Get Started with Intel® Advisor

On Windows* OS:

To set up the environment for Intel Advisor, run the <install-dir>\env\vars.bat script.

On Linux* OS:

To set up the environment for Intel Advisor, run the source <install-dir>/env/vars.sh script.

On macOS*:

To set up the environment for Intel Advisor, run one of the following commands:

• <install-dir>/env/vars.sh
• <install-dir>/env/vars.csh

Explore a step-by step instruction how to view your Intel Advisor results on a macOS* machine in the Intel Advisor Cookbook: Analyze Performance Remotely and Visualize Results on a Local macOS* System.

Run Vectorization Perspective

In the Analysis Workflow pane, use a drop-down menu to select the Vectorization and Code Insights perspective, set data collection accuracy level to Low, and click the button to run it. When you select a perspective, Intel Advisor automatically sets up analyses to be run. You can view the list of analyses that are going to be run at the selected accuracy level under the Accuracy pane. Upon completion, Intel Advisor displays a Survey Report.

Survey Report - Offers integrated compiler report data and performance data that shows where vectorization will pay off the most; if vectorized loops are providing benefit, and if not, why not; un-vectorized loops and why they are not vectorized; and performance problems in general.

What's Next

If all loops are vectorizing properly and performance is satisfactory, you are done! Congratulations!

If one or more loops is not vectorizing properly and performance is unsatisfactory:

1. Improve application performance using various Intel Advisor features to guide your efforts, such as:

   • Information in the Performance Issues column and associated Recommendations tab.

   • Suggestions in Examine Non-Vectorized and Under-Vectorized Loops in the Intel Advisor User Guide.

   • Optional Dependencies and Memory Access Patterns (MAP) analyses to help you dig deeper.

2. Rebuild your modified code.

3. Run another Survey analysis to verify all loops are vectorizing properly and performance is satisfactory.

Run CPU Roofline Perspective

In the Analysis Workflow pane, the drop-down menu to select the CPU/MEMORY Roofline Insights perspective and click the button to run it. Upon completion, Intel Advisor displays a Roofline chart.

The Roofline chart plots an application's achieved performance and arithmetic intensity against the machine's maximum achievable performance:

• Arithmetic intensity (x axis) - measured in number of floating-point operations (FLOPs) and/or integer operations (INTOPs) per byte, based on the loop/function algorithm, transferred between CPU/VPU and memory.
• Performance (y axis) - measured in billions of floating-point operations per second (GFLOPS) and/or billions of integer operations per second (GINTOPS).

In general:

• The size and color of each Roofline chart dot represent relative execution time for each loop/function. Large red dots take the most time, so are the best candidates for optimization. Small green dots take less time, so may not be worth optimizing.
• Roofline chart diagonal lines indicate memory bandwidth limitations preventing loops/functions from achieving better performance without some form of optimization. For example: The L1 Bandwidth roofline represents the maximum amount of work that can get done at a given arithmetic intensity if the loop always hits L1 cache. A loop does not benefit from L1 cache speed if a dataset causes it to miss L1 cache too often, and instead is subject to the limitations of the lower-speed L2 cache it is hitting. So a dot representing a loop that misses L1 cache too often but hits L2 cache is positioned somewhere below the L2 Bandwidth roofline.
• Roofline chart horizontal lines indicate compute capacity limitations preventing loops/functions from achieving better performance without some form of optimization. For example: The Scalar Add Peak represents the peak number of add instructions that can be performed by the scalar loop under these circumstances. The Vector Add Peak represents the peak number of add instructions that can be performed by the vectorized loop under these circumstances. So a dot representing a loop that is not vectorized is positioned somewhere below the Scalar Add Peak roofline.
• A dot cannot exceed the topmost rooflines, as these represent the maximum capabilities of the machine; however, not all loops can utilize maximum machine capabilities.

• The greater the distance between a dot and the highest achievable roofline, the more opportunity exists for performance improvement.

