Range Summary view in Timing Captures

The Range Summary view shows Timing Capture data for a selected time range. Use it to inspect individual items, group the same data into summaries, filter to areas of interest, and move between Range Summary, the Timeline, Element Details, and Metrics views.

Range Summary complements the Timeline layout. The Timeline shows activity graphically over time. Range Summary shows the selected time range as sortable item tables and pivot-table summaries. It also complements the Range Details view, which lists the data for a time range by Item Type with type-specific display options, such as allocation stack trees and sampled-function trees.

How Range Summary is organized

Range Summary combines three elements:

  • A pivot table, on the Summary tab, that aggregates the data on multiple dimensions in any order you choose.
  • An item list, on the Items tab, that shows the individual records that make up the aggregation.
  • A set of filters that restrict the data in both the pivot table and the item list.

Together, these elements let you move between aggregated data and the individual items behind it. Use Range Summary to answer questions such as:

  • How much total time did a PIX event spend executing across all of the threads that ran it? For example, a job system that distributes work across a thread pool.
  • Which PIX events contain a given CPU sample, without selecting each event in the Timeline to look for it?
  • Which individual memory allocations came from a given call stack?

Choose the time range and data type

To populate Range Summary, select a time range in the Timeline view, or use Time Range in the Range Summary toolbar. The time range selector can use:

  • The selected Timeline range.
  • The visible Timeline viewport.
  • The selected Metrics range.
  • The visible Metrics viewport.
  • The entire capture.
  • A manually entered range.

Use Data Type to choose the kind of capture data to analyze. PIX groups data types into categories such as CPU, Memory, GPU, and Other. The available choices depend on the data in the capture and include data types such as PIX Events (CPU), PIX Markers (CPU), PIX Events & Markers (CPU), CPU Samples, memory events, GPU events, file I/O, DirectStorage events, controller input, and scheduler events.

Some data types open to Items by default, and others open to Summary by default. Select the other tab when you want the alternate view of the same data type and time range.

Use the Items tab

The Items tab lists individual records for the selected data type and time range. It is the best starting point when you need to inspect a specific event, sample, allocation, file access, or other record.

Use the item list to:

  • Sort by columns such as start time, duration, count, thread, process, queue, name, or size, depending on the selected data type.
  • Select a row to populate Element Details for that item.
  • Right-click a supported row and select Show in Timeline to zoom the Timeline to that item.
  • Right-click a supported row and select Graph Duration of Selected Events in Metrics View to graph the selected item in the Metrics layout.

Select Customize while Items is active to open Event List Columns. Use the check boxes to show or hide item-list columns.

If the selected range contains more item rows than Range Summary loads, PIX shows Data limit exceeded, showing first 1,000 items. Narrow the time range or add filters to inspect a smaller set.

Use the Summary tab

The Summary tab is the pivot table for Range Summary. It groups the same underlying data shown in Items, aggregates values for each group, and lets you drill from a high-level summary to the individual records that contributed to it.

Before you add any groups, the pivot table contains a single aggregation of all the data for the selected data type and time range, and Items lists every individual record.

Select Customize to show the Group By row. Use Group By to choose one or more grouping dimensions. Select Add to add another group, or use a group chip's menu to move it left, move it right, or delete it. Group order matters: grouping by Thread and then PIX Event Stack answers a different question than grouping by PIX Event Stack and then Thread.

The available groups depend on the selected data type. For example:

  • PIX Events (CPU) can group by Process, Thread, and PIX Event Stack.
  • PIX Events & Markers (CPU) can also group by Type.
  • CPU Samples can group by Process, Thread, Core, Call Stack, Function List, PIX Event Stack, and Flat PIX Event List.

Summary value columns aggregate numeric values for each group. Common aggregation modes include Inc. Sum, Exc. Sum, Average, Min, Max, Count, Std. Dev., Inc. %, Exc. %, and % of Parent. For PIX CPU events, the Duration value column aggregates the total event duration. You can also add columns such as Execution Duration, Stalled Duration, and, on captures with heterogeneous-core data, Performance Duration.

Each value column header shows a symbol for its aggregation mode. Hover over the header to see a description of the column and its aggregation mode.

Select Customize while Summary is active to open Summary Columns. Use this pane to show or hide summary value columns, remove columns, and add value columns with a selected aggregation mode. You can add the same value column more than once with different aggregation modes. For example, add Duration with Max and Average next to the default Duration column to see the longest and average instance of each group alongside the total.

When you select a pivot-table row that represents a call stack or function, such as a Call Stack or Function List group for CPU samples or an Alloc Call Stack group for memory allocations, Element Details shows information about that level of the aggregation. Selecting an Allocated Type row shows details about that type.

Filter the data

Filters apply to both Items and Summary for the current data type. Use filters to narrow the item list and recompute the pivot table over only the matching records.

