Intel® VTune™ Profiler

Cookbook

Download PDF
ID 766316
Date 6/24/2024
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
Cookbook
Cookbook x
Methodologies Configuration Recipes Tuning Recipes Notices and Disclaimers
Methodologies x
Analyzing Uncore Perfmon Events for Use of Intel® Data Direct I/O Technology in Intel® Xeon® Processors (NEW) Top-down Microarchitecture Analysis Method OpenMP* Code Analysis Method Custom Data Collection for Performance Analysis (NEW) Software Optimization for Intel® GPUs (NEW) Core Utilization in DPDK Apps PCIe Traffic in DPDK Apps DPDK Event Device Profiling Effective Utilization of Intel® Data Direct I/O Technology Compile a Portable Optimized Binary with the Latest Instruction Set
Configuration Recipes x
Profiling OpenVINO™ Applications (NEW) Profiling High Bandwidth Memory Performance on Intel® Xeon® CPU Max Series (NEW) Profiling Windows* Applications for Hybrid CPU Platforms (NEW) Ingredients Directions Build the Sample in Microsoft* Visual Studio Run Hotspots Analysis Review Results Adjust Scheduler Value and Repeat Analysis See Also Viewing Analysis Results on a Web Browser (NEW) Profiling Data Parallel Python* Applications (NEW) Profiling Single-Node Kubernetes* Applications (NEW) Analyzing Hot Code Paths Using Flame Graphs (NEW) Improving Hotspot Observability in a C++ Application Using Flame Graphs Profiling Games built with Unity* (NEW) Profiling Games built with Unreal Engine* (NEW) Profiling Java Applications as a Remote User (NEW) Profiling JavaScript* Code in Node.js* Analyzing CPU and FPGA (Intel® Arria® 10 GX) Interaction Profiling a .NET* Core Application Profiling Applications in Amazon Web Services* (AWS) EC2 Instances Enabling Performance Profiling in GitLab* CI Configuring a Hyper-V* Virtual Machine for Hardware-Based Hotspots Analysis Profiling an Application for Performance Anomalies (NEW) Profiling an OpenMP* Offload Application running on a GPU Profiling a SYCL* Application running on a GPU Profiling an FPGA-driven SYCL* Application Profiling Hardware Without Intel Sampling Drivers Profiling MPI Applications Profiling Docker* Containers Profiling a Remote Target Through a Proxy Server (NEW) Profiling in an Apptainer* Container Profiling Linux*, Android*, and QNX* System Boot Time Using Intel® VTune™ Profiler Server with Visual Studio Code and Intel® DevCloud for oneAPI (NEW) Using Intel® VTune™ Profiler Server in HPC Clusters Using the Command-Line Interface to Analyze the Performance of a SYCL* Application running on a GPU (NEW)
Tuning Recipes x
Cache-Related Latency Issues in Segmented Cache Environment False Sharing Frequent DRAM Accesses Poor Port Utilization Page Faults Instruction Cache Misses OS Thread Migration OpenMP* Imbalance and Scheduling Overhead Processor Cores Underutilization: OpenMP* Serial Time Scheduling Overhead in an Intel® oneAPI Threading Building Blocks Application PMDK Application Overhead
Cookbook

Profiling Windows* Applications for Hybrid CPU Platforms (NEW)

Use this recipe to profile and view hybrid CPU utilization data for Windows-based applications.

A combination of performance cores (P-Cores) and efficient cores (E-Cores) empowers hybrid CPUs to tackle the processing demands of modern workloads, including computer games. Fine tuning your applications enables you to take full advantage of the processing capability of hybrid CPUs, especially if you are using the 12th Generation Intel® Core™ processor.

This recipe describes how you use VTune Profiler to profile and visualize performance data for Windows* applications that run on hybrid CPUs. This recipe highlights two examples with the asteroids_d3d12 executable in the HybridDetect sample. For a description of this sample, see the Game Dev Guide for 12th Gen Intel® Core™ Processor.

Content expert: Jennifer DiMatteo

Ingredients

  • Application: asteroids_d3d12 executable in the HybridDetect sample

  • Tools:

    • Intel® VTune™ Profiler version 2023 - Hotspots Analysis (using Hardware Event-based Sampling)
    • Microsoft* Visual Studio - For versions compatible with Intel® VTune™ Profiler, see Intel® VTune™ Profiler System Requirements.

  • CPU/GPU: Intel® Core™ i7-12700H

  • Operating system: Windows* 11 Enterprise

