User Guide

Intel® VTune™ Profiler User Guide

Download PDF
ID 766319
Date 12/16/2022
Public

A newer version of this document is available. Customers should click here to go to the newest version.

Document Table of Contents
Document Table of Contents x
Intel® VTune™ Profiler User Guide
Intel® VTune™ Profiler User Guide x
Introduction Install Intel® VTune™ Profiler Open Intel® VTune™ Profiler Set Up Project Set Up Analysis Target Analyze Performance Intel® VTune™ Profiler Command Line Interface API Support Troubleshooting Reference Notices and Disclaimers
Introduction x
What's New in Intel® VTune™ Profiler Tuning Methodology Tutorials and Samples Notational Conventions Get Help Product Website and Support Related Information
Install Intel® VTune™ Profiler x
Sampling Drivers Set Up System for GPU Analysis Verify Intel® VTune™ Profiler Installation on a Linux* System Install VTune Profiler Server Security Best Practices
Set Up System for GPU Analysis x
Rebuild and Install the Kernel for GPU Analysis Rebuild and Install Module i915 for GPU Analysis on CentOS* Rebuild and Install Module i915 for GPU Analysis on Ubuntu*
Install VTune Profiler Server x
Set Up Transport Security Configure User Authentication/Authorization
Open Intel® VTune™ Profiler x
Get Started with Intel® VTune™ Profiler Intel® VTune™ Profiler Graphical User Interface Web Server Interface Microsoft Visual Studio* Integration Eclipse* and Intel System Studio IDE Integration Containerization Support macOS* Support
Containerization Support x
Run VTune Profiler in a Container Profile Container Targets from the Host
Set Up Project x
WHERE: Analysis System WHAT: Analysis Target HOW: Analysis Types Search Directories
WHERE: Analysis System x
Analysis System Options
WHAT: Analysis Target x
Analysis Target Options
Search Directories x
Search Order
Set Up Analysis Target x
Prepare Application for Analysis Windows* Targets Linux* Targets Embedded Linux* Targets FreeBSD* Targets QNX* Targets Managed Code Targets Android* Targets Intel® Xeon Phi™ Processor Targets Targets in Virtualized Environments Targets in a Cloud Environment Arbitrary Targets Embedded System Targets
Windows* Targets x
Install the Sampling Drivers for Windows* Targets Debug Information for Windows* Application Binaries Compiler Switches for Performance Analysis on Windows* Targets Debug Information for Windows* System Libraries Add Administrative Privileges
Linux* Targets x
Build and Install the Sampling Drivers for Linux* Targets Debug Information for Linux* Application Binaries Compiler Switches for Performance Analysis on Linux* Targets Enable Linux* Kernel Analysis Resolution of Symbol Names for Linux-Loadable Kernel Modules Analyze Statically Linked Binaries on Linux* Targets Set Up Remote Linux* Target
Set Up Remote Linux* Target x
Set Up Linux* System for Remote Analysis Configure SSH Access for Remote Collection Search Directories for Remote Linux* Targets Temporary Directory for Performance Results on Linux* Targets
Embedded Linux* Targets x
Configure Yocto Project* and VTune Profiler with the Integration Layer Configure Yocto Project*/Wind River* Linux* and Intel® VTune™ Profiler with the Intel System Studio Integration Layer Configure Yocto Project* and Intel® VTune™ Profiler with the Linux* Target Package
FreeBSD* Targets x
Set Up FreeBSD* System
Managed Code Targets x
.NET* Targets Windows Store Application Targets Go* Application Targets
Android* Targets x
Build and Install Sampling Drivers for Android* Targets Set Up Android* System Enable Java* Analysis on Android* System Prepare an Android* Application for Analysis Analyze Unplugged Devices Search Directories for Android* Targets
Targets in Virtualized Environments x
Profile Targets on a VMware* Guest System Profile Targets on a Parallels* Guest System Profile Targets on a KVM* Guest System Profile Targets on a Xen* Virtualization Platform Profile Targets in the Hyper-V* Environment
Profile Targets on a KVM* Guest System x
Profile KVM Kernel Modules from the Host Profile KVM Kernel and User Space on the KVM System Profile KVM Kernel and User Space from the Host
Analyze Performance x
User-Mode Sampling and Tracing Collection Hardware Event-based Sampling Collection Performance Snapshot Algorithm Group Microarchitecture Analysis Group Parallelism Analysis Group Input and Output Analysis Accelerators Analysis Group Platform Analysis Group Hybrid CPU Analysis Source Code Analysis Custom Analysis Energy Analysis Code Profiling Scenarios Control Data Collection Manage Data Views Manage Result Files
Hardware Event-based Sampling Collection x
Allow Multiple Runs or Multiplex Events Hardware Event-based Sampling Collection with Stacks
Algorithm Group x
Hotspots Analysis for CPU Usage Issues Anomaly Detection Analysis (preview) Memory Consumption Analysis
Hotspots Analysis for CPU Usage Issues x
Hotspots View
Anomaly Detection Analysis (preview) x
Anomaly Detection View
Memory Consumption Analysis x
Memory Consumption and Allocations View
Microarchitecture Analysis Group x
Microarchitecture Exploration Analysis for Hardware Issues Memory Access Analysis for Cache Misses and High Bandwidth Issues
Microarchitecture Exploration Analysis for Hardware Issues x
Microarchitecture Exploration View Microarchitecture Pipe
Memory Access Analysis for Cache Misses and High Bandwidth Issues x
Memory Usage View
Parallelism Analysis Group x
Threading Analysis HPC Performance Characterization Analysis
Threading Analysis x
Threading Efficiency View
HPC Performance Characterization Analysis x
HPC Performance Characterization View
Input and Output Analysis x
Analyze Platform Performance Analyze DPDK Applications Analyze SPDK Applications Analyze Linux Kernel I/O
Accelerators Analysis Group x
GPU Offload Analysis GPU Compute/Media Hotspots Analysis (Preview) CPU/FPGA Interaction Analysis
GPU Compute/Media Hotspots Analysis (Preview) x
GPU Compute/Media Hotspots View
CPU/FPGA Interaction Analysis x
CPU/FPGA Interaction View
Platform Analysis Group x
System Overview Analysis Platform Profiler Analysis
System Overview Analysis x
Analyze Interrupts Analyze Latency Issues
Platform Profiler Analysis x
Platform Profiler View
Custom Analysis x
Custom Analysis Options
Custom Analysis Options x
Highly Accurate CPU Time Data Collection Hardware Event List Linux* and Android* Kernel Analysis Sampling Interval Sample After Value
Hardware Event List x
Hardware Event Skid Instructions Retired Event Precise Events
Energy Analysis x
Run Energy Analysis View Energy Analysis Data with Intel® VTune™ Profiler Interpret Energy Analysis Data with Intel® VTune™ Profiler
Code Profiling Scenarios x
Java* Code Analysis Python* Code Analysis Intel® Threading Building Blocks Code Analysis MPI Code Analysis OpenSHMEM* Code Analysis with Fabric Profiler GPU Application Analysis on Intel® HD Graphics and Intel® Iris® Graphics Frame Data Analysis Task Analysis
GPU Application Analysis on Intel® HD Graphics and Intel® Iris® Graphics x
GPU OpenCL™ Application Analysis Intel® Media SDK Program Analysis
Control Data Collection x
Finalization Pause Data Collection Limit Data Collection Generate Command Line Configuration from GUI Minimize Collection Overhead Import External Data
Import External Data x
Use a Custom Collector Create a CSV File with External Data Import Linux Perf* Trace with VTune Profiler Metrics Examples of CSV Format and Imported Data
Manage Data Views x
Switch Viewpoints Control Window Synchronization View Stacks Manage Grid Views Manage Timeline View Change Threshold Values Choose Data Format Group and Filter Data View Data on Inline Functions Analyze Loops Stitch Stacks for Intel® oneAPI Threading Building Blocks or OpenMP* Analysis Search for Data
View Stacks x
Call Stack Mode Metrics Distribution Over Call Stacks
Manage Result Files x
VTune Profiler Filenames and Locations Import Results and Traces into VTune Profiler GUI Compare Results
Compare Results x
Compare Source Code View Comparison Data
View Comparison Data x
Comparison Summary Bottom-up Comparison Top-down Tree Comparison
Intel® VTune™ Profiler Command Line Interface x
vtune Command Syntax vtune Actions Run Command Line Analysis Work with Results from Command Line Generate Command Line Reports Command Line Usage Scenarios Command Line Interface Reference Report Problems from Command Line
Run Command Line Analysis x
performance-snapshot Command Line Analysis hotspots Command Line Analysis anomaly-detection Command Line Analysis threading Command Line Analysis memory-consumption Command Line Analysis hpc-performance Command Line Analysis uarch-exploration Command Line Analysis memory-access Command Line Analysis tsx-exploration Command Line Analysis tsx-hotspots Command Line Analysis sgx-hotspots Command Line Analysis gpu-hotspots Command Line Analysis gpu-offload Command Line Analysis graphics-rendering Command Line Analysis fpga-interaction Command Line Analysis io Command Line Analysis system-overview Command Line Analysis platform-profiler Command Line Analysis runsa/runss Custom Command Line Analysis Configure Analysis Options from Command Line
Configure Analysis Options from Command Line x
Collect System-Wide Data from Command Line Collect Data on Remote Linux* Systems from Command Line Configure GPU Analysis from Command Line Specify Search Directories from Command Line Specify Result Directory from Command Line Pause Collection from Command Line Manage Analysis Duration from Command Line Limit Data Collection from Command Line
Work with Results from Command Line x
View Command Line Results in the GUI Import Results from Command Line Re-finalize Results from Command Line
Generate Command Line Reports x
Summary Report Hotspots Report Hardware Events Report Callstacks Report Top-down Report gprof-cc Report Difference Report View Source Objects from Command Line Save and Format Command Line Reports Filter and Group Command Line Reports
Command Line Usage Scenarios x
Use VTune Profiler Server in Containers Android* Target Analysis from the Command Line OpenMP* Analysis from the Command Line Java* Code Analysis from the Command Line
Command Line Interface Reference x
Option Descriptions and General Rules allow-multiple-runs analyze-kvm-guest analyze-system app-working-dir call-stack-mode collect collect-with column command cpu-mask csv-delimiter cumulative-threshold-percent custom-collector data-limit discard-raw-data duration filter finalization-mode finalize format group-by help import inline-mode knob GUI Equivalent Syntax Arguments Actions Modified Description Example kvm-guest-kallsyms kvm-guest-modules limit loop-mode mrte-mode no-follow-child no-summary no-unplugged-mode quiet report report-knob report-output report-width result-dir resume-after return-app-exitcode ring-buffer search-dir show-as sort-asc sort-desc source-object source-search-dir stack-size start-paused strategy target-install-dir target-system target-tmp-dir target-duration-type target-pid target-process time-filter trace-mpi user-data-dir verbose version
API Support x
Instrumentation and Tracing Technology APIs JIT Profiling API System APIs Supported by Intel® VTune™ Profiler
Instrumentation and Tracing Technology APIs x
Basic Usage and Configuration Instrumentation and Tracing Technology API Reference
Basic Usage and Configuration x
Configure Your Build System Attach ITT APIs to a Launched Application Instrument Your Application Minimize ITT API Overhead View Instrumentation and Tracing Technology (ITT) API Task Data in Intel® VTune™ Profiler
Instrumentation and Tracing Technology API Reference x
Domain API String Handle API Collection Control API Thread Naming API Task API Frame API Histogram API User-Defined Synchronization API Event API Counter API Load Module API Memory Allocation APIs
JIT Profiling API x
Using JIT Profiling API JIT Profiling API Reference
JIT Profiling API Reference x
iJIT_NotifyEvent iJIT_IsProfilingActive iJIT_ GetNewMethodID
Troubleshooting x
Best Practices: Resolve Intel® VTune™ Profiler BSODs, Crashes, and Hangs in Windows* OS Error Message: Application Sets Its Own Handler for Signal Error Message: Cannot Enable Event-Based Sampling Collection Error Message: Cannot Collect GPU Hardware Metrics Error Message: Cannot Collect GPU Hardware Metrics for the Selected GPU Adapter Error Message: Cannot Load Data File Error Message: Cannot Locate Debugging Information Error Message: Cannot Open Data Error Message: Client Is Not Authorized to Connect to Server Error Message: Root Privileges Required for Processor Graphics Events Error Message: No Pre-built Driver Exists for This System Error Message: Not All OpenCL™ API Profiling Callbacks Are Received Error Message: Problem Accessing the Sampling Driver Error Message: Required Key Not Available Error Message: Scope of ptrace System Call Is Limited Error Message: Stack Size Is Too Small Error Message: Symbol File Is Not Found Problem: Analysis of the .NET* Application Fails Problem: Cannot Access VTune Profiler Documentation Problem: CPU time for Hotspots or Threading Analysis is Too Low Problem: 'Events= Sample After Value (SAV) * Samples' Is Not True If Multiple Runs Are Disabled Problem: Guessed Stack Frames Problem: GUI Hangs or Crashes Problem: Inaccurate Sum in the Grid Problem: Information Collected via ITT API Is Not Available When Attaching to a Process Problem: No GPU Utilization Data Is Collected Problem: Same Functions Are Compared As Different Instances Problem: Skipped Stack Frames Problem: Stack in the Top-Down Tree Window Is Incorrect Problem: Stacks in Call Stack and Bottom-Up Panes Are Different Problem: System Functions Appear in the User Functions Only Mode Problem: VTune Profiler is Slow to Respond When Collecting or Displaying Data Problem: VTune Profiler is Slow on X-Servers with SSH Connection Problem: Unexpected Paused Time Problem: {Unknown Timer} in the Platform Power Analysis Viewpoint Problem: Unknown Critical Error Due to Disabled Loopback Interface Problem: Unknown Frames Problem: Unreadable Text on macOS* Problem: Unsupported Microsoft* Windows* OS Warnings about Accurate CPU Time Collection
Reference x
User Interface Reference CPU Metrics Reference GPU Metrics Reference OpenCL™ Kernel Analysis Metrics Reference Energy Analysis Metrics Reference Intel Processor Events Reference
User Interface Reference x
Context Menu: Grid Context Menus: Call Stack Pane Context Menus: Project Navigator Context Menus: Source/Assembly Window Dialog Box: Binary/Symbol Search Dialog Box: Source Search Hot Keys Menu: Customize Grouping Menu: Intel VTune Profiler Pane: Call Stack Pane: Options - General Pane: Options - Result Location Pane: Options - Source/Assembly Project Navigator Pane: Timeline Toolbar: Configure Analysis Toolbar: Filter Toolbar: Source/Assembly Toolbar: Intel VTune Profiler Window: Bandwidth - Platform Power Analysis Window: Bottom-up Window: Caller/Callee Window: Cannot Find <file type> File Window: Collection Log Window: Compare Results Window: Configure Analysis Window: Core Wake-ups - Platform Power Analysis Window: Correlate Metrics - Platform Power Analysis Window: CPU C/P States - Platform Power Analysis Window: Debug Window: Event Count - Hardware Events Window: Flame Graph Window: Graphics - GPU Compute/Media Hotspots Window: Graphics C/P States - Platform Power Analysis Window: NC Device States - Platform Power Analysis Window: Platform Window: Platform Power Analysis Window: Sample Count - Hardware Events Window: SC Device States - Platform Power Analysis Window: Summary Window: System Sleep States - Platform Power Analysis Window: Temperature/Thermal Sample - Platform Power Analysis Window: Timer Resolution - Platform Power Analysis Window: Top-down Tree Window: Uncore Event Count - Hardware Events Window: Wakelocks - Platform Power Analysis
Window: Summary x
Window: Summary - Input and Output Summary Window: Summary - Microarchitecture Exploration Window: Summary - GPU Analysis Window: Summary - Hardware Events Window: Summary - Hotspots by CPU Utilization Window: Summary - HPC Performance Characterization Window: Summary - Memory Consumption Window: Summary - Memory Usage Window: Summary - Platform Power Analysis
GPU Metrics Reference x
Average Time Computing Threads Started Computing Threads Started, Threads/sec CPU Time EU 2 FPU Pipelines Active EU Array Active EU Array Idle EU Array Stalled/Idle EU Array Stalled EU IPC Rate EU Send pipeline active EU Threads Occupancy Global GPU EU Array Usage GPU L3 Bound GPU L3 Miss Ratio GPU L3 Misses GPU L3 Misses, Misses/sec GPU Memory Read Bandwidth, GB/sec GPU Memory Texture Read Bandwidth, GB/sec GPU Memory Write Bandwidth, GB/sec GPU Texel Quads Count, Count/sec GPU Utilization Instance Count L3 Sampler Bandwidth, GB/sec L3 Shader Bandwidth, GB/sec LLC Miss Rate due GPU Lookups LLC Miss Ratio due GPU Lookups Local Maximum GPU Utilization Occupancy PS EU Active % PS EU Stall % Ratio to Max Bandwidth, % Ratio to Max Bandwidth, % Ratio to Max Bandwidth, % Render/GPGPU Command Streamer Loaded Samples Blended Samples Killed in PS, pixels Samples Written Sampler Busy Sampler Is Bottleneck Shared Local Memory Read Bandwidth, GB/sec Shared Local Memory Write Bandwidth, GB/sec SIMD Width Size Total, GB/sec Total Time Typed Memory Read Bandwidth, GB/sec Typed Memory Write Bandwidth, GB/sec Typed Reads Coalescence Typed Writes Coalescence Untyped Memory Read Bandwidth, GB/sec Untyped Memory Write Bandwidth, GB/sec Untyped Reads Coalescence Untyped Writes Coalescence VS EU Active VS EU Stall
OpenCL™ Kernel Analysis Metrics Reference x
Computing Task Total Time Instance Count SIMD Width SIMD Utilization Work Size
Energy Analysis Metrics Reference x
Available Core Time C-State D0ix States DRAM Self Refresh Energy Consumed (mJ) Idle Wake-ups P-State S0ix States Temperature Timer Resolution Total Time in C0 State Total Time in Non-C0 States Total Time in S0 State Total Wake-up Count Wake-ups Wake-ups/sec per Core
Intel® VTune™ Profiler User Guide

