Menu
Home
People
Places
Arts
History
Plants & Animals
Science
Life & Culture
Technology
Reference.org
Profiling (computer programming)
open-in-new
<h2 id="gathering-program-events">Gathering program events</h2> <p>Profilers use a wide variety of techniques to collect data, including <a href="/facts/Hardware_interrupt/Mm6C4rpc">hardware interrupts</a>, <a href="/facts/Instrumentation_(computer_programming)/XXmEttjR">code instrumentation</a>, <a href="/facts/Instruction_set_simulator/kz2WRgjb">instruction set simulation</a>, operating system <a href="/facts/Hooking/FJlTwAmd">hooks</a>, and <a href="/facts/Hardware_performance_counter/gVe7AyKQ">performance counters</a>. </p> <h2 id="use-of-profilers">Use of profilers</h2> <blockquote><p>Program analysis tools are extremely important for understanding program behavior. Computer architects need such tools to evaluate how well programs will perform on new <a href="/facts/Computer_architecture/tHtwxgR2">architectures</a>. Software writers need tools to analyze their programs and identify critical sections of code. <a href="/facts/Compiler/WNfCDFJe">Compiler</a> writers often use such tools to find out how well their <a href="/facts/Instruction_scheduling/5GuldkLY">instruction scheduling</a> or <a href="/facts/Branch_prediction/pGPhFMj5">branch prediction</a> algorithm is performing...</p>— ATOM, <a href="/facts/Conference_on_Programming_Language_Design_and_Implementation/4Hn10W0u">PLDI</a></blockquote> <p>The output of a profiler may be: </p> <ul><li>A statistical <i>summary</i> of the events observed (a profile)</li></ul> Summary profile information is often shown annotated against the source code statements where the events occur, so the size of measurement data is linear to the code size of the program. /* ------------ source------------------------- count */ 0001 IF X = "A" 0055 0002 THEN DO 0003 ADD 1 to XCOUNT 0032 0004 ELSE 0005 IF X = "B" 0055 <ul><li>A stream of recorded events (a trace)</li></ul> For sequential programs, a summary profile is usually sufficient, but performance problems in parallel programs (waiting for messages or synchronization issues) often depend on the time relationship of events, thus requiring a full trace to get an understanding of what is happening. The size of a (full) trace is linear to the program's <a href="/facts/Instruction_path_length/Wk4jdu67">instruction path length</a>, making it somewhat impractical. A trace may therefore be initiated at one point in a program and terminated at another point to limit the output. <ul><li>An ongoing interaction with the <a href="/facts/Hypervisor/3gX9fKlH">hypervisor</a> (continuous or periodic monitoring via on-screen display for instance)</li></ul> This provides the opportunity to switch a trace on or off at any desired point during execution in addition to viewing on-going metrics about the (still executing) program. It also provides the opportunity to suspend asynchronous processes at critical points to examine interactions with other parallel processes in more detail. <p>A profiler can be applied to an individual method or at the scale of a module or program, to identify performance bottlenecks by making long-running code obvious.<a class="footnote-ref" id="fnref:1" href="#fn:1"><sup>1</sup></a> A profiler can be used to understand code from a timing point of view, with the objective of optimizing it to handle various runtime conditions<a class="footnote-ref" id="fnref:2" href="#fn:2"><sup>2</sup></a> or various loads.<a class="footnote-ref" id="fnref:3" href="#fn:3"><sup>3</sup></a> Profiling results can be ingested by a compiler that provides <a href="/facts/Profile-guided_optimization/u9ej9s76">profile-guided optimization</a>.<a class="footnote-ref" id="fnref:4" href="#fn:4"><sup>4</sup></a> Profiling results can be used to guide the design and optimization of an individual algorithm; the <a href="/facts/Krauss_matching_wildcards_algorithm/xBFgmIgr">Krauss matching wildcards algorithm</a> is an example.<a class="footnote-ref" id="fnref:5" href="#fn:5"><sup>5</sup></a> Profilers are built into some <a href="/facts/Application_performance_management/3XI0tuSy">application performance management</a> systems that aggregate profiling data to provide insight into <a href="/facts/Transaction_processing/Q0WHeD9R">transaction</a> workloads in <a href="/facts/Distributed_computing/o5nyhqTF">distributed</a> applications.<a class="footnote-ref" id="fnref:6" href="#fn:6"><sup>6</sup></a> </p> <h2 id="history">History</h2> <p>Performance-analysis tools existed on <a href="/facts/IBM%2f360/7znvpy4K">IBM/360</a> and <a href="/facts/IBM%2f370/TRo1jaFw">IBM/370</a> platforms from the early 1970s, usually based on timer interrupts which recorded the <a href="/facts/Program_status_word/ejBFel3W">program status word</a> (PSW) at set timer-intervals to detect "hot spots" in executing code. This was an early example of <a href="/facts/Sampling_(statistics)/kIb01xdL">sampling</a> (see below). In early 1974 <a href="/facts/Instruction_Set_Simulator/kz2WRgjb">instruction-set simulators</a> permitted full trace and other performance-monitoring features. </p><p>Profiler-driven program analysis on Unix dates back to 1973,<a class="footnote-ref" id="fnref:7" href="#fn:7"><sup>7</sup></a> when Unix systems included a basic tool, prof, which listed each function and how much of program execution time it used. In 1982 gprof extended the concept to a complete <a href="/facts/Call_graph/Uk0b0mdN">call graph</a> analysis.<a class="footnote-ref" id="fnref:8" href="#fn:8"><sup>8</sup></a> </p><p>In 1994, Amitabh Srivastava and <a href="/facts/Alan_Eustace/I3mygxYm">Alan Eustace</a> of <a href="/facts/Digital_Equipment_Corporation/ztxs6keA">Digital Equipment Corporation</a> published a paper describing ATOM<a class="footnote-ref" id="fnref:9" href="#fn:9"><sup>9</sup></a> (Analysis Tools with OM). The ATOM platform converts a program into its own profiler: at <a href="/facts/Compile_time/yCdI3oqn">compile time</a>, it inserts code into the program to be analyzed. That inserted code outputs analysis data. This technique - modifying a program to analyze itself - is known as "<a href="/facts/Instrumentation_(computer_programming)/XXmEttjR">instrumentation</a>". </p><p>In 2004 both the gprof and ATOM papers appeared on the list of the 50 most influential <a href="/facts/Conference_on_Programming_Language_Design_and_Implementation/4Hn10W0u">PLDI</a> papers for the 20-year period ending in 1999.<a class="footnote-ref" id="fnref:10" href="#fn:10"><sup>10</sup></a> </p> <h2 id="profiler-types-based-on-output">Profiler types based on output</h2> <h3>Flat profiler</h3> <p>Flat profilers compute the average call times, from the calls, and do not break down the call times based on the callee or the context. </p> <h3>Call-graph profiler</h3> <p><a href="/facts/Call_graph/Uk0b0mdN">Call graph</a> profilers<a class="footnote-ref" id="fnref:11" href="#fn:11"><sup>11</sup></a> show the call times, and frequencies of the functions, and also the call-chains involved based on the callee. In some tools full context is not preserved. </p> <h3>Input-sensitive profiler</h3> <p>Input-sensitive profilers<a class="footnote-ref" id="fnref:12" href="#fn:12"><sup>12</sup></a><a class="footnote-ref" id="fnref:13" href="#fn:13"><sup>13</sup></a><a class="footnote-ref" id="fnref:14" href="#fn:14"><sup>14</sup></a> add a further dimension to flat or call-graph profilers by relating performance measures to features of the input workloads, such as input size or input values. They generate charts that characterize how an application's performance scales as a function of its input. </p> <h2 id="data-granularity-in-profiler-types">Data granularity in profiler types</h2> <p>Profilers, which are also programs themselves, analyze target programs by collecting information on the target program's execution. Based on their data granularity, which depends upon how profilers collect information, they are classified as <i>event-based</i> or <i>statistical</i> profilers. Profilers interrupt program execution to collect information. Those interrupts can limit time measurement resolution, which implies that timing results should be taken with a grain of salt. <a href="/facts/Basic_block/HPL1Nkvs">Basic block</a> profilers report a number of machine <a href="/facts/Cycles_per_instruction/bUSCaRPM">clock cycles</a> devoted to executing each line of code, or timing based on adding those together; the timings reported per basic block may not reflect a difference between <a href="/facts/CPU_cache/x8BYFcdv">cache</a> hits and misses.<a class="footnote-ref" id="fnref:15" href="#fn:15"><sup>15</sup></a><a class="footnote-ref" id="fnref:16" href="#fn:16"><sup>16</sup></a> </p> <h3>Event-based profilers</h3> <p>Event-based profilers are available for the following programming languages: </p> <ul><li><a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a>: the <a href="/facts/Java_Virtual_Machine_Tools_Interface/9Q35TcFj">JVMTI</a> (JVM Tools Interface) API, formerly JVMPI (JVM Profiling Interface), provides hooks to profilers, for trapping events like calls, class-load, unload, thread enter leave.</li> <li><a href="/facts/.NET_Framework/J6QDAUhP">.NET</a>: Can attach a profiling agent as a <i>COM</i> server to the <i>CLR</i> using Profiling <i>API</i>. Like Java, the runtime then provides various callbacks into the agent, for trapping events like method <a href="/facts/Interpreter/7NxWE3xS">JIT</a> / enter / leave, object creation, etc. Particularly powerful in that the profiling agent can rewrite the target application's bytecode in arbitrary ways.</li> <li><a href="/facts/Python_(programming_language)/YbuGqofa">Python</a>: Python profiling includes the profile module, hotshot (which is call-graph based), and using the 'sys.setprofile' function to trap events like c_{call,return,exception}, python_{call,return,exception}.</li> <li><a href="/facts/Ruby_(programming_language)/BeYSaPSR">Ruby</a>: Ruby also uses a similar interface to Python for profiling. Flat-profiler in profile.rb, module, and ruby-prof a C-extension are present.</li></ul> <h3>Statistical profilers</h3> <p>These profilers operate by <a href="/facts/Sampling_(statistics)/kIb01xdL">sampling</a>. A sampling profiler probes the target program's <a href="/facts/Call_stack/1sMt713v">call stack</a> at regular intervals using <a href="/facts/Operating_system/8XTuvMh2">operating system</a> <a href="/facts/Interrupt/Mm6C4rpc">interrupts</a>. Sampling profiles are typically less numerically accurate and specific, providing only a statistical approximation, but allow the target program to run at near full speed. "The actual amount of error is usually more than one sampling period. In fact, if a value is n times the sampling period, the expected error in it is the square-root of n sampling periods."<a class="footnote-ref" id="fnref:17" href="#fn:17"><sup>17</sup></a> </p><p>In practice, sampling profilers can often provide a more accurate picture of the target program's execution than other approaches, as they are not as intrusive to the target program and thus don't have as many side effects (such as on memory caches or instruction decoding pipelines). Also since they don't affect the execution speed as much, they can detect issues that would otherwise be hidden. They are also relatively immune to over-evaluating the cost of small, frequently called routines or 'tight' loops. They can show the relative amount of time spent in user mode versus interruptible kernel mode such as <a href="/facts/System_call/NW44AFJr">system call</a> processing. </p><p>Unfortunately, running kernel code to handle the interrupts incurs a minor loss of CPU cycles from the target program, diverts cache usage, and cannot distinguish the various tasks occurring in uninterruptible kernel code (microsecond-range activity) from user code. Dedicated hardware can do better: ARM Cortex-M3 and some recent MIPS processors' JTAG interfaces have a PCSAMPLE register, which samples the <a href="/facts/Program_counter/BxqulBRq">program counter</a> in a truly undetectable manner, allowing non-intrusive collection of a flat profile. </p><p>Some commonly used<a class="footnote-ref" id="fnref:18" href="#fn:18"><sup>18</sup></a> statistical profilers for Java/managed code are <a href="/facts/SmartBear_Software/rlE78srr">SmartBear Software</a>'s <a href="/facts/AQtime/pgJU6Axg">AQtime</a><a class="footnote-ref" id="fnref:19" href="#fn:19"><sup>19</sup></a> and <a href="/facts/Microsoft/nGIDDXdx">Microsoft</a>'s <a href="/facts/CLR_Profiler/p2KUmByC">CLR Profiler</a>.<a class="footnote-ref" id="fnref:20" href="#fn:20"><sup>20</sup></a> Those profilers also support native code profiling, along with <a href="/facts/Apple_Inc./oTJYta3k">Apple Inc.</a>'s <a href="/facts/Apple_Developer_Tools/mJdDT5SJ">Shark</a> (OSX),<a class="footnote-ref" id="fnref:21" href="#fn:21"><sup>21</sup></a> <a href="/facts/OProfile/e0FJRfuz">OProfile</a> (Linux),<a class="footnote-ref" id="fnref:22" href="#fn:22"><sup>22</sup></a> <a href="/facts/Intel/SMF0gJJX">Intel</a> <a href="/facts/VTune/JX3Saa0h">VTune</a> and Parallel Amplifier (part of <a href="/facts/Intel_Parallel_Studio/SPL6qbvj">Intel Parallel Studio</a>), and <a href="/facts/Oracle_Corporation/0z14FygH">Oracle</a> <a href="/facts/Performance_Analyzer/LubbVe5e">Performance Analyzer</a>,<a class="footnote-ref" id="fnref:23" href="#fn:23"><sup>23</sup></a> among others. </p> <h3>Instrumentation</h3> <p>This technique effectively adds instructions to the target program to collect the required information. Note that <a href="/facts/Instrumenting/XXmEttjR">instrumenting</a> a program can cause performance changes, and may in some cases lead to inaccurate results and/or <a href="/facts/Heisenbug/5THWh0k2">heisenbugs</a>. The effect will depend on what information is being collected, on the level of timing details reported, and on whether basic block profiling is used in conjunction with instrumentation.<a class="footnote-ref" id="fnref:24" href="#fn:24"><sup>24</sup></a> For example, adding code to count every procedure/routine call will probably have less effect than counting how many times each statement is obeyed. A few computers have special hardware to collect information; in this case the impact on the program is minimal. </p><p>Instrumentation is key to determining the level of control and amount of time resolution available to the profilers. </p> <ul><li>Manual: Performed by the programmer, e.g. by adding instructions to explicitly calculate runtimes, simply count events or calls to measurement <a href="/facts/API/GMlN4vUr">APIs</a> such as the <a href="/facts/Application_Response_Measurement/ANGXynVU">Application Response Measurement</a> standard.</li> <li>Automatic source level: instrumentation added to the source code by an automatic tool according to an instrumentation policy.</li> <li>Intermediate language: instrumentation added to <a href="/facts/Assembly_language/7XuV0cla">assembly</a> or decompiled <a href="/facts/Bytecode/EPkMFR7M">bytecodes</a> giving support for multiple higher-level source languages and avoiding (non-symbolic) binary offset re-writing issues.</li> <li>Compiler assisted</li> <li>Binary translation: The tool adds instrumentation to a compiled <a href="/facts/Executable/VSst9eLA">executable</a>.</li> <li>Runtime instrumentation: Directly before execution the code is instrumented. The program run is fully supervised and controlled by the tool.</li> <li>Runtime injection: More lightweight than runtime instrumentation. Code is modified at runtime to have jumps to helper functions.</li></ul> <h3>Interpreter instrumentation</h3> <ul><li>Interpreter debug options can enable the collection of performance metrics as the interpreter encounters each target statement. A <a href="/facts/Bytecode/EPkMFR7M">bytecode</a>, <a href="/facts/Control_table/AMkFG0mQ">control table</a> or <a href="/facts/Just-in-time_compilation/rEYDsd8l">JIT</a> interpreters are three examples that usually have complete control over execution of the target code, thus enabling extremely comprehensive data collection opportunities.</li></ul> <h3>Hypervisor/simulator</h3> <ul><li>Hypervisor: Data are collected by running the (usually) unmodified program under a <a href="/facts/Hypervisor/3gX9fKlH">hypervisor</a>. Example: <a href="/facts/SIMMON/eozb6Jkn">SIMMON</a></li> <li>Simulator and Hypervisor: Data collected interactively and selectively by running the unmodified program under an <a href="/facts/Instruction_set_simulator/kz2WRgjb">instruction set simulator</a>.</li></ul> <h2 id="see-also">See also</h2> <ul><li><a href="/facts/Algorithmic_efficiency/VutjvPTd">Algorithmic efficiency</a> – amount of computational resources used by an algorithmPages displaying wikidata descriptions as a fallback</li> <li><a href="/facts/Benchmark_(computing)/XSS42cRe">Benchmark</a> – Standardized performance evaluation</li> <li><a href="/facts/Java_performance/Grb7EJKn">Java performance</a> – Aspect of Java programming language</li> <li><a href="/facts/List_of_performance_analysis_tools/acwRDnor">List of performance analysis tools</a></li> <li><a href="/facts/Performance_Application_Programming_Interface/yqrowXRl">PAPI</a> – Software library for microprocessor metrics</li> <li><a href="/facts/Performance_engineering/opjKPvhH">Performance engineering</a> – Encompasses the techniques applied during a systems development life cycle</li> <li><a href="/facts/Performance_prediction/2BQafHLN">Performance prediction</a></li> <li><a href="/facts/Performance_tuning/SRkRTmVr">Performance tuning</a> – tuning a computer system to improve its performancePages displaying wikidata descriptions as a fallback</li> <li><a href="/facts/Runtime_verification/pRHEYoDz">Runtime verification</a> – extraction of information from a running system to verify certain propertiesPages displaying wikidata descriptions as a fallback</li> <li><a href="/facts/Profile-guided_optimization/u9ej9s76">Profile-guided optimization</a> – Compiler optimization technique</li> <li><a href="/facts/Static_code_analysis/b56nr6QM">Static code analysis</a> – Analysis of computer programs without executing themPages displaying short descriptions of redirect targets</li> <li><a href="/facts/Software_archaeology/evsYf5qk">Software archaeology</a> – study of poorly documented or undocumented legacy software implementationsPages displaying wikidata descriptions as a fallback</li> <li><a href="/facts/Worst-case_execution_time/PQfFMtGx">Worst-case execution time</a> – maximum length of time a computed task could take to executePages displaying wikidata descriptions as a fallback (WCET)</li></ul> <h2 id="external-links">External links</h2> <ul><li>Article "<a href="http://www.ibm.com/developerworks/rational/library/05/1004_gupta/">Need for speed — Eliminating performance bottlenecks</a>" on doing execution time analysis of Java applications using IBM Rational Application Developer.</li> <li><a href="http://software.intel.com/sites/products/documentation/hpc/vtune/windows/jit_profiling.pdf">Profiling Runtime Generated and Interpreted Code using the VTune Performance Analyzer</a></li></ul> <h2 id="references">References</h2> <ol> <li id="fn:1"><p>"How to find the performance bottleneck in C# desktop application?". Stack Overflow. 2012. <a href="https://stackoverflow.com/questions/13698674/how-to-find-the-performance-bottleneck-in-c-sharp-desktop-application" target="_blank">https://stackoverflow.com/questions/13698674/how-to-find-the-performance-bottleneck-in-c-sharp-desktop-application</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li> <li id="fn:2"><p>Krauss, Kirk J (2017). "Performance Profiling with a Focus". Develop for Performance. <a href="http://www.developforperformance.com/PerformanceProfilingWithAFocus.html" target="_blank">http://www.developforperformance.com/PerformanceProfilingWithAFocus.html</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li> <li id="fn:3"><p>"What is code profiling? Learn the 3 Types of Code Profilers". Stackify Developer Tips, Tricks and Resources. Disqus. 2016. <a href="https://stackify.com/what-is-code-profiling/" target="_blank">https://stackify.com/what-is-code-profiling/</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li> <li id="fn:4"><p>Lawrence, Eric (2016). "Getting Started with Profile Guided Optimization". testslashplain. WordPress. <a href="https://textslashplain.com/2016/01/10/getting-started-with-profile-guided-optimization/" target="_blank">https://textslashplain.com/2016/01/10/getting-started-with-profile-guided-optimization/</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li> <li id="fn:5"><p>Krauss, Kirk (2018). "Matching Wildcards: An Improved Algorithm for Big Data". Develop for Performance. <a href="http://www.developforperformance.com/MatchingWildcards_AnImprovedAlgorithmForBigData.html" target="_blank">http://www.developforperformance.com/MatchingWildcards_AnImprovedAlgorithmForBigData.html</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></p></li> <li id="fn:6"><p>"List of .Net Profilers: 3 Different Types and Why You Need All of Them". Stackify Developer Tips, Tricks and Resources. Disqus. 2016. <a href="https://stackify.com/three-types-of-net-profilers/" target="_blank">https://stackify.com/three-types-of-net-profilers/</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></p></li> <li id="fn:7"><p>Unix Programmer's Manual, 4th Edition <a href="http://www.tuhs.org/Archive/Distributions/Research/Dennis_v4/v4man.tar.gz" target="_blank">http://www.tuhs.org/Archive/Distributions/Research/Dennis_v4/v4man.tar.gz</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></p></li> <li id="fn:8"><p>S.L. Graham, P.B. Kessler, and M.K. McKusick, gprof: a Call Graph Execution Profiler, Proceedings of the SIGPLAN '82 Symposium on Compiler Construction, SIGPLAN Notices, Vol. 17, No 6, pp. 120-126; doi:10.1145/800230.806987 <a href="http://docs.freebsd.org/44doc/psd/18.gprof/paper.pdf" target="_blank">http://docs.freebsd.org/44doc/psd/18.gprof/paper.pdf</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></p></li> <li id="fn:9"><p>A. Srivastava and A. Eustace, ATOM: A system for building customized program analysis tools, Proceedings of the ACM SIGPLAN Conference on Programming language design and implementation (PLDI '94), pp. 196-205, 1994; ACM SIGPLAN Notices - Best of PLDI 1979-1999 Homepage archive, Vol. 39, No. 4, pp. 528-539; doi:10.1145/989393.989446 <a href="http://www.ece.cmu.edu/~ece548/tools/atom/man/wrl_94_2.pdf" target="_blank">http://www.ece.cmu.edu/~ece548/tools/atom/man/wrl_94_2.pdf</a> <a href="#fnref:9" class="footnote-back-ref">↩</a></p></li> <li id="fn:10"><p>20 Years of PLDI (1979–1999): A Selection, Kathryn S. McKinley, Editor <a href="http://www.cs.utexas.edu/users/mckinley/20-years.html" target="_blank">http://www.cs.utexas.edu/users/mckinley/20-years.html</a> <a href="#fnref:10" class="footnote-back-ref">↩</a></p></li> <li id="fn:11"><p>S.L. Graham, P.B. Kessler, and M.K. McKusick, gprof: a Call Graph Execution Profiler, Proceedings of the SIGPLAN '82 Symposium on Compiler Construction, SIGPLAN Notices, Vol. 17, No 6, pp. 120-126; doi:10.1145/800230.806987 <a href="http://docs.freebsd.org/44doc/psd/18.gprof/paper.pdf" target="_blank">http://docs.freebsd.org/44doc/psd/18.gprof/paper.pdf</a> <a href="#fnref:11" class="footnote-back-ref">↩</a></p></li> <li id="fn:12"><p>E. Coppa, C. Demetrescu, and I. Finocchi, Input-Sensitive Profiling, IEEE Trans. Software Eng. 40(12): 1185-1205 (2014); doi:10.1109/TSE.2014.2339825 <a href="https://web.archive.org/web/20180611201601/https://ieeexplore.ieee.org/document/6858059/" target="_blank">https://web.archive.org/web/20180611201601/https://ieeexplore.ieee.org/document/6858059/</a> <a href="#fnref:12" class="footnote-back-ref">↩</a></p></li> <li id="fn:13"><p>D. Zaparanuks and M. Hauswirth, Algorithmic Profiling, Proceedings of the 33rd ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2012), ACM SIGPLAN Notices, Vol. 47, No. 6, pp. 67-76, 2012; doi:10.1145/2254064.2254074 <a href="//doi.org/10.1145/2254064.2254074" target="_blank">//doi.org/10.1145/2254064.2254074</a> <a href="#fnref:13" class="footnote-back-ref">↩</a></p></li> <li id="fn:14"><p>T. Kustner, J. Weidendorfer, and T. Weinzierl, Argument Controlled Profiling, Proceedings of Euro-Par 2009 – Parallel Processing Workshops, Lecture Notes in Computer Science, Vol. 6043, pp. 177-184, 2010; doi:10.1007/978-3-642-14122-5 22 <a href="//doi.org/10.1007/978-3-642-14122-5_22" target="_blank">//doi.org/10.1007/978-3-642-14122-5_22</a> <a href="#fnref:14" class="footnote-back-ref">↩</a></p></li> <li id="fn:15"><p>"Timing and Profiling - Basic Block Profilers". OpenStax CNX Archive. <a href="https://archive.cnx.org/contents/d29c016a-2960-4fc9-b431-9eda881a28f5@3/timing-and-profiling-basic-block-profilers#id6897344" target="_blank">https://archive.cnx.org/contents/d29c016a-2960-4fc9-b431-9eda881a28f5@3/timing-and-profiling-basic-block-profilers#id6897344</a> <a href="#fnref:15" class="footnote-back-ref">↩</a></p></li> <li id="fn:16"><p>Ball, Thomas; Larus, James R. (1994). "Optimally profiling and tracing programs" (PDF). ACM Transactions on Programming Languages and Systems. 16 (4). ACM Digital Library: 1319–1360. doi:10.1145/183432.183527. S2CID 6897138. Archived from the original (PDF) on 2018-05-18. Retrieved 2018-05-18. <a href="https://web.archive.org/web/20180518195918/https://www.classes.cs.uchicago.edu/current/32001-1/papers/ball-larus-profiling.pdf" target="_blank">https://web.archive.org/web/20180518195918/https://www.classes.cs.uchicago.edu/current/32001-1/papers/ball-larus-profiling.pdf</a> <a href="#fnref:16" class="footnote-back-ref">↩</a></p></li> <li id="fn:17"><p>Statistical Inaccuracy of gprof Output Archived 2012-05-29 at the Wayback Machine <a href="http://www.cs.utah.edu/dept/old/texinfo/as/gprof.html#SEC12" target="_blank">http://www.cs.utah.edu/dept/old/texinfo/as/gprof.html#SEC12</a> <a href="#fnref:17" class="footnote-back-ref">↩</a></p></li> <li id="fn:18"><p>"Popular C# Profilers". Gingtage. 2014. <a href="http://www.ginktage.com/2014/10/popular-c-profilers/" target="_blank">http://www.ginktage.com/2014/10/popular-c-profilers/</a> <a href="#fnref:18" class="footnote-back-ref">↩</a></p></li> <li id="fn:19"><p>"Sampling Profiler - Overview". AQTime 8 Reference. SmartBear Software. 2018. <a href="https://support.smartbear.com/viewarticle/54581/" target="_blank">https://support.smartbear.com/viewarticle/54581/</a> <a href="#fnref:19" class="footnote-back-ref">↩</a></p></li> <li id="fn:20"><p>Wenzal, Maira; et al. (2017). "Profiling Overview". Microsoft .NET Framework Unmanaged API Reference. Microsoft. <a href="https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/profiling/profiling-overview#supported-features" target="_blank">https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/profiling/profiling-overview#supported-features</a> <a href="#fnref:20" class="footnote-back-ref">↩</a></p></li> <li id="fn:21"><p>"Performance Tools". Apple Developer Tools. Apple, Inc. 2013. <a href="https://developer.apple.com/library/content/documentation/Performance/Conceptual/PerformanceOverview/PerformanceTools/PerformanceTools.html" target="_blank">https://developer.apple.com/library/content/documentation/Performance/Conceptual/PerformanceOverview/PerformanceTools/PerformanceTools.html</a> <a href="#fnref:21" class="footnote-back-ref">↩</a></p></li> <li id="fn:22"><p>Netto, Zanella; Arnold, Ryan S. (2012). "Evaluate performance for Linux on Power". IBM DeveloperWorks. <a href="https://www.ibm.com/developerworks/linux/library/l-evaluatelinuxonpower/" target="_blank">https://www.ibm.com/developerworks/linux/library/l-evaluatelinuxonpower/</a> <a href="#fnref:22" class="footnote-back-ref">↩</a></p></li> <li id="fn:23"><p>Schmidl, Dirk; Terboven, Christian; an Mey, Dieter; Müller, Matthias S. (2013). Suitability of Performance Tools for OpenMP Task-Parallel Programs. Proc. 7th Int'l Workshop on Parallel Tools for High Performance Computing. pp. 25–37. ISBN 9783319081441. <a href="9783319081441" target="_blank">9783319081441</a> <a href="#fnref:23" class="footnote-back-ref">↩</a></p></li> <li id="fn:24"><p>Carleton, Gary; Kirkegaard, Knud; Sehr, David (1998). "Profile-Guided Optimizations". Dr. Dobb's Journal. <a href="http://www.drdobbs.com/profile-guided-optimizations/184410561" target="_blank">http://www.drdobbs.com/profile-guided-optimizations/184410561</a> <a href="#fnref:24" class="footnote-back-ref">↩</a></p></li> </ol>