Build the Sample in Microsoft* Visual Studio

  1. Open the HybridDetect sample in Microsoft* Visual Studio.

  2. Build the sample.

Run Hotspots Analysis

This procedure describes how you run the hotspots analysis in hardware event-based sampling mode using the standalone version of VTune Profiler. If you are using VTune Profiler integrated into Microsoft Visual Studio, in order to run hardware event-based sampling analysis, you must run Visual Studio as an administrator.

  1. Open Intel® VTune™ Profiler and click New Project on the Welcome screen.

  2. Specify a project name and a location for your project.

  3. Click Create Project.
  4. In the WHERE pane of the Configure Analysis window, select Local Host.
  5. In the WHAT pane,

    • Fill in the Application field with the path to the asteroids_d3d12 executable.

    • In the Application parameters field, enter -scheduler 0. This parameter ensures that each of the render and update tasks run on individual threads.

    • In the Advanced section, select Automatically stop collection after to 30 seconds. Also select Analyze child processes.

  6. In the HOW pane, select the Hotspots analysis type and enable Hardware Event-Based Sampling.

  7. Click Start to run the analysis.

The sample shows that the frame rate is variable at 103 frames per second (fps).

Review Results

After the data collection runs for about 30 seconds, Intel® VTune™ Profiler terminates the application and data collection. Finalizing the results may take a few minutes as Intel® VTune™ Profiler finds and resolves debug symbols.

Once results have been finalized, the Summary tab displays information about:

  • Elapsed time
  • Top hotspots
  • Top tasks
  • Additional insights and guidance

In this example, the top task is DrawString with a high clock cycles per instruction (CPI) rate of 1.729. This means that the execution of instructions is slower than optimal. The thread count is eight, but actual parallelism in the executable is very low. You can infer this detail from the Additional Insights section in the upper right corner. The application is executing instructions very slowly and only on a single CPU.

Next, look at the Bottom-up window.

Customize Results by Core Type

To see how the application uses P-Cores and E-Cores, create a custom grouping. Click the tool icon next to the Grouping pulldown menu and group results by Function/Core Type/Logical Core.

Next, expand the RenderSubset function. You can see that this function ran on two logical P-Cores.

In this manner, you see from the timeline that the entire application used only two P-Cores and hardly any E-Cores. This implies that any execution that happened on E-Cores was too minimal for Intel® VTune™ Profiler to collect and use the data confidently.

Adjust Scheduler Value and Repeat Analysis

Repeat the hotspots analysis, but this time, set Application parameters to -scheduler 1. This setting ensures that the number of render tasks is equal to the number of P-Cores. Also, there are eight update tasks which now run independent of the render tasks.

Once you repeat the analysis, the application shows that 12 tasks are running. The average frame rate is 119 fps.

When the data collection completes, Intel® VTune™ Profiler finalizes results. The Summary window opens with this information:

The parallelism is now much higher. Instead of using one logical CPU, the application used over 12 CPUs.

This time, the top function is the TaskScheduler. The total thread count is 27. At 0.35, the CPI rate is much lower now. This may be because the scheduler had a very low CPI rate and accounted for most of the CPU time.

It is important to ensure that the render performance has actually improved, so that the results are not skewed by overhead. The Bottom-up window shows that the CPI rate of the render function improved.

However, the render function ran almost 20 million instructions this time, compared to 4.5 million instructions the previous time. This work was split almost evenly between P-Cores and E-Cores, although P-Cores ran the instructions 2x faster. Again, the timeline shows the overall utilization of cores.

The HybridDetect sample has several configurations which you can use to understand how to control CPU utilization on a hybrid platform. This recipe uses the default pre-compiler macros available in the sample. These macros give you control over the render and update threads, but they let the Intel Thread Detector determine the core type to be used.

As an additional exercise, force the render tasks to run on P-Cores and update tasks to run on E-Cores. To do this, enable the ENABLE_RUNON macro in HybridDetect.h. See how this change affects performance.

Parent topic: Configuration Recipes
Level Two Title