knob

Set configuration options for the specified analysis type or collector type.

GUI Equivalent

Configure Analysiswindow > HOW pane

Syntax

-knob | -k <knob-name>=<knob-value>

Arguments

knob-name

An analysis type or collector type may have one or more configuration options (knobs) that provide additional instructions for performing the specified type of analysis. To use a knob, you must specify the knob name and knob value.

Multiple knob options are allowed and can be followed by additional action-options, as well as global-options, if needed.

knob-value

There are values available for each knob. In most cases this is a Boolean value, so for Boolean knobs, specify <knob-name>=true to enable the knob.

NOTE:

Knob behavior may vary depending on the analysis type or collector type.

<knob-name>

Description

accurate-cpu-time-detection=true | false (Windows only)

Default: true

Collect more accurate CPU time data. This option requires additional disk space and post-processing time. Administrator privileges are required.

Supported analysis: runss

analyze-loops=true | false

Default: false

Extend loop analysis to collect advanced loops information such as instruction set usage and display analysis results by loops and functions.

Supported analysis: runss, runsa

analyze-mem-objects=true | false

Default: false

Enable the instrumentation of memory allocation/de-allocation and map hardware events to memory objects. This option is supported for Linux targets only running on the Intel microarchitecture code name Sandy Bridge (or later).

