Optimally profiling and tracing programs

@article{Ball1994OptimallyPA,
  title={Optimally profiling and tracing programs},
  author={Thomas Ball and James R. Larus},
  journal={ACM Trans. Program. Lang. Syst.},
  year={1994},
  volume={16},
  pages={1319-1360}
}
  • T. Ball, J. Larus
  • Published 1994
  • Computer Science
  • ACM Trans. Program. Lang. Syst.
This paper describes algorithms for inserting monitoring code to profile and trace programs. These algorithms greatly reduce the cost of measuring programs with respect to the commonly used technique of placing code in each basic block. Program profiling counts the number of times each basic block in a program executes. Instruction tracing records the sequence of basic blocks traversed in a program execution. The algorithms optimize the placement of counting/tracing code with respect to the… Expand
Optimally profiling and tracing programs
TLDR
Algorithms for inserting monitoring code to profile and trace programs that greatly reduce the cost of measuring programs and reduce the file size and overhead of an already highly optimized tracing system are presented. Expand
Toward abstract profiling
Profiling is a well-known technique in program analysis with many applications in compiler optimization. However, traditional profiling often requires instrumentation and execution of programs asExpand
Hardware-assisted instruction profiling and latency detection
TLDR
The authors analyse state-of-the-art hardware-tracing support, as provided in modern Intel processors and propose a new technique which uses the processor hardware for tracing without any code instrumentation or tracepoints, observing that hardware-based tracing has a much reduced overhead, while achieving greater precision. Expand
The use of control-flow and control dependence in software tools
TLDR
Algorithms for profiling and tracing programs that use a combination of control-flow analysis and program instrumentation to produce exact profiles and traces with low run-time overhead are described. Expand
Efficient path profiling
  • T. Ball, J. Larus
  • Computer Science
  • Proceedings of the 29th Annual IEEE/ACM International Symposium on Microarchitecture. MICRO 29
  • 1996
TLDR
A new algorithm for path profiling is described, which selects and places profile instrumentation to minimize run-time overhead and identifies longer paths than a previous technique, which predicted paths from edge profiles. Expand
Path-based compilation
TLDR
This thesis shows how to collect path profiles efficiently, then applies the path profiles to two optimizations, static correlated branch prediction and path-based superblock scheduling, which address different performance aspects of modern machines. Expand
Profiling All Paths
TLDR
A new profiling technique called PAP (profiling all paths), which can profile finite-length paths inside a procedural and how to use PAP to profile executed sequences on the method level is discussed. Expand
Hardware-Software Collaborative Techniques for Runtime Profiling and Phase Transition Detection
TLDR
A new profiling technique is proposed, that incorporates the strength of both software and hardware to achieve near-zero overhead profiling, that is believed that the hardware-software collaborative scheme will enable many profile-driven dynamic optimizations for EPIC processors such as the Itanium processors. Expand
Efficient memory tracing by program skeletonization
  • A. Ketterlin, P. Clauss
  • Computer Science
  • (IEEE ISPASS) IEEE INTERNATIONAL SYMPOSIUM ON PERFORMANCE ANALYSIS OF SYSTEMS AND SOFTWARE
  • 2011
TLDR
This paper describes how static analysis of the binary code can be used to reduce the amount of instrumentation, by transforming the original executable into a skeleton program that consumes base register values and produces memory addresses. Expand
Exploiting hardware performance counters with flow and context sensitive profiling
TLDR
This paper extends previous work on efficient path profiling to flow sensitive profiling, which associates hardware performance metrics with a path through a procedure, and describes a data structure, the calling context tree, that efficiently captures calling contexts for procedure-level measurements. Expand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 52 REFERENCES
Optimally profiling and tracing programs
TLDR
Algorithms for inserting monitoring code to profile and trace programs that greatly reduce the cost of measuring programs and reduce the file size and overhead of an already highly optimized tracing system are presented. Expand
Profile-Driven Compilation
TLDR
TYPESETTER is a programming system that utilizes profile data to select implementations of program abstractions and integrates the development, evaluation, and selection of alternative implementations of programming abstractions into a package that is transparent to the programmer. Expand
Techniques for debugging parallel programs with flowback analysis
TLDR
PPD uses a static program dependence graph structure that reduces the amount of work done at compile time and takes advantage of the dynamic information produced during execution time, and uses semantic analysis and a technique called incremental tracing to keep the time and space overhead low. Expand
Optimal Insertion of Software Probes in Well-Delimited Programs
  • R. Probert
  • Computer Science
  • IEEE Transactions on Software Engineering
  • 1982
TLDR
Assuming all control constructs are explicitly delimited, for example, by END IF or equivalent statements, an easily programmed method is given for inserting a minimum number of probes for monitoring statement and branch execution counts without disrupting source code structure or paragraphing. Expand
Profile guided code positioning
TLDR
This paper presents the results of the investigation of code positioning techniques using execution profile data as input into the compilation process to reduce the overhead of the instruction memory hierarchy. Expand
Efficient program tracing
TLDR
Two tracing systems based on abstract execution and optimal control tracing techniques are presented and results collected when using the later systems on several programs show significant reductions in the cost of collecting traces. Expand
Optimal code for control structures
TLDR
This paper presents an algorithm that finds an ordering of the basic blocks of a program that is optimal with respect to the number of jumps, provided the program is constructed using only the “structured” control structures if–then-else, loop, and exit. Expand
An execution profiler for modular programs
TLDR
The central idea is that the execution time for a routine is charged to the routines that call it, and the techniques used to gather the necessary information about the timing and structure of the program are given, as is the processing used to propagate routine execution times along arcs of the call graph of the programs. Expand
Procedure merging with instruction caches
This paper describes a method of determining which procedures to merge for machines with instruction caches. The method uses profile information, the structure of the program, the cache size, and theExpand
Branch prediction for free
TLDR
This work presents a program-based branch predictor that performs well for a large and diverse set of programs written in C and Fortran and focuses on heuristics for predicting non-loop branches, which dominate the dynamic branch count of many programs. Expand
...
1
2
3
4
5
...