Intel® Advisor User Guide

Download PDF
ID 766448
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® Advisor User Guide
Intel® Advisor User Guide x
Introduction Install and Launch Intel® Advisor Set Up Project Analyze Vectorization Perspective Analyze CPU Roofline Model Threading Designs Model Offloading to a GPU Analyze GPU Roofline Design and Analyze Flow Graphs Minimize Analysis Overhead Analyze MPI Applications Manage Results Command Line Interface Troubleshooting Reference Appendix Notices and Disclaimers
Introduction x
What's New in Intel® Advisor Design and Optimization Methodology Tutorials and Samples Get Help and Support
Install and Launch Intel® Advisor x
Install Intel® Advisor Set Up Environment Variables Set Up System to Analyze GPU Kernels Set Up Environment to Offload SYCL, OpenMP* target, and OpenCL™ Applications to CPU Launch Intel® Advisor GUI Navigation Quick Start
Set Up Project x
Configure Target Application Build Target Application Create Project
Configure Target Application x
Limit the Number of Threads Used by Parallel Frameworks Choose a Small, Representative Data Set
Create Project x
Configure Project Configure Binary/Symbol Search Directories Configure Source Search Directory Binary/Symbol Search and Source Search Locations
Analyze Vectorization Perspective x
Run Vectorization and Code Insights Perspective from GUI Run Vectorization and Code Insights Perspective from Command Line Explore Vectorization and Code Insights Results
Run Vectorization and Code Insights Perspective from GUI x
Vectorization Accuracy Presets Customize Vectorization and Code Insights Perspective
Run Vectorization and Code Insights Perspective from Command Line x
Vectorization Accuracy Levels in Command Line
Explore Vectorization and Code Insights Results x
Vectorization Report Overview Examine Not-Vectorized and Under-Vectorized Loops Analyze Loop Call Count Investigate Memory Usage and Traffic Find Data Dependencies
Analyze CPU Roofline x
Run CPU / Memory Roofline Insights Perspective from GUI Run CPU / Memory Roofline Insights Perspective from Command Line Explore CPU/Memory Roofline Results
Run CPU / Memory Roofline Insights Perspective from GUI x
CPU Roofline Accuracy Presets Customize CPU / Memory Roofline Insights Perspective
Run CPU / Memory Roofline Insights Perspective from Command Line x
CPU Roofline Accuracy Levels in Command Line
Explore CPU/Memory Roofline Results x
CPU Roofline Report Overview Examine Bottlenecks on CPU Roofline Chart Examine Relationships Between Memory Levels Compare CPU Roofline Results
Model Threading Designs x
Run Threading Perspective from GUI Run Threading Perspective from Command Line Annotate Code for Deeper Analysis Explore Threading Results Model Threading Parallelism Check for Dependencies Issues Add Parallelism to Your Program
Run Threading Perspective from GUI x
Customize Threading Perspective
Run Threading Perspective from Command Line x
Threading Accuracy Levels in Command Line
Annotate Code for Deeper Analysis x
Annotate Code to Model Parallelism Annotations Annotation Report
Annotate Code to Model Parallelism x
Before Annotating Code for Deeper Analysis Use Amdahl's Law and Measure the Program Task Organization and Annotations Annotate Parallel Sites and Tasks Task Patterns Choose the Tasks Use Partially Parallel Programs with Intel® Advisor
Task Patterns x
Multiple Parallel Sites Data and Task Parallelism Mix and Match Tasks
Choose the Tasks x
Task Interactions and Suitability How Big Should a Task Be?
Annotations x
Annotation Types Annotation Definitions Files Add Annotations into Your Source Code Tips for Annotation Use with C/C++ Programs
Annotation Types x
Annotation Types Summary Annotation General Characteristics Site and Task Annotations for Simple Loops With One Task Site and Task Annotations for Parallel Sites with Multiple Tasks Lock Annotations Pause Collection and Resume Collection Annotations Special-purpose Annotations
Annotation Definitions Files x
Reference the Annotations Definitions Directory Add a Copy of the C/C++ Annotation Definition File to Your Visual Studio* Project Include the Annotations Header File in C/C++ Sources
Add Annotations into Your Source Code x
Insert Annotations Using the Annotation Wizard Copy Annotations and Build Settings Using the Annotation Assistant Pane Insert Annotations in the Visual Studio* Code Editor Insert Annotations in a Text Editor
Insert Annotations Using the Annotation Wizard x
Annotation Wizard - Page 1 Annotation Wizard - Page 2 Annotation Wizard - Page 3
Tips for Annotation Use with C/C++ Programs x
Control the Expansion of advisor-annotate.h Handle Compilation Issues that Appear After Adding advisor-annotate.h advisor-annotate.h and libittnotify.dll
Annotation Report x
Annotation Report, Clear Description of Storage Row Annotation Report, Disable Observations in Region Row Annotation Report, Pause Collection Row Annotation Report, Inductive Expression Row Annotation Report, Lock Row Annotation Report, Observe Uses Row Annotation Report, Reduction Row Annotation Report, Re-enable Observations at End of Region Row Annotation Report, Resume Collection Row Annotation Report, Site Row Annotation Report, Task Row Annotation Report, User Memory Allocator Use Row Annotation Report, User Memory Deallocator Use Row
Model Threading Parallelism x
Suitability Report Overview Choose Modeling Parameters in the Suitability Report Fix Annotation-related Errors Detected by the Suitability Tool Advanced Modeling Options Reduce Parallel Overhead, Lock Contention, and Enable Chunking
Reduce Parallel Overhead, Lock Contention, and Enable Chunking x
Reduce Site Overhead Reduce Task Overhead Reduce Lock Overhead Reduce Lock Contention Enable Task Chunking
Check for Dependencies Issues x
Code Locations Pane Filter Pane (Dependencies Report) Problems and Messages Pane Dependencies Source Window
Dependencies Source Window x
Code Locations Pane (Dependencies Source Window) Focus Code Location Pane Focus Code Location Call Stack Pane Related Code Locations Pane Related Code Location Call Stack Pane Relationship Diagram Pane
Add Parallelism to Your Program x
Before You Add Parallelism: Choose a Parallel Framework Add the Parallel Framework to Your Build Environment Annotation Report Replace Annotations with Intel® oneAPI Threading Building Blocks (oneTBB) Code Replace Annotations with OpenMP* Code Next Steps for the Parallel Program
Before You Add Parallelism: Choose a Parallel Framework x
Parallel Frameworks Intel® oneAPI Threading Building Blocks (oneTBB) OpenMP* Microsoft Task Parallel Library* (TPL) Other Parallel Frameworks
Add the Parallel Framework to Your Build Environment x
Enable Intel® oneAPI Threading Building Blocks (oneTBB) in your Build Environment Define the TBBROOT Environment Variable Enable C++11 Lambda Expression Support with Intel® oneAPI Threading Building Blocks (oneTBB) Enable OpenMP* in your Build Environment
Annotation Report x
Annotation Report Overview Locate Annotations with the Annotation Report
Replace Annotations with Intel® oneAPI Threading Building Blocks (oneTBB) Code x
Intel® oneAPI Threading Building Blocks (oneTBB) Mutexes Intel® oneAPI Threading Building Blocks (oneTBB) Simple Mutex - Example Test the Intel® oneAPI Threading Building Blocks (oneTBB) Synchronization Code Parallelize Functions - Intel® oneAPI Threading Building Blocks (oneTBB) Tasks Parallelize Data - Intel® oneAPI Threading Building Blocks (oneTBB) Counted Loops Parallelize Data - Intel® oneAPI Threading Building Blocks (oneTBB) Loops with Complex Iteration Control
Replace Annotations with OpenMP* Code x
Add OpenMP Code to Synchronize the Shared Resources OpenMP Critical Sections Basic OpenMP Atomic Operations Advanced OpenMP Atomic Operations OpenMP Reduction Operations OpenMP Locks Test the OpenMP Synchronization Code Parallelize Functions - OpenMP Tasks Parallelize Data - OpenMP Counted Loops Parallelize Data - OpenMP Loops with Complex Iteration Control
Next Steps for the Parallel Program x
Use Intel® Inspector and Intel® VTune™ Profiler Debug Parallel Programs
Model Offloading to a GPU x
Run Offload Modeling Perspective from GUI Run Offload Modeling Perspective from Command Line Explore Offload Modeling Results Advanced Modeling Configuration
Run Offload Modeling Perspective from GUI x
Offload Modeling Accuracy Presets Customize Offload Modeling Perspective
Run Offload Modeling Perspective from Command Line x
Offload Modeling Accuracy Levels in Command Line Run GPU-to-GPU Performance Modeling from Command Line
Explore Offload Modeling Results x
Offload Modeling Report Overview Examine Regions Recommended for Offloading Examine Data Transfers for Modeled Regions Check for Dependency Issues Explore Performance Gain from GPU-to-GPU Modeling Investigate Non-Offloaded Code Regions
Advanced Modeling Configuration x
Model Application Performance on a Custom Target GPU Device Check How Assumed Dependencies Affect Modeling Manage Invocation Taxes Enforce Offloading for Specific Loops
Analyze GPU Roofline x
Run GPU Roofline Insights Perspective from GUI Run GPU Roofline Insights Perspective from Command Line Explore GPU Roofline Results
Run GPU Roofline Insights Perspective from GUI x
GPU Roofline Accuracy Presets Customize GPU Roofline Insights Perspective
Run GPU Roofline Insights Perspective from Command Line x
GPU Roofline Accuracy Levels in Command Line
Explore GPU Roofline Results x
Examine GPU Roofline Summary Examine Bottlenecks on GPU Roofline Chart Examine Kernel Details Compare GPU Roofline Results
Design and Analyze Flow Graphs x
Where to Find the Flow Graph Analyzer Launching the Flow Graph Analyzer Flow Graph Analyzer GUI Overview Flow Graph Analyzer Workflows Designer Workflow Generating C++ Stubs Preferences Scalability Analysis Collecting Traces from Applications Nested Parallelism in Flow Graph Analyzer Analyzer Workflow Experimental Support for OpenMP* Applications Sample Trace Files Additional Resources
Flow Graph Analyzer GUI Overview x
Menus Toolbars Tabs Main Canvas Charts
Designer Workflow x
Adding Nodes, Edges, and Ports Modifying Node Properties Viewing Edge Properties Validating a Graph Saving a Graph to a File
Scalability Analysis x
Activating the Graph Scalability Analysis Prerequisites Running the Scalability Analysis Exploring the Parallelism in a Concurrent Node Showing Non-Parallel Nature of a Serial Node Explore Parallelism Provided by the Topology of a Graph Understanding Analysis Color Codes
Scalability Analysis Prerequisites x
Setting Concurrency Specification Setting Data Count Setting Node Weight
Collecting Traces from Applications x
Building an Application for Trace Collection Collecting Trace Files
Building an Application for Trace Collection x
Building an Application on Windows* OS Building an Application on Linux* OS Building an Application on macOS*
Collecting Trace Files x
Collect Traces In the Flow Graph Analyzer GUI Collect Traces Outside the Flow Graph Analyzer GUI
Collect Traces Outside the Flow Graph Analyzer GUI x
Collecting Trace Files with fgtrun Script Collecting Trace Files without fgtrun Script
Analyzer Workflow x
Find Time Regions of Low Concurrency and Their Cause Finding a Critical Path Finding Tasks with Small Durations Reduce Scheduler Overhead using Lightweight Policy Identifying Tasks that Operate on Common Input Support for SYCL
Support for SYCL x
Collect SYCL Application Traces Examine a SYCL Application Graph Find Issues Using Static Rule-check Engine
Examine a SYCL Application Graph x
Hotspot View View Performance Inefficiencies of Data-parallel Constructs
Find Issues Using Static Rule-check Engine x
Issue: Const Reference to a Host Pointer Used to Initialize a Buffer Issue: Host Pointer Accessor Used in a Loop Issue: Data Parallel Construct Inefficiency
Experimental Support for OpenMP* Applications x
Collecting Traces for OpenMP* Applications OpenMP* Constructs in the Per-Thread Task View OpenMP* Constructs in the Graph Canvas
Sample Trace Files x
code_generation Samples performance_analysis Samples
Minimize Analysis Overhead x
Collection Controls to Minimize Analysis Overhead Loop Markup to Minimize Analysis Overhead Filtering to Minimize Analysis Overhead Execution Speed/Duration/Scope Properties to Minimize Analysis Overhead Miscellaneous Techniques to Minimize Analysis Overhead
Analyze MPI Applications x
Model MPI Application Performance on GPU Control Collection with an MPI_Pcontrol Function
Manage Results x
Open a Result Rename an Existing Result Delete a Result Save Results to a Custom Location Work with Standalone HTML Reports Create a Read-only Result Snapshot Create a Result Snapshot Dialog Box Open a Result as a Read-only File in Visual Studio
Command Line Interface x
advisor Command Line Interface Reference Offload Modeling Command Line Reference Generate Pre-configured Command Lines
advisor Command Line Interface Reference x
advisor Command Action Reference advisor Command Option Reference
advisor Command Action Reference x
collect command create-project help import-dir mark-up-loops report snapshot version workflow
advisor Command Option Reference x
accuracy append app-working-dir assume-dependencies assume-hide-taxes assume-ndim-dependency assume-single-data-transfer auto-finalize batching benchmarks-sync bottom-up cache-binaries cache-binaries-mode cache-config cache-simulation cache-sources cachesim cachesim-associativity cachesim-cacheline-size cachesim-mode cachesim-sampling-factor cachesim-sets check-profitability clear config count-logical-instructions count-memory-instructions count-memory-objects-accesses count-mov-instructions count-send-latency cpu-scale-factor csv-delimiter custom-config data-limit data-reuse-analysis data-transfer data-transfer-histogram data-transfer-page-size data-type delete-tripcounts disable-fp64-math-optimization display-callstack dry-run duration dynamic enable-cache-simulation enable-data-transfer-analysis enable-task-chunking enforce-baseline-decomposition enforce-fallback enforce-offloads estimate-max-speedup evaluate-min-speedup exclude-files executable-of-interest exp-dir filter filter-by-scope filter-reductions flop force-32bit-arithmetics force-64bit-arithmetics format gpu gpu-carm gpu-sampling-interval hide-data-transfer-tax ignore ignore-app-mismatch ignore-checksums instance-of-interest integrated interval limit loop-call-count-limit loop-filter-threshold loops mark-up mark-up-list memory-level memory-operation-type mix mkl-user-mode model-baseline-gpu model-children model-extended-math model-system-calls module-filter module-filter-mode mpi-rank mrte-mode ndim-depth-limit option-file overlap-taxes pack profile-gpu profile-intel-perf-libs profile-jit profile-python profile-stripped-binaries project-dir quiet recalculate-time record-mem-allocations record-stack-frame reduce-lock-contention reduce-lock-overhead reduce-site-overhead reduce-task-overhead refinalize-survey remove report-output report-template result-dir resume-after return-app-exitcode search-dir search-n-dim select set-dependency set-parallel set-parameter show-all-columns show-all-rows show-functions show-loops show-not-executed show-report small-node-filter sort-asc sort-desc spill-analysis stack-access-granularity stack-stitching stack-unwind-limit stacks stackwalk-mode start-paused static-instruction-mix strategy support-multi-isa-binaries target-device target-gpu target-pid target-process target-system threading-model threads top-down trace-mode trace-mpi track-memory-objects track-stack-accesses track-stack-variables trip-counts verbose with-stack
Offload Modeling Command Line Reference x
run_oa.py Options collect.py Options analyze.py Options Usage Options
Troubleshooting x
Error Message: Application Sets Its Own Handler for Signal Error Message: Cannot Collect GPU Hardware Metrics for the Selected GPU Adapter Error Message: Memory Model Cache Hierarchy Incompatible Error Message: No Annotations Found Error Message: No Data Is Collected Error Message: Stack Size Is Too Small Error Message: Undefined Linker References to dlopen or dlsym Problem: Broken Call Tree Problem: Code Region is not Marked Up Problem: Debug Information Not Available Problem: No Data Problem: Source Not Available Problem: Stack in the Top-Down Tree Window Is Incorrect Problem: Survey Tool does not Display Survey Report Problem: Unexpected C/C++ Compilation Errors After Adding Annotations Problem: Unexpected Unmatched Annotations in the Dependencies Report Warning: Analysis of Debug Build Warning: Analysis of Release Build
Reference x
Data Reference Dependencies Problem and Message Types Recommendation Reference User Interface Reference
Data Reference x
CPU Metrics Accelerator Metrics
Dependencies Problem and Message Types x
Dangling Lock Data Communication Data Communication, Child Task Inconsistent Lock Use Lock Hierarchy Violation Memory Reuse Memory Reuse, Child Task Memory Watch Missing End Site Missing End Task Missing Start Site Missing Start Task No Tasks in Parallel Site One Task Instance in Parallel Site Orphaned Task Parallel Site Information Thread Information Unhandled Application Exception
Recommendation Reference x
Vectorization Recommendations for C++ Vectorization Recommendations for Fortran
User Interface Reference x
Dialog Box: Corresponding Command Line Dialog Box: Create a Project Dialog Box: Create a Result Snapshot Dialog Box: Options - Assembly Editor Tab Dialog Box: Options - General Dialog Box: Options - Result Location Dialog Box: Project Properties - Analysis Target Dialog Box: Project Properties - Binary/Symbol Search Dialog Box: Project Properties - Source Search Pane: Advanced View Pane: Analysis Workflow Pane: Roofline Chart Pane: GPU Roofline Chart Project Navigator Pane Toolbar: Intel Advisor Annotation Report Window: Dependencies Source Window: GPU Roofline Regions Window: GPU Roofline Insights Summary Window: Memory Access Patterns Source Window: Offload Modeling Summary Window: Offload Modeling Report - Accelerated Regions Window: Perspective Selector Window: Refinement Reports Window: Suitability Report Window: Suitability Source Window: Survey Report Window: Survey Source Window: Threading Summary Window: Vectorization Summary
Window: Refinement Reports x
Tab: Dependencies Report Tab: Memory Access Patterns Report
Appendix x
Data Sharing Problems Notational Conventions Key Concepts Related Information
Data Sharing Problems x
Data Sharing Problem Types Problem Solving Strategies
Data Sharing Problem Types x
Incidental Sharing Independent Updates
Problem Solving Strategies x
Eliminate Incidental Sharing Synchronize Independent Updates Difficult Problems: Choosing a Different Set of Tasks Fix Problems in Code Used by Multiple Parallel Sites Memory That is Accessed Through a Pointer
Eliminate Incidental Sharing x
Examine the Task's Static and Dynamic Extent Verify Whether Incidental Sharing Exists Create the Private Memory Location Pointer Dereferences
Synchronize Independent Updates x
Synchronization Explicit Locking Assign Locks to Transactions Pitfalls from Using Synchronization
Key Concepts x
Glossary Parallelism
Parallelism x
Parallel Processing Terminology Add Parallelism Common Issues When Adding Parallelism Parallel Programming Implementations
Intel® Advisor User Guide