Supported analysis: memory-access

analyze-openmp=true | false

Default: true for the HPC Performance Characterization analysis; false for other analysis types.

Instrument the OpenMP* runtimes in your application to group performance data by regions/work-sharing constructs and detect inefficiencies such as imbalance, lock contention, or overhead on performing scheduling, reduction, and atomic operations. Using this option may cause higher overhead and increase the result size.

Supported analysis: hotspots, threading, hpc-performance, memory-access, uarch-exploration, runsa

analyze-persistent-memory=true | false

Default: false

Collect performance information for Intel® Optane™ Persistent Memory modules.

Supported analysis: platform-profiler

analyze-power-usage=true | false

Default: false

Collect information about energy consumed by CPU, DRAM, and discrete GPU.

Supported analysis: gpu-hotspots,gpu-offload

analyze-throttling-reasons=true | false

Default: false

Collect information about factors that cause the CPU to throttle.

Supported analysis: system-overview

atrace-config=<event>

Available events are gfx, input, view, webview, wm, am, audio, video, camera, hal, res, dalvik.

Collect Android framework events from Systrace*.

Supported analysis: runsa

characterization-mode=overview | global-local-accesses | compute-extended | full-compute | instruction-count

Default: overview

Monitor the Render and GPGPU engine usage (Intel Graphics only), identify which parts of the engine are loaded, and correlate GPU and CPU data.