What's Next

If one or more loops is not vectorizing properly and performance is unsatisfactory:

1. Check data in associated Intel Advisor views to support your Roofline chart interpretation. For example: Check the Vectorized Loops/Efficiency values in the Survey Report or the data in the Code Analytics tab.

2. Improve application performance using various Intel Advisor features to guide your efforts, such as:

   • Information in the Code Analytics tab and associated Recommendations tab.

   • Suggestions in Examine Relationships Between Memory Levels in the Intel Advisor User Guide

If you need more information, continue your investigation by:

1. Mark one or more loops/functions for deeper analysis in the column AND

2. Run a Dependencies analysis to discover why the compiler assumed a dependency and did not vectorize a loop/function, and/or running a Memory Access Patterns (MAP) analysis to identify expensive memory instructions.

Method 1: run_oa.py

advisor-python <APM>/run_oa.py <project-dir> -- <target> [target-options]

Method 3: advisor + analyze.py

This method is the most flexible and is applicable to MPI applications. To use this method:

1. Run collect.py with the --dry-run option to get command lines appropriate for your configuration:

   advisor-python <APM>/collect.py <project-dir> –-dry-run -- <target> [target-options]

   You will get several command lines for advisor collections. You can omit markup command (advisor-python collect.py --markup <markup-type>) to get more data for analysis at the cost of collection overhead.

2. Run all the printed command lines. For example:
   1. Run the Survey analysis:

      advisor –collect=survey --auto-finalize --stackwalk-mode=online --static-instruction-mix --project-dir=<project-dir> -–profile-jit –-data-transfer-analysis -- <target> [target-options]

   2. Run the Trip Counts and FLOP analysis:

      advisor --collect=tripcounts --flop --stacks -–enable-cache-simulation –-cache-config=<cache-configuration> --enable-data-transfer-analysis --project-dir=<project-dir> -- <target> [target-options]

   3. [Optional]: Run a Dependencies collection. It is not required for analyzing existing parallel regions, such as OpenMP or DPC++, but strongly recommended for generic analysis, which is the default mode.

      advisor --collect=dependencies --loops="scalar" --filter-reductions --loop-call-count-limit=16 --project-dir=<project-dir> -- <target> [target-options]

3. Run analyze.py to model application performance as if it is run on a target device:

   advisor-python <APM>/analyze.py <project-dir>

What's Next

Run a Data Transfer analysis to examine data transfers for each code region and get more accurate data about how your application is going to execute on a target GPU platform.

Explore a typical scenario of optimizing GPU usage described in Intel Advisor Cookbook: Identify Code Regions to Offload to GPU and Visualize GPU Usage.

Run GPU Roofline Perspective

In the Analysis Workflow pane, use a drop-down menu to select the GPU Roofline Insights perspective and click the button to run it. Upon completion, Intel Advisor displays a GPU Roofline Summary. View the GPU Roofline Chart to identify the main factors limiting the performance of your application.

A Roofline chart plots an application's achieved performance and arithmetic intensity against the machine's maximum achievable performance:

• Arithmetic intensity (x axis) - measured in number of floating-point operations (FLOPs) per byte, based on the kernel algorithm, transferred between GPU and memory

• Performance (y axis) - measured in billions of floating-point operations per second (GFLOPS)

In general:

• The size and color of each dot represent relative execution time for each kernel. Large red dots take the most time, so are the best candidates for optimization. Small green dots take less time, so may not be worth optimizing.

• Diagonal lines indicate memory bandwidth limitations preventing kernels from achieving better performance without some form of optimization.

  • L3 cache roof: Represents the maximal bandwidth of the L3 cache for your current graphics hardware. Measured using an optimized sequence of load operations, iterating over an array that fits entirely into L3 cache.

  • SLM cache roof: Represents the maximal bandwidth of the Shared Local Memory for your current graphics hardware. Measured using an optimized sequence of load and store operations that work only with SLM.

  • GTI roof: Represents the maximum bandwidth between the GPU and the rest of the SoC. This estimate is calculated via analytical formula based on the maximum frequency of your current graphics hardware.

  • DRAM roof: Represents the maximal bandwidth of the DRAM memory available to your current graphics hardware. Measured using an optimized sequence of load operations, iterating over an array that does not fit in GPU caches.

• Horizontal lines indicate compute capacity limitations preventing kernels from achieving better performance without some form of optimization.

• A dot cannot exceed the topmost rooflines, as these represent the maximum capabilities of the machine. However, not all kernels can utilize maximum machine capabilities.

• The greater the distance between a dot and the highest achievable roofline, the more opportunity exists for performance improvement.

The GPU Roofline chart is based on a CPU Roofline chart, but there are some differences:

• The dots on the chart correspond to OpenCL kernels, while in the CPU version, they correspond to individual loops.

• Some displayed information and controls (for example, thread/core count) are not relevant to GPU Roofline. For more information, see the table below.

• Integrated chart shows multiple dots for a single kernel . These dots correspond to different memory levels used to calculate arithmetic intensity. Hover over a dot to identify its arithmetic intensity. To show or hide certain dots from a chart, use the Memory Level drop-down filter.

What's Next

Use the GPU Roofline Summary to compare performance of your application on a CPU and on a GPU device.

Explore the typical scenario of optimizing GPU usage described in Intel Advisor Cookbook: Identify Code Regions to Offload to GPU and Visualize GPU Usage.

Run Threading Perspective

In the Analysis Workflow pane, use a drop-down menu to select the Threading perspective, set data collection accuracy to Low, and click the button to run the perspective. Use the resulting information to discover candidates for parallelization with threads.

Annotate Sources

Insert annotations to mark places in parts of your application that are good candidates for later replacement with parallel framework code that enables parallel execution.

The main types of Intel® Advisor annotations mark the location of:

• A parallel site. A parallel site is a region of code that contains one or more tasks that may execute in one or more parallel threads to distribute work. An effective parallel site typically contains a hotspot that consumes application execution time. To distribute these frequently executed instructions to different tasks that can run at the same time, the best parallel site is not usually located at the hotspot, but higher in the call tree.

• One or more parallel tasks within a parallel site. A task is a portion of time-consuming code with data that can be executed in one or more parallel threads to distribute work.

• Locking synchronization, where mutual exclusion of data access must occur in the parallel application.

After adding annotations, rebuild your application to prototype threading designs using the Suitability analysis.

Run Suitability Analysis

In the Analysis Workflow pane, set data collection accuracy level to Medium to collect Suitability data while your application executes. Upon completion, Intel Advisor displays a Suitability Report.

The Suitability Report predicts maximum speedup based on the inserted annotations and what-if modeling parameters with which you can experiment, such as:

• Different hardware configurations and parallel frameworks

• Different trip counts and instance durations

• Any plans to address parallel overhead, lock contention, or task chunking when you implement your parallel framework code

Use the resulting information to choose the best candidates for parallelization with threads.

Run Dependencies Analysis

If the data collection accuracy level is set to Medium, Threading Advisor collects Dependencies data while your application executes. Use the resulting information to fix the data sharing problems if the predicted maximum speedup benefit justifies the effort.

What's Next

If you decide the predicted maximum speedup benefit is worth the effort to add threading parallelism to your application:

1. Complete developer/architect design and code reviews about the proposed parallel changes.

2. Choose one parallel programming framework (threading model) for your application, such as oneTBB, OpenMP*, Microsoft Task Parallel Library* (TPL), or some other parallel framework.

3. Add the parallel framework to your build environment.

4. Add parallel framework code to synchronize access to the shared data resources, such as oneTBB or OpenMP locks.

5. Add parallel framework code to create parallel tasks.

As you add the appropriate parallel code from the chosen parallel framework, you can keep, comment out, or replace the Intel Advisor annotations.