How Can We Accurately Measure Function Exit Times in Performance Profiling Beyond Using `__gnu_mcount_nc`?

Determining Function Exit Time with __gnu_mcount_nc

In an attempt to perform performance profiling on an embedded platform, it has been noted that the GCC's -pg flag inserts thunks to __gnu_mcount_nc on entry to every function. While no implementation of __gnu_mcount_nc is readily available, custom implementations that record the stack frame and current cycle count have proven useful in gathering caller/callee graphs and identifying frequently called functions.

However, capturing information about the time spent within function bodies remains a challenge solely based on entry points. Existing approaches, such as maintaining a shadow callstack and manipulating the return address, introduce limitations and overhead.

To address the question of an alternative __gnu_mcount_nc implementation that enables capturing function exit times, let's delve into the actual approach used by gprof.

How gprof Measures Function Time

Contrary to initial assumptions, gprof does not use __gnu_mcount_nc for timing function entry or exit. Instead, it relies on self-time gathered by counting PC samples in each routine. These samples are then used, along with the function-to-function call counts, to estimate the portion of self-time that should be attributed to callers.

Call-Counting vs. Stack-Sampling

Another approach is stack-sampling, which involves capturing a sample of the stack at regular intervals. While more expensive than PC-sampling, it provides more accurate measurements since it does not distinguish between short and long calls, nor is it affected by I/O or uninstrumented library routines.

Identifying Costly Operations

The key to finding performance bottlenecks lies in analyzing raw stack samples and relating them to the source code. As opposed to focusing on call graphs or hot-spots, examining individual stack samples can reveal the specific reasons why certain operations consume significant time and suggest possible optimizations.

Beyond Fancy Visualizations

While visualizations such as flame graphs and tree maps can be visually appealing, they often fail to highlight performance issues that stem from code being called numerous times from different locations. Aggregating and sorting data by function, rather than solely based on time, provides a more comprehensive view of code execution.

Conclusion

While __gnu_mcount_nc can provide valuable information about function entry points, alternative methods like stack-sampling should be considered for capturing function exit times. By focusing on analyzing actual stack samples and avoiding distractions from eye-catching visualizations, developers can effectively identify performance bottlenecks and implement optimizations.

The above is the detailed content of How Can We Accurately Measure Function Exit Times in Performance Profiling Beyond Using `__gnu_mcount_nc`?. For more information, please follow other related articles on the PHP Chinese website!