The Characterization mode uses platform-specific presets of the GPU metrics. All presets, except for the instruction-count, collect data about execution units (EUs) activity: EU Array Active, EU Array Stalled, EU Array Idle, Computing Threads Started, and Core Frequency; and each one introduces additional metrics:

  • overview metric set includes additional metrics that track general GPU memory accesses such as Memory Read/Write Bandwidth, GPU L3 Misses, Sampler Busy, Sampler Is Bottleneck, and GPU Memory Texture Read Bandwidth. These metrics can be useful for both graphics and compute-intensive applications.
  • global-local-accesses metric group includes additional metrics that distinguish accessing different types of data on a GPU: Untyped Memory Read/Write Bandwidth, Typed Memory Read/Write Transactions, SLM Read/Write Bandwidth, Render/GPGPU Command Streamer Loaded, and GPU EU Array Usage. These metrics are useful for compute-intensive workloads on the GPU.
  • compute-extended metric group includes additional metrics targeted only for GPU analysis on the Intel processor code name Broadwell and higher. For other systems, this preset is not available.
  • full-compute metric group is a combination of the overview and global-local-accesses event sets.
  • instruction-count metric group counts the execution frequency of specific classes of instructions.

Supported analysis: gpu-hotspots, graphics-rendering, runsa

chipset-event-config="event1,event2 ,..."

Specify a comma-separated list of Android chipset events (up to 5 events) to monitor with the hardware event-based sampling collector.

Supported analysis: runsa

source-analysis=bb-latency | mem-latency

Default value: bb-latency

Collect data on performance-critical basic blocks and issues caused by memory accesses in the GPU kernels. Choose one of the following modes:

  • bb-latency mode helps you identify issues caused by algorithm inefficiencies. In this mode, VTune Profiler measures the execution time of all basic blocks. Basic block is a straight-line code sequence that has a single entry point at the beginning of the sequence and a single exit point at the end of this sequence. During post-processing, VTune Profiler calculates the execution time for each instruction in the basic block. So, this mode helps understand which operations are more expensive.
  • mem-latency mode helps identify latency issues caused by memory accesses. In this mode, VTune Profiler profiles memory read/synchronization instructions to estimate their impact on the kernel execution time. Consider using this option, if you ran the gpu-hotspots analysis in the Characterization mode, identified that the GPU kernel is throughput or memory-bound, and want to explore which memory read/synchronization instructions from the same basic block take more time.

Supported analysis: gpu-hotspots

collect-bad-speculation=true | false

Default value: true

Collect the minimum set of data required to compute top-level metrics and all Bad Speculation sub-metrics.

Supported analysis: uarch-exploration, runsa