To filter from the pivot table:

  1. Open the Summary tab.
  2. Select one or more group rows.
  3. Right-click the selection.
  4. Select Filter To Selection to keep matching data, or select Filter Out Selection to remove matching data.

Applying a filter changes the view in three ways:

  • The pivot table recomputes its aggregations over only the matching data.
  • Items lists only the matching individual records.
  • Filters lists the new filter.

Filters combine. For example, after you filter to a PIX event and then group by Thread, select Filter To Selection on one thread row to restrict the data further to the instances of that event that ran on that thread.

Open Filters to view the active filters. You can disable a filter with its check box, delete a single filter, select Delete Last Filter, or select Clear Filters.

The toolbar filter bar adds a text filter across searchable item-list fields for the current data type. It supports plain text, Match Case, Use Regular Expressions, and exclude mode. Text filters appear in Filters with the other active filters.

Use presets

Use Presets to apply common groupings and column layouts. Each data type includes a (default) preset that restores the shipped layout for that data type. Some data types include extra presets such as PIX Stacks by Thread, Names by Thread, Call Stacks by Thread, Call Stacks by Operation, or Batches by Queues. For example:

  • Memory data types offer presets that group by allocation lifetime, allocation call stack, PIX event stack, and thread, such as Call Stacks by Lifetime, Call Stacks by Thread, PIX Stacks by Lifetime, and PIX Stacks by Thread.
  • File I/O offers presets that group by device, thread, file operation, call stack, and path, such as Device Operations, Call Stacks by Operation, Call Stacks by Thread, and Path.

Select the save icon next to Presets to save the current layout as a user preset for the current data type. User presets appear in the same Presets menu and can be deleted from that menu.

Common workflows

Sum CPU event duration across threads

Use this workflow when an event name represents work distributed across a thread pool and you want to know where the time was spent. For example, suppose a job system records each job in a PIX event named ExecuteJob and runs jobs on several worker threads.

  1. Select the time range you want to analyze.
  2. Set Data Type to PIX Events (CPU) or PIX Events & Markers (CPU).
  3. Open Summary, and then select Customize to show Group By.
  4. Select Add, and then select PIX Event Stack. The pivot table groups all PIX events by the stack of events that contains them.
  5. Find ExecuteJob in the pivot table, right-click it, and select Filter To Selection. The pivot table now contains only the ExecuteJob stack group, which includes ExecuteJob and any events nested inside it, and Filters shows the new filter. The Duration column shows the total duration of ExecuteJob across all of the threads it ran on.
  6. Select Add, and then select Thread. The pivot table shows each thread that ran ExecuteJob, such as WorkerH1, WorkerL1, and WorkerL2.
  7. Use Duration to compare how much total time each thread spent in ExecuteJob. By default, Count includes events nested inside ExecuteJob. To count only ExecuteJob instances, use Summary Columns to set Count to the Exc. Sum aggregation mode.

Note

Duration values in this view are exclusive: each event contributes only the time not covered by its nested events. Totals across a stack group equal the inclusive time, but Max and Average aggregations describe individual events in the group, not whole ExecuteJob instances.

To focus on a single thread, right-click its row and select Filter To Selection. The new filter combines with the ExecuteJob filter.

Find events that contain a sampled function

Use this workflow when CPU samples identify a hot function and you need to find which PIX events contained it.

  1. Select the time range you want to analyze.
  2. Set Data Type to CPU Samples.
  3. Open Summary, and then select Customize to show Group By.
  4. Add Function List to Group By.
  5. Find the function, right-click it, and select Filter To Selection. The pivot table now contains only samples whose call stacks include that function.
  6. Add PIX Event Stack to Group By.
  7. Expand the function row to see the PIX event stacks where samples for that function occurred. For example, you might find that samples in a ResizeBuffer function occurred when it was called from two PIX events, CheckWorldSize and RunSimulation.

You can reverse the grouping order to answer the complementary question. Group first by PIX Event Stack, then by Function List, to see which sampled functions appear inside each PIX event stack. For example, expand CheckWorldSize to see all functions where CPU samples landed during that event.

Find allocations made by a call stack

Use this workflow when a call stack accounts for many memory allocations and you need the individual allocations it made.

  1. Select the time range you want to analyze.
  2. Set Data Type to a memory data type, such as HeapAlloc Memory.
  3. Open Summary, and then select Customize to show Group By.
  4. Add Alloc Call Stack to Group By, or apply a preset such as Call Stacks by Thread.
  5. Find the call stack you want to investigate, right-click it, and select Filter To Selection.
  6. Open Items to see the individual allocations made from that call stack.

Find individual items behind an aggregate

Use this workflow when a summary row explains the aggregate cost but you need the concrete records.

  1. Build or apply the grouping you need in Summary.
  2. Select Filter To Selection on the row you want to investigate.
  3. Open Items.
  4. Sort and inspect the individual records that contributed to that summary row.
  5. Use Show in Timeline or Element Details for a selected item when the data type supports those actions.

Related content

  • Last updated on