Detecting and Explaining Dependencies in Execution Traces

1994 ◽  
pp. 71-77 ◽  
Author(s):  
Adele E. Howe ◽  
Paul R. Cohen
Keyword(s):  
Execution Traces

scholarly journals Mining Message Flows from System-on-Chip Execution Traces

2021 ◽  
Author(s):  
Md Rubel Ahmed ◽  
Hao Zheng ◽  
Parijat Mukherjee ◽  
Mahesh C. Ketkar ◽  
Jin Yang
Keyword(s):  
System On Chip ◽  
Execution Traces ◽  
On Chip

scholarly journals From parametric trace slicing to rule systems

2021 ◽  
Author(s):  
Giles Reger ◽  
David Rydeheard
Keyword(s):  
Runtime Verification ◽  
Specification Languages ◽  
Execution Traces ◽  
Running System ◽  
Proof Of Correctness ◽  
Rule Systems ◽  
The Relationship ◽  
Specification Techniques ◽  
Previous Conference

AbstractParametric runtime verification is the process of verifying properties of execution traces of (data carrying) events produced by a running system. This paper continues our work exploring the relationship between specification techniques for parametric runtime verification. Here we consider the correspondence between trace-slicing automata-based approaches and rule systems. The main contribution is a translation from quantified automata to rule systems, which has been implemented in Scala. This then allows us to highlight the key differences in how the two formalisms handle data, an important step in our wider effort to understand the correspondence between different specification languages for parametric runtime verification. This paper extends a previous conference version of this paper with further examples, a proof of correctness, and an optimisation based on a notion of redundancy observed during the development of the translation.

Mining Patterns from Concurrent Execution Traces

2021 ◽  
pp. 1-1
Author(s):  
Md Rubel Ahmed ◽  
Hao Zheng ◽  
Parijat Mukherjee ◽  
Mahesh C. Ketkar ◽  
Jin Yang
Keyword(s):  
Concurrent Execution ◽  
Execution Traces

scholarly journals Cube data model for multilevel statistics computation of live execution traces

2014 ◽  
Vol 27 (5) ◽  
pp. 1069-1091 ◽  
Author(s):  
Naser Ezzati-Jivan ◽  
Michel R. Dagenais
Keyword(s):  
Data Model ◽  
Execution Traces

Whole Execution Traces and Their Use in Debugging

2007 ◽  
pp. 4-1-4-17 ◽  
Author(s):  
Xiangyu Zhang ◽  
Neelam Gupta ◽  
Rajiv Gupta
Keyword(s):  
Execution Traces

scholarly journals Daisen: A Framework for Visualizing Detailed GPU Execution

2021 ◽  
Author(s):  
Yifan Sun ◽  
Yixuan Zhang ◽  
Ali Mosallaei ◽  
Michael D. Shah ◽  
Cody Dunne ◽  
...  
Keyword(s):  
Performance Analysis ◽  
Performance Improvement ◽  
Graphics Processing Units ◽  
Qualitative Evaluation ◽  
Evaluation Study ◽  
Survey Study ◽  
Performance Bottlenecks ◽  
Making Sense ◽  
Execution Traces ◽  
Physics Simulation

Graphics Processing Units~(GPUs) have been widely used to accelerate artificial intelligence, physics simulation, medical imaging, and information visualization applications. To improve GPU performance, GPU hardware designers need to identify performance issues by inspecting a huge amount of simulator-generated traces. Visualizing the execution traces can reduce the cognitive burden of users and facilitate making sense of behaviors of GPU hardware components. In this paper, we first formalize the process of GPU performance analysis and characterize the design requirements of visualizing execution traces based on a survey study and interviews with GPU hardware designers. We contribute data and task abstraction for GPU performance analysis. Based on our task analysis, we propose Daisen, a framework that supports data collection from GPU simulators and provides visualization of the simulator-generated GPU execution traces. Daisen features a data abstraction and trace format that can record simulator-generated GPU execution traces. Daisen also includes a web-based visualization tool that helps GPU hardware designers examine GPU execution traces, identify performance bottlenecks, and verify performance improvement. Our qualitative evaluation with GPU hardware designers demonstrates that the design of Daisen reflects the typical workflow of GPU hardware designers. Using Daisen, participants were able to effectively identify potential performance bottlenecks and opportunities for performance improvement. The open-sourced implementation of Daisen can be found at gitlab.com/akita/vis. Supplemental materials including a demo video, survey questions, evaluation study guide, and post-study evaluation survey are available at osf.io/j5ghq.

scholarly journals Distributed Architecture for an Integrated Development Environment, Large Trace Analysis, and Visualization

Sensors ◽  
2021 ◽  
Vol 21 (16) ◽  
pp. 5560
Author(s):  
Yonni Chen Kuang Piao ◽  
Naser Ezzati-jivan ◽  
Michel R. Dagenais
Keyword(s):  
Programming Languages ◽  
Trace Analysis ◽  
Development Environment ◽  
Integrated Development ◽  
Resource Limitations ◽  
Execution Traces ◽  
Integrated Development Environments ◽  
Visualization Tools ◽  
Iot Devices ◽  
Server Architecture

Integrated development environments (IDEs) provide many useful tools such as a code editor, a compiler, and a debugger for creating software. These tools are highly sophisticated, and their development requires a significant effort. Traditionally, an IDE supports different programming languages via plugins that are not usually reusable in other IDEs. Given the high complexity and constant evolution of popular programming languages, such as C++ and even Java, the effort to update those plugins has become unbearable. Thus, recent work aims to modularize IDEs and reuse the existing parser implementation directly in compilers. However, when IDE debugging tools are insufficient at detecting performance defects in large and multithreaded systems, developers must use tracing and trace visualization tools in their software development process. Those tools are often standalone applications and do not interoperate with the new modular IDEs, thus losing the power and the benefits of many features provided by the IDE. The structure and use cases of tracing tools, with the potentially massive execution traces, significantly differ from the other tools in IDEs. Thus, it is a considerable challenge, one which has not been addressed previously, to integrate them into the new modular IDEs. In this paper, we propose an efficient modular client–server architecture for trace analysis and visualization that solves those problems. The proposed architecture is well suited for performance analysis on Internet of Things (IoT) devices, where resource limitations often prohibit data collection, processing, and visualization all on the same device. The experimental evaluation demonstrated that our proposed flexible and reusable solution is scalable and has a small acceptable performance overhead compared to the standalone approach.

Sign in / Sign up

Export Citation Format

Share Document