analyze.py Options

This script allows you to run an analysis on profiling data and generate report results.

Usage

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

NOTE:
Replace <APM> with $APM on Linux* OS or %APM% on Windows* OS.

Options

The following table describes options that you can use with the analyze.py script.

Option

Description

<project-dir>

Required. Specify the path to the Intel® Advisor project directory.

-h

--help

Show all script options.

--version

Display Intel® Advisor version information.

-v <verbose>

--verbose <verbose>

Specify output verbosity level:

  • 1 - Show only error messages. This is the least verbose level.

  • 2 - Show warning and error messages.

  • 3 (default) - Show information, warning, and error messages.

  • 4 - Show debug, information, warning, and error messages. This is the most verbose level.

NOTE:
This option affects the console output, but does not affect logs and report results.

--assume-dependencies (default) | --no-assume-dependencies

Assume that a loop has a dependency if the loop type is not known. When disabled, assume that a loop does not have dependencies if the loop dependency type is unknown.

--assume-hide-taxes [<loop-id> | <file-name>:<line-number>]

Use an optimistic approach to estimate invocation taxes: hide all invocation taxes except the first one.

You can provide a comma-separated list of loop IDs and source locations to hide taxes for. If you do not provide a list, taxes are hidden for all loops.

--assume-never-hide-taxes (default)

Use a pessimistic approach to estimate invocation taxes: do not hide invocation taxes.

--assume-ndim-dependency (default) | --no-assume-ndim-dependency

When searching for an optimal N-dimensional offload, assume there are dependencies between inner and outer loops.

--assume-parallel | --no-assume-parallel (default)

Assume that a loop is parallel if the loop type is not known.

--assume-single-data-transfer (default) | --no-assume-single-data-transfer

Assumed data is transferred once for each offload, and all instances share the data. When disabled, assume each data object is transferred for every instance of an offload that uses it.

This method assumes no data re-use between calls to the same kernel.

IMPORTANT:
This option requires you to enable the following options during the Trip Counts collection:
  • With collect.py, use --collect basic or --collect full.
  • With advisor --collect=tripcounts, use data-transfer=<mode>.

--atomic-access-pattern <pattern>

Select an atomic access pattern. Possible options: sequential, partial_sums_16, same. By default, it is set to partial_sums_16.

--assume-atomic-optimization-ratio <ratio>

Model atomic accesses as a number of parallel sums. Specify one of the following values: 8, 16, 32, 64, 128 to model a specific number of parallel sums. Specify 0 value to search for an optimal number of parallel sums.

Default value: '16'.

--check-profitability (default) | --no-check-profitability

Check the profitability of offloading regions. Only regions that can benefit from the increased speed are added to a report.

When disabled, add all evaluated regions to a report, regardless of the profitability of offloading specific regions.

--config <config>

Specify a configuration file by absolute path or name. If you choose the latter, the model configuration directory is searched for the file first, then the current directory.

The following device configurations are available: xehpg_512xve (default), xehpg_256xve , gen11_icl, gen12_tgl, gen12_dg1, gen9_gt4, gen9_gt3, gen9_gt2.

NOTE:
You can specify several configurations by using the option more than once.

--count-logical-instructions (default) | --no-count-logical-instructions

Use the projection of x86 logical instructions to GPU logical instructions.

--count-memory-instructions (default) | --no-count-memory-instructions

Use the projection of x86 instructions with memory to GPU SEND/SENDS instructions.

--count-mov-instructions | --no-count-mov-instructions (default)

Use the projection of x86 MOV instructions to GPU MOV instructions.

--count-send-latency {all, first, off}

Select how to model SEND instruction latency.

  • all - Assume each SEND instruction has an uncovered latency. This is a default value for GPU-to-GPU modeling with --gpu, --profile-gpu, or --analyze-gpu-kernels-only.
  • first - Assume only the first SEND instruction in a thread has an uncovered latency. This is a default value for CPU-to-GPU modeling.
  • off - Do not model SEND instruction latency.

--cpu-scale-factor <integer>

Assume a host CPU that is faster than the original CPU by the specified value.

All original CPU times are divided by the scale factor.

--data-reuse-analysis | --no-data-reuse-analysis (default)

Estimate data reuse between offloaded regions. Disabling can decrease analyze overhead.

IMPORTANT:
This option requires you to enable the following options during the Trip Counts collection:
  • With collect.py, use --collect full.
  • With advisor --collect=tripcounts, use data-transfer=full.

--data-transfer-histogram (default) | --no-data-transfer-histogram

Estimate fine-grained data transfer and latencies for each object transferred and add a memory object histogram to a report.

IMPORTANT:
This option requires you to enable track-memory-objects or data-transfer=medium or higher (for advisor CLI only) during the Trip Counts collection.

--disable-fp64-math-optimization

Disable accounting for optimized traffic for transcendentals on the GPU.

--enable-batching | --disable-batching (default)

Enable job batching for top-level offloads. Emulate the execution of more than one instance simultaneously.

--enable-edram

Enable eDRAM modeling in the memory hierarchy model.

NOTE:
Make sure to use this option with both collect.py and analyze.py.

--enable-slm

Enable SLM modeling in the memory hierarchy model.

NOTE:
Make sure to use this option with both collect.py and analyze.py.

--enforce-baseline-decomposition | --no-enforce-baseline-decomposition (default)

Use the same local size and SIMD width as measured on the baseline. When disabled, search for an optimal local size and SIMD width to optimize kernel execution time.

Enable the option for the GPU-to-GPU performance modeling.

-e, --enforce-offloads | --no-enforce-offloads (default)

Skip the profitability check, disable analyzing child loops and functions, and ensure that the rows marked for offload are offloaded even if offloading child rows is more profitable.

--estimate-max-speedup (default) | --no-estimate-max-speedup

Estimate region speedup with relaxed constraints.

NOTE:
Disabling can decrease performance model overhead.

--evaluate-min-speedup

Enable offload fraction estimation that reaches minimum speedup defined in a configuration file. Disabled by default.

--exclude-from-report <items-to-exclude>

Specify items to exclude from a report. Available items: memory_objects, sources, call_graph, dependencies, strides.

By default, you can exclude the following items from the report:

  • For the CPU-to-GPU modeling:
    • memory objects
    • sources
    • call graph
    • dependencies
  • For the GPU-to-GPU modeling:
    • memory objects
    • sources

Use this option if your report is heavy weight, for example, due to containing a lot of memory objects or sources, which slows down opening in a browser.

NOTE:
This option affects only data shown in the HTML report and does not affect data collection.

--force-32bit-arithmetics

Force all arithmetic operations to be considered single-precision FPs or int32.

--force-64bit-arithmetics

Force all arithmetic operations to be considered double-precision FPs or int64.

--gpu (recommended) | --profile-gpu | --analyze-gpu-kernels-only

Model performance only for code regions running on a GPU. Use one of the three options.

IMPORTANT:
Make sure to specify this option for both collect.py and analyze.py.
NOTE:
This is a preview feature. --analyze-gpu-kernels-only is deprecated and will be removed in futire releases.

--hide-data-transfer-tax | --no-hide-data-transfer-tax (default)

Disable data transfer tax estimation.

By default, the data transfer tax estimation is enabled.

--ignore <list>

Specify a comma-separated list of runtimes or libraries to ignores time spent in regions from these runtimes and libraries when calculating per-program speedup.

NOTE:
This does not affect estimated speedup of individual offloads.

--include-to-report <items-to-include>

Specify items to include to a report. Available items: memory_objects, sources, call_graph, dependencies, strides.

By default, you can add the following items from the report:

  • For the CPU-to-GPU modeling: strides
  • For the GPU-to-GPU modeling:
    • call graph
    • dependencies
    • strides

Use this option if you want to add more data to the report or see that some data, for example, sources or memory objects, are missing from the report, though you collected this data.

NOTE:
This option affects only data shown in the HTML report and does not affect data collection.

--loop-filter-threshold <threshold>

Specify the loop filter threshold in seconds. The default is 0.02. Loop nests with total time less than the threshold are ignored.

-m <markup>

--markup <markup>

Select markup_analyze, affecting which regions to mark up for data collection and analysis.

--model-children (default) | --no-model-children

Analyze child loops of the region head to find if some of the loops provide more profitable offload.

--model-extended-math (default) | --no-model-extended-math

Model calls to math functions such as EXP, LOG, SIN, and COS as extended math instructions, if possible.

--model-system-calls (default) | --no-model-system-calls

Analyze regions with system calls inside. The actual presence of system calls inside a region may reduce model accuracy.

--mpi-rank <mpi-rank>

Model performance for the specified MPI rank if multiple ranks were analyzed.

--ndim-depth-limit <N>

When searching for an optimal N-dimensional offload, limit the maximum loop depth that can be converted to one offload. The limit must be in the range 1 <= N <= 6. The default value is 3.

--no-cachesim

Disable cache simulation during collection. The model assumes 100% hit rate for cache.

NOTE:
Usage decreases analysis overhead.

--no-stacks

Run data analysis without using callstacks data. You can use this option to avoid bad callstacks attributed data at the expense of accuracy.

--non-accel-time-breakdown

Provide a detailed breakdown of non-offloaded parts of offloaded regions.

-o <output-dir>

--out-dir <output-dir>

Specify the directory to put all generated files into. By default, results are saved in <advisor-project>/e<NNN>/pp<MMM>/data.0. If you specify an existing directory or absolute path, results are saved in specified directory. The new directory is created if it does not exist.

If you only specify the directory <name>, results are stored in <advisor-project>/e<NNN>/pp<MMM>/<name>.

NOTE:
If you use this options, you might not be able to open the analysis results in the Intel Advisor GUI.

-p <output-name-prefix>

--out-name-prefix <output-name-prefix>

Specify a string to add to the beginning output result filenames.

NOTE:
If you use this options, you might not be able to open the analysis results in the Intel Advisor GUI.

--overlap-taxes | --no-overlap-taxes (default)

Enable asynchronous execution to overlap offload overhead with execution time.

When disabled, assume no overlap of execution time and offload overhead.

--refine-repeated-transfer | --no-refine-repeated-transfer (default)

Reduce over-estimation of data transfer when --no-assume-single-data-transfer is used. This option counts how many times each data object is modified and limits the number of data transfers based on that result. For example, constant data may be used in each call to a loop, but needs to be transferred to a device only once.

IMPORTANT:
This option requires you to enable the following options during the Trip Counts collection:
  • With collect.py, use --collect full.
  • With advisor --collect=tripcounts, use data-transfer=full.

--search-n-dim (default) | --no-search-n-dim

Enable search for optimal N-dimensional offload.

-l [<file-name>:<line-number>]

--select-loops [<file-name>:<line-number>]

Limit the analysis to specified loop nests determined by passing a topmost loop. The parameter must be a comma-separated list of source locations in the following format: <file-name>:<line-number>.

--set-dependency [<IDs/source-locations>]

Assume loops have dependencies if they have IDs or source locations from the specified comma-separated list. If the list is empty, assume all loops have dependencies.

NOTE:
--set-dependency option takes precedence over --set-parallel, so if a loop is listed in both, it is considered as having a dependency.

--set-parallel [<IDs/source-locations>]

Assume loops are parallel if they have IDs or source locations from a specified comma-separated list. If the list is empty, assume all loops are parallel.

NOTE:
--set-dependency option takes precedence over --set-parallel, so if a loop is listed in both, it is considered as having a dependency.

--set-parameter <CLI-config>

Specify a single-line configuration parameter to modify in a format "<group>.<parameter>=<new-value>". For example: "min_required_speed_up=0", "scale.Tiles_per_process=0.5". You can use this option more than once to modify several parameters.

IMPORTANT:
Make sure to use this option for both collect.py and analyze.py with the same value.

--small-node-filter <threshold>

Specify the total time threshold, in seconds, to filter out nodes in the program_tree.dot and program_tree.pdf that fall below this value. The default is 0.0.

--threads <number-of-threads>

Specify the number of parallel threads to use for offload heads.

--track-heap-objects | --no-track-heap-objects

Deprecated. Use --track-memory-objects.

--track-memory-objects (default) | --no-track-memory-objects

Attribute heap-allocated objects to the analyzed loops that accessed the objects. Disabling can decrease collection overhead.

IMPORTANT:
This option requires you to enable the following options during the Trip Counts collection:
  • With collect.py, use --collect basic or --collect full.
  • With advisor --collect=tripcounts, use data-transfer=medium or data-transfer=full.

--use-collect-configs | --no-use-collect-configs (default)

Use configuration files from collection phase in addition to default and custom configuration files.

Examples

  • Run analysis with default configuration on the project in the ./advi directory. The generated output is saved to the default advi/perf_models/mNNNN directory. 

    advisor-python $APM/analyze.py ./advi_results

  • Run analysis using the Intel® Iris® Xe MAX graphics (gen12_dg1 configuration) configuration for the specific loops of the ./advi project. Add both analyzed loops to the report regardless of their offloading profitability. The generated output is saved to the default advi/perf_models/mNNNN directory. 

    advisor-python $APM/analyze.py ./advi_results --config gen12_dg1 --select-loops [foo.cpp:34,bar.cpp:192] --no-check-profitability

  • Run analysis for a custom configuration on the ./advi project. Mark up regions for analysis and assume a code region is parallel if its type is unknown. Save the generated output to the advi/perf_models/report directory. 

    advisor-python $APM/analyze.py ./advi_results --config ./myConfig.toml --markup --assume-parallel --out-dir report
Parent topic: Offload Modeling Command Line Reference
Level Two Title