Pseudo-Routines in Profiling Results

Applies to AQTime 8.81, last modified on January 18, 2022

The Performance profiler results may include the <Root>, <JIT compiler> and <Garbage collector> pseudo-routines. These are fictitious routines, they do not exist in your application. The following sections explains the meaning of these functions.

Information the profiler collects for the <Root>, <JIT compiler> and <Garbage collector> routines depends on the active counter. Most likely, you will use “time” counters, therefore, we will speak about the “Time” column in our further explanation. However, this does not mean you cannot use other counters. The results the other counters produce are similar to the results of the “time” counters.

The <JIT compiler> and <Garbage collector> Pseudo-Routines

The total execution time of a managed (.NET) routine includes the following four times:

  1. Time spent for executing the routine's own code.
  2. Time spent for running the child routines.
  3. Time spent by the Just-In-Time compiler (JIT compiler) for compiling the routine's code: before executing a routine, the Common Language Runtime (CLR) may compile this routine at run time. Compilation takes some time, this time is included in the total execution time of the routine. AQTime traces the compilation requests and calculates JIT compilation time.
  4. Time spent for the garbage collecting: the CLR pauses the .NET application, when the garbage collector starts, and resumes the application after the garbage collection is over. The time spent for garbage collecting is included in the total execution time of the routine.

To help you find out how much time was spent on the Just-In-Time compiling and garbage collecting during the application run, the Performance profiler includes the Profile .NET runtime option. If this option is enabled, AQTime times the JIT compilation and garbage collection routines and display them as <JIT compiler> and <Garbage collector> in the Report and Details panels:

  • The Time column for the <JIT compiler> routine in the Report panel displays the total time spent by the JIT compiler for compiling application routines during the run. The Time column for the <Garbage collector> routine in the Report panel shows the total time spent by the CLR for garbage collecting during the application run.

  • The <JIT compiler> and <Garbage collector> routines are displayed in the Children table of the Details panel. This means that they were called from the routine, which is currently selected in the Report panel. They let you determine what portion of time was included in the total execution time of the routine, but was not spent executing the routine's own code or for child calls:

    • The Time column of the <JIT compiler> routine shows the time spent by the JIT compiler for compiling the routine.
    • The Time column of the <Garbage collector> function indicates the time spent on garbage collecting.
Some notes:
  • Results in the Details panel includes the <JIT compiler> and <Garbage collector> routines only if the Just-In-Time compiler or garbage collector was called during the routine execution. Otherwise, these functions will be absent in results.

    The <JIT compiler> function is also absent in results if the analyzed routine was pre-compiled (pre-JITted) before the application start.

  • Since both <JIT compiler> and <Garbage collector> are fictitious routines, they do not have child routines. That is why, the Time with Children result is equal to Time, and % with Children is equal to % Time.

  • Since the CLR may perform JIT compilation or garbage collection while executing native-code functions, <JIT compiler> and <Garbage collector> may appear in detailed results of native-code functions.

The <Root> Pseudo-Routine

If the Profile <Root> routine option is enabled, the results of the Performance profiler include the <Root> routine. AQTime treats it as a parent routine of the topmost level. The <Root> body includes different initialization statements and function calls. All other routines are called from the <Root> one: the main routine, event handlers (for example, OnClick) that respond to user actions, etc.

Each application thread has its own <Root> routine. Even the thread function is “called” from <Root> (of course, this differs from what actually happens, because the first “parent” function in each thread is its thread function).

To view functions that are called from <Root>, click <Root> in the Report panel and switch to Details. The Hit Count column always displays 1 for the <Root> routine. As the <Root> body includes mostly initialization statements, the Time column for this routine displays the time needed for application initialization. Time with Children displays the overall time of the application run. Note that this time is less than the one you can see in the Event View panel. This happens because Event View displays the total time of the application run, which includes time taken by AQTime for operation profiling. The Report panel displays the “net” application time (without AQTime time).

See Also

Profiling .NET Applications - Specifics
Performance Profiler - Overview
Analyzing Performance Profiler Results

Highlight search results