collect-core-bound=true | false

Default: false

Collect the minimum set of data required to compute top-level metrics and all Core Bound sub-metrics.

Supported analysis: uarch-exploration, runsa

collect-frontend-bound=true | false

Default value: true

Collect the minimum set of data required to compute top-level metrics and all Front-End Bound sub-metrics.

Supported analysis: uarch-exploration, runsa

collect-cpu-gpu-bandwidth=true | false

Default: false

Collect DRAM bandwidth data for all hosts. Additionally, collect PCIe bandwidth for supported server hosts (Intel® micro-architectures code named Ice Lake and Sapphire Rapids). To view collected data in GUI, enable the Analyze CPU host-GPU bandwidth option.

Supported analysis:gpu-offload

collect-cpu-gpu-pci-bandwidth=true | false

Default: false

Collect PCIe bandwidth for supported server hosts (Intel® micro-architectures code named Ice Lake and Sapphire Rapids). This knob is available for custom analyses only. To view collected data in GUI, enable the Analyze CPU host-GPU bandwidth option.

Supported analysis:runsa

collect-io-waits=true | false

Default: false

Analyze the percentage of time each thread and CPU spends in I/O wait state.

Supported analysis: runsa

collect-memory-bandwidth=true | false

Default: depends on analysis type

Collect data to identify where your application is generating significant bandwidth to DRAM. To view collected data in GUI, enable the Analyze memory bandwidth option.

Supported analysis: performance-snapshot, uarch-exploration, hpc-performance, gpu-hotspots,runsa

collect-memory-bound=true | false

Default value: true

Collect the minimum set of data required to compute top-level metrics and all Memory Bound sub-metrics.

Supported analysis: uarch-exploration, hpc-performance

collect-programming-api=true | false

Default for gpu-hotspots: true, for runss: false.

Analyze execution of SYCL apps, OpenCL™ kernels and Intel® Media SDK programs on Intel HD Graphics and Intel® Iris® Graphics. This option may affect the performance of your application on the CPU side.

Supported analysis: gpu-hotspots, gpu-offload, runsa

collect-retiring=true | false

Default value: true

Collect the minimum set of data required to compute top-level metrics and all Retiring sub-metrics.

Supported analysis: uarch-exploration, runsa

collecting-mode=hw-tracing | hw-tracing

Default value: hw-sampling

Specify the system-wide collection mode to either explore CPU, GPU, and I/O resources utilization with the default event-based sampling mode, or enable the low-overhead hardware tracing and identify a root cause of latency issues.

Supported analysis: system-overview, runsa

computing-task-of-interest=computing_task_name[#start_idx#step#stop_idx]

Specify a comma-separated list of GPU computing task names and invocations.

computing_task_name is the name of a GPU computing task; start_idx is the number of the first invocation; and stop_idx is the number of the last invocation to be profiled.

Supported analysis: gpu-hotspots, runsa

counting-mode=true | false

Default: false

Choose between collecting detailed context data for each PMU event (such as code or hardware context) or the counts of events. Counting mode introduces less overhead but gives less information.

Supported analysis: runsa

cpu-samples-mode=off | stack | nostack

Default: false

Enable to periodically sample the application. Samples can be collected with or without stacks.

Supported analysis: runss

dpdk=true | false

Default: false

Profile DPDK IO API.

Supported analysis: io

dram-bandwidth-limits=true | false

Default: true for the HPC Performance Characterization and Microarchitecture Exploration analysis with collect-memory-bandwidth knob enabled; true for the Memory Access and Microarchitecture Exploration analysis.

Evaluate maximum achievable local DRAM bandwidth before the collection starts. This data is used to scale bandwidth metrics on the timeline and calculate thresholds.

Supported analysis: performance-snapshot, memory-access, uarch- exploration, hpc-performance, runsa

enable-characterization-insights=true | false

Get additional performance insights such as the efficiency of hardware usage, and learn next steps.

Supported analysis: gpu-offload

enable-context-switches=true | false

Default: false

Analyze detailed scheduling layout for all threads in your application, explore time spent on a context switch and identify the nature of context switches for a thread (preemption or synchronization).

Supported analysis: runsa

enable-driverless-collection=true | false

Default: false

Enable driverless Linux Perf collection when possible.

Supported analysis: runsa

enable-gpu-usage=true | false

Default: false

Analyze frame rate and usage of Intel HD Graphics and Intel® Iris® Graphics engines and identify whether your application is GPU or CPU bound.

Supported analysis: runss, runsa

enable-interrupt-collection=true | false

Default: false

Collect interrupt events that alter a normal execution flow of a program. Such events can be generated by hardware devices or by CPUs. Use this data to identify slow interrupts that affect your code performance.

Supported analysis: system-overview.

enable-parallel-fs-collection=true | false

Default: false

Analyze Lustre* file system performance statistics, including Bandwidth, Package Rate, Average Packet Size, and others.

Supported analysis: runsa

enable-stack-collection=true | false

Default: false

Enable Hardware Event-based Sampling Collection with Stacks.

Supported analysis: hotspots, hpc-performance, gpu-offload, runsa

enable-system-cswitch=true | false

Default: false

Analyze detailed scheduling layout for all threads on the system and identify the nature of context switches for a thread (preemption or synchronization).

Supported analysis: runsa

enable-thread-affinity=true | false

Default: false

Analyze thread pinning to sockets, physical cores, and logical cores. Identify incorrect affinity that utilizes logical cores instead of physical cores and contributes to poor physical CPU utilization.

NOTE:

Affinity information is collected at the end of the thread lifetime, so the resulting data may not show the whole issue for dynamic affinity that is changed during the thread lifetime.

enable-user-sync=true | false

Default: false

Collect synchronization data via the User-Defined Synchronization API.

Supported analysis: threading, runss

enable-user-tasks=true | false

Default: false

Analyze tasks, events and counters specified in your application via the Task API. This option causes higher overhead and increases result size.

Supported analysis: hotspots, threading, uarch-exploration, runss, runsa

event-config=<event_name1>,<event_name2>,...

Configure PMU events to collect with the hardware event-based sampling collector. Multiple events can be specified as a comma-separated list (no spaces).

NOTE:

To display a list of events available on the target PMU, enter:

vtune -collect-with runsa -knob event-config=? <target>

The command returns names and short descriptions of available events. For more information on the events, use Intel Processor Events Reference.

Supported analysis: runsa

event-mode=all | user | os

Default: all

Limit event-based sampling collection to OS or USER mode.

Supported analysis: hotspots, runsa

ftrace-config=<event_name>

Available events are freq, idle, sched, disk, filesystem, irq, kvm, workq, softirq, sync.

Default for Linux targets: sched,freq,idle,workq,irq,softirq

Default for Android targets: sched,freq,idle,workq,filesystem, irq,softirq,sync,disk

Collect Linux Ftrace* framework events.

Supported analysis: runsa, runss

gpu-sampling-interval=<number> between 0.1 and 1000ms

Default: 1.

Specify an interval between GPU samples (in milliseconds).

Supported analysis: gpu-hotspots, graphics-rendering, runss, runsa

io-mode=off | stack | nostack

Default: off

Enable to identify where threads are waiting or compute thread concurrency. The collector instruments APIs, which causes higher overhead and increases result size.

Supported analysis: runss, runsa

ipt-regions-to-load=<number> between 10 and 5000

Default: 1000

Specify the maximum number (10-5000) of code regions to load for detailed analysis.

Supported analysis: anomaly-detection

kernel-stack=true | false

Default: true

Profile system disk IO API.

Supported analysis: io

max-region-duration=<number> between 0.001 and 1000 ms

Default: 100

Specify the maximum duration (0.001-1000ms) of analysis per code region.

Supported analysis: anomaly-detection

mem-object-size-min-thres=<number>

Default: 1024 bytes

Specify a minimal size of memory allocations to analyze. This option helps reduce runtime overhead of the instrumentation.

This option is supported for Linux targets only running on the Intel microarchitecture code name Sandy Bridge (or later).

Supported analysis: memory-access

mrte-type=java,dotnet | java,dotnet,python | python

Default: java,dotnet

Specify a type of managed runtime to analyze. Available values: combined .NET* and Java* analysis, combined Java, .NET and Python* analysis, and Python only.

Supported analysis: runss, runsa

no-altstack=true | false

Default: false

Disable using alternative stacks for signal handlers. Consider this option for profiling standard Python 3 code on Linux.

Supported analysis: runss

pmu-collection-mode=detailed | summary

Default: detailed

Choose the detailed sampling-based collection mode to view data breakdown per function and other hotspots. Use the summary counting-based mode for an overview of the whole profiling run. This mode has a lower collection overhead and fast post-processing time.

Supported analysis: uarch-exploration

profiling-mode=characterization (default), code-level-analysis

Select a profiling mode to either characterize GPU performance issues based on GPU hardware metric presets or enable a source analysis to identify basic blocks latency due to algorithm inefficiencies, or memory latency due to memory access issues.

Supported analysis: gpu-hotspots, runsa

sampling-interval=<number>

For user-mode sampling and tracing types: a number (in milliseconds) between 1 and 1000. Default: 10

For hardware event-based sampling types: a number (in milliseconds) between 0.01 and 1000. Default: 1.

Specify a sampling interval (in milliseconds) between CPU samples.

Supported analysis: hotspots,runss, threading, ,runsa, system-overview, memory-access, hpc-performance

sampling-mode=sw | hw

Default: sw

Specify a profiling mode.

Use sw to identify CPU hotspots and explore a call flow of your program. This mode does not require sampling drivers to be installed but incurs more collection overhead.

Use hw to identify application hotspots based on such basic hardware events as Clockticks and Instructions Retired. This is a low-overhead collection mode but it requires the sampling driver to be installed on your system.

Supported analysis: hotspots, threading

signals-mode=off | objects | stack | nostack

Default: off

Enable to view synchronization transitions in the timeline and signalling call stacks for associated waits. The collector instruments signalling APIs, which causes higher overhead and increases result size.

Supported analysis: runss

spdk=true | false

Default: false

Profile SPDK IO API.

Supported analysis: io

stack-size=<number>

A number between 0 and 2147483647. Default is 0 (unlimited stack size).

Reduce the collection overhead and limit the stack size (in bytes) processed by the VTune Profiler.

Supported analysis: runsa

stack-stitching=true | false

Default: true

For Intel® oneAPI Threading Building Blocks(oneTBB )-based applications, restructure the call flow to attach stacks to a point introducing a parallel workload.

Supported analysis: runss

stack-type=software | lbr

Default: software

Choose between software stack and hardware LBR-based stack types. Software stacks have no depth limitations and provide more data while hardware stacks introduce less overhead. Typically, software stack type is recommended unless the collection overhead becomes significant. Note that hardware LBR stack type may not be available on all platforms.

Supported analysis: runsa

stackwalk-mode=online | offline

Default: offline

Choose between online (during collection) and offline (after collection) modes to analyze stacks. Offline mode reduces analysis overhead and is typically recommended.

Supported analysis: runss

target-gpu= <domain:bus:device.function>

Default: The newest GPU architecture that VTune Profiler can detect

Select a target GPU for profiling when you have multiple GPUs connected to your system. If unset, VTune Profiler selects the newest GPU architecture it can detect.

Example: target-gpu=0:0:2.0

Supported analysis: gpu-offload, gpu-hotspots

uncore-sampling-interval=<number>

For hardware event-based sampling types: a number (in milliseconds) between 1 and 1000. Default: 10.

Specify an interval (in milliseconds) between uncore event samples.

Supported analysis: runsa

waits-mode=off | stack | nostack

Default: off

Enable to identify where threads are waiting or compute thread concurrency. The collector instruments APIs, which causes higher overhead and increases result size.

Supported analysis: runss

Actions Modified

collect, collect-with

Description

Use the knob action-option to configure knob settings for a collect (predefined analysis types) or collect-with (custom analysis types) action where the analysis type supports one or more knobs. Each analysis type or collector type supports a specific set of knobs, and each knob requires a value. In most cases the knob value is Boolean, so you would use True to enable the knob.

To see all knobs available for a predefined analysis type:

vtune -help collect <analysis_type>

To see knobs for a custom analysis type:

vtune -help collect-with <analysis_type>

Example

This example returns a list of knobs for the Threading analysis type: 

vtune -help collect threading

This example runs a custom event-based sampling data collection on an Android system enabling collection of Android framework and chipset events. 

vtune -collect-with runss -target-system=android -knob sampling-interval=2 -knob cpu-samples-mode=stack -knob ftrace-config=gfx,dalvik -knob chipset-event-config="GMCH_PARTIAL_WR_DRAM.ANY,GMCH_CORE_CLKS" --target-process com.intel.tbb.example.tachyon

This example configures and runs a custom event-based sampling data collection with the stack size limited to 8192 bytes: 

vtune -collect-with runsa -knob enable-stack-collection=true -knob stack-size=8192 -knob enable-call-counts=true -knob event-config=CPU_CLK_UNHALTED.REF_TSC:sa=1800000,CPU_CLK_UNHALTED
Parent topic: Command Line Interface Reference

See Also

Level Two Title