Contents
Vectorization Advisor
Threading Advisor
Intel Advisor
Intel® Advisor provides two tools to help ensure your Fortran, C and C++ applications realize full performance potential on modern processors, such as Intel® Xeon Phi™ processors:
Vectorization Advisor is a vectorization optimization tool that lets you identify loops that will benefit most from vectorization, identify what is blocking effective vectorization, forecast the benefit of alternative data reorganizations, and increase the confidence that vectorization is safe.
Threading Advisor is a threading design and prototyping tool that lets you analyze, design, tune, and check threading design options without disrupting your normal development.
Intel® Advisor is available as part of the:
Intel® Parallel Studio XE Professional Edition
Intel® Parallel Studio XE Cluster Edition
If you do not already have access to the Intel® Advisor, download an evaluation copy from http://software.intel.com/en-us/articles/intel-software-evaluation-center/. (Use Version 15.0 or higher of an Intel compiler to get more benefit from the Vectorization Advisor Survey Report; download an evaluation copy from http://software.intel.com/en-us/articles/intel-software-evaluation-center/.)
To build applications that produce the most accurate and complete Vectorization Advisor analysis results, build an optimized binary of your application in release mode using these settings:
To Do This |
Optimal C/C++ Settings |
|---|---|
Request full debug information (compiler and linker). |
Linux* OS command line: -g
|
Request moderate optimization. |
Linux* OS command line: -O2 or higher Windows* OS command line: /O2 or higher Visual Studio* IDE: C/C++ > Optimization > Optimization > Maximize Speed (/O2) or higher |
Produce compiler diagnostics (necessary for version 15.0 of the Intel compiler; unnecessary for version 16.0 and higher). |
Linux* OS command line: -qopt-report=5 Windows* OS command line: /Qopt-report:5 Visual Studio* IDE: C/C++ > Diagnostics [Intel C++] > Optimization Diagnostic Level > Level 5 (/Qopt-report:5) |
Enable vectorization |
Linux* OS command line: -vec Windows* OS command line: /Qvec |
Enable SIMD directives |
Linux command line: -simd Windows* OS command line: /Qsimd |
Enable generation of multi-threaded code based on OpenMP* directives. |
Linux* OS command line: -qopenmp Windows* OS command line: /Qopenmp Visual Studio* IDE: C/C++ > Language [Intel C++] > OpenMP Support > Generate Parallel Code (/Qopenmp) |
To Do This |
Optimal Fortran Settings |
|---|---|
Request full debug information (compiler and linker). |
Linux* OS command line: -g
|
Request moderate optimization. |
Linux* OS command line: -O2 or higher Windows* OS command line: /O2 or higher Visual Studio* IDE: Fortran > Optimization > Optimization > Maximize Speed or higher |
Produce compiler diagnostics (necessary for version 15.0 of the Intel compiler; unnecessary for version 16.0 and higher). |
Linux* OS command line: -qopt-report=5 Windows* OS command line: /Qopt-report:5 Visual Studio* IDE: Fortran > Diagnostics > Optimization Diagnostic Level > Level 5 (/Qopt-report:5) |
Enable vectorization |
Linux* OS command line: -vec Windows* OS command line: /Qvec |
Enable SIMD directives |
Linux* OS command line: -simd Windows* OS command line: /Qsimd |
Enable generation of multi-threaded code based on OpenMP* directives. |
Linux* OS command line: -qopenmp Visual Studio* IDE: Fortran > Language > Process OpenMP Directives > Generate Parallel Code (/Qopenmp) |
Do one of the following to set up your Linux* OS environment.
Run one of the following source commands:
For csh/tcsh users: source <advisor-install-dir>/advixe-vars.csh
For bash users: source <advisor-install-dir>/advixe-vars.sh
The default installation path, <advisor-install-dir>, is below:
/opt/intel/ for root users
$HOME/intel/ for non-root users
Add <advisor-install-dir>/bin32 or <advisor-install-dir>/bin64 to your path.
Run the <parallel-studio-install-dir>/psxevars.csh or <parallel-studio-install-dir>/psxevars.sh command. The default installation path, <parallel-studio-install-dir>, is below:
/opt/intel/ for root users
$HOME/intel/ for non-root users
Setting up the Windows* OS environment is necessary only if you use the advixe-gui command to launch the Intel Advisor standalone GUI (or the advixe-cl command to run the command line interface). To set up your Intel Advisor environment, run the <advisor-install-dir>\advixe-vars.bat or the <parallel-studio-install-dir>\psxevars.bat command.
The default installation path for both <advisor-install-dir> and <parallel-studio-install-dir> is below C:\Program Files (x86)\IntelSWTools\ (on certain systems, instead of Program Files (x86), the directory name is Program Files ).
Verify your application runs before trying to analyze it with the Intel Advisor.
Make sure you run the Intel Advisor in the same Linux* OS environment as your application.
Follow these steps (white blocks are optional) to get started using the
Vectorization Advisor in the
Intel Advisor.
Survey Report - Offers integrated compiler report data and performance data all in one place. Use the Survey Report to help identify:
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
Performance problems
The Survey Report also provides code-specific recommendations for how to fix vectorization issues, and quick visibility into source code and assembly code.
Trip Counts and FLOPs analysis - Dynamically identifies the number of times loops are invoked and execute (sometimes called call count/loop count and iteration count respectively); and provides data about floating-point operations, memory traffic, and AVX-512 mask usage. Use this added information in the Survey Report to make better decisions about your vectorization strategy for particular loops, as well as optimize already-parallel loops.
Roofline chart - Helps visualize actual performance against hardware-imposed performance ceilings, as well as determine the main limiting factor (memory bandwidth or compute capacity), thereby providing an ideal roadmap of potential optimization steps.
Use the Roofline chart to answer the following questions:
What is the maximum achievable performance with your current hardware resources?
Does your application work optimally on current hardware resources?
If not, what are the best candidates for optimization?
Is memory bandwidth or compute capacity limiting performance for each optimization candidate?
Dependencies Report - For safety purposes, the compiler is often conservative when assuming data dependencies. Use a Dependencies-focused Refinement Report to check for real data dependencies in loops the compiler did not vectorize because of assumed dependencies. If real dependencies are detected, the analysis can provide additional details to help resolve the dependencies. Your objective: Identify and better characterize real data dependencies that could make forced vectorization unsafe.
Memory Access Patterns (MAP) Report - Use a MAP-focused Refinement Report to check for various memory issues, such as non-contiguous memory accesses and unit stride vs. non-unit stride accesses. Your objective: Eliminate issues that could lead to significant vector code execution slowdown or block automatic vectorization by the compiler.
For the Linux* standalone GUI: Run the advixe-gui command.
For the Windows* standalone GUI: Do one of the following:
Run the advixe-gui command.
From the Microsoft Windows* 7 Start menu, select Intel Parallel Studio XE 201n > Analyzers > Advisor.
From the Microsoft Windows* 8/8.1/10 All Apps screen, select Intel Parallel Studio XE 201n > Intel Advisor 201n.
For the Visual Studio* IDE: Open your solution in the Visual Studio* IDE.
For the standalone GUI:
Choose File > New > Project… (or click New Project… in the Welcome page) to open the Create a Project dialog box.
Supply a name and location for your project, then click the Create Project button to open the Project Properties dialog box.
On the left side of the Analysis Target tab, ensure the Survey Hotspots Analysis type is selected.
Set the appropriate parameters. (Setting the binary/symbol search and source search directories is optional for the Vectorization Advisor.)
Click the OK button to close the Project Properties dialog box.
On the left side of the Analysis Target tab, ensure the Survey Hotspots Analysis type is selected.
Set the appropriate parameters. (Setting the binary/symbol search and source search directories is optional for the Vectorization Advisor.)
Click the OK button to close the Project Properties dialog box.
If you plan to run other vectorization analysis types, set parameters for them now, if possible.
If possible, use the Inherit settings from Survey Hotspots Analysis Type checkbox for other analysis types.
The Survey Trip Counts Analysis type has similar parameters to the Survey Hotspots Analysis type.
The Dependencies Analysis and Memory Access Patterns Analysis types consume more resources than the Survey Hotspots Analysis type. If these Refinement analyses take too long, consider decreasing the workload.
Select Track stack variables in the Dependencies Analysis type to detect all possible dependencies.
When necessary, click the tab at the top of the Workflow pane to switch between the Vectorization Workflow and Threading Workflow.
Under
Survey Target in the
Vectorization Workflow, click the
control to collect Survey data while your application executes.
If the
Workflow is not displayed in the Visual Studio IDE: Click the
icon on the
Intel Advisor toolbar.
After the Intel Advisor collects the data, it displays a Survey Report similar to the following:
There are many controls available to help you focus on the data most important to you, including the following:
This step is optional.
Before running a Trip Counts and/or FLOPs analysis, make sure you set the appropriate Project Properties for the Survey Trip Counts Analysis type. (Use the same application, but a smaller input data set if possible.)
Under
Find Trip Counts and FLOPS in the
Vectorization Workflow, select the
Trip Counts and/or
FLOPS checkbox; then click the
control to collect Trip Counts and/or FLOPS data while your application executes.
After the Intel Advisor collects the data, it adds a Trip Counts and/or FLOPS column set to the Survey Report. Expand the column set(s) to see all available data.
This step is optional.
Before running a Roofline analysis, make sure you set the appropriate Project Properties for the Survey Hotspots Analysis and Survey Trip Counts Analysis types.
Under
Roofline in the
Vectorization Workflow, click the
control to execute your target application twice to:
Measure the hardware limitations of your machine and collect loop/function timings using the Survey analysis.
Collect FLOPs data using the Trip Counts and FLOPS analysis - this collection can take three to four times longer than the Survey analysis.
Upon completion, the Intel Advisor displays a Roofline chart on the left side of the Survey Report.
The Roofline chart plots an application's achieved floating-point 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 loop/function algorithm, transferred between CPU/VPU and memory
Floating-point performance (y axis) - measured in billions of floating-point operations per second (GFLOPS)
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 the dot representing the loop 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. If a loop is not vectorized, the dot representing the loop 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.
In the following
Roofline chart representation, loops A and G (large red dots) B are the best candidates for optimization, while loops C, D, and E (small green dots) are poor candidates.
See the Intel Advisor Help for a complete description of all Roofline chart controls.
The Survey Report, with or without a Roofline chart, provides a wealth of information. See the Intel Advisor Help for investigation tips.
After you investigate the data, you have several choices:
This step is optional.
Before running a Dependencies analysis, make sure you:
Set the appropriate Project Properties for the Dependencies Analysis type. (Use the same application, but a smaller input data set if possible. And select Track stack variables to detect all possible dependencies.)
Mark one or more un-vectorized loops for deeper analysis in the Survey Report.
Under
Check Dependencies in the
Vectorization Workflow, click the
control to collect Dependencies data while your application executes.
After the Intel Advisor collects the data, it displays a Dependencies-focused Refinement Report similar to the following:
There are many controls available to help you focus on the data most important to you, including the following:
1 |
To display more information in the Dependencies Report about a loop you selected for deeper analysis: Click the associated data row. |
2 |
To display instruction addresses and code snippets for associated code locations in the Code Locations pane: Click a data row. To choose a problem of interest to display in the Dependencies Source window: Right click a data row, then choose View Source. To open your default editor in another tab/window: Right-click a data row, then choose Edit Source to open an editor tab. |
3 |
To choose a code location of interest to display in the Dependencies Source window: Right-click a data row, then choose View Source. To open your default editor in another tab/window: Right-click a data row, then choose Edit Source to open an editor tab. |
4 |
|
5 |
To populate these columns and the Memory Access Patterns Report with data, run a Memory Access Patterns analysis. |
Depending on what the Dependencies Report shows, do one or more of the following:
If there is no real dependency in the loop for the given workload, use one of the following to tell the compiler it is safe to vectorize:
#pragma simd ICL/ICC/ICPC directive, or #pragma omp simd OpenMP* 4.0 standard, or !DIR$ SIMD or !$OMP SIMD IFORT directive to ignore all dependencies in the loop
#pragma ivdep ICL/ICC/ICPC directive or !DIR$ IVDEP IFORT directive to ignore only vector dependencies (which is safest, but less powerful in certain cases)
restrict keyword
If there is an anti-dependency (often called a Write after read dependency or WAR), enable vectorization using the #pragma simd vectorlength(k) ICL/ICC/ICPC directive or !DIR$ SIMD VECTORLENGTH(k) IFORT directive, where k is smaller than the distance between dependent items in anti-dependency:
If there is a reduction in the loop, enable vectorization using the #pragma omp simd reduction(operator:list) ICL/ICC/ICPC directive or !$OMP SIMD REDUCTION(operator:list) IFORT directive.
Rewrite code to remove dependencies.
After you finish making improvements:
Run a MAP analysis if desired.
Rebuild your modified code.
Run another Survey analysis, with or without a Roofline chart, to verify your application still runs correctly and all test cases pass, all loops are vectorizing properly, and performance is satisfactory.
This step is optional.
Before running a MAP analysis, make sure you:
Set the appropriate Project Properties for the Memory Access Patterns Analysis type. (Use the same application, but a smaller input data set if possible.)
Mark one or more loops for deeper analysis in the Survey Report.
Under
Check Memory Access Patterns in the
Vectorization Workflow, click the
control to collect MAP data while your application executes.
After the Intel Advisor collects the data, it displays a MAP-focused Refinement Report similar to the following:
After you finish making improvements:
Rebuild your modified code.
Run another Survey analysis, with or without a Roofline chart, to verify your application still runs correctly and all test cases pass, all loops are vectorizing properly, and performance is satisfactory.
Double-click source lines at the bottom of the report to get a more detailed source and assembly access pattern report where stride information is provided at the instruction level.
Also, see https://software.intel.com/en-us/intel-advisor-xe-support/faq.
To build applications that produce the most accurate and complete Threading Advisor analysis results, build an optimized binary of your application in release mode using these settings:
To Do This |
Optimal C/C++ Settings |
|---|---|
Search additional directory related to Intel Advisor annotation definitions. |
Linux* OS command line: -I${ADVISOR_XE_[product_year]_DIR}/include Windows* OS command line: /I"%ADVISOR_XE_[product_year]_DIR%"\include Microsoft Visual Studio* IDE: C/C++ > General > Additional Include Directories > $(ADVISOR_XE_[product_year]_DIR)\include;%(AdditionalIncludeDirectories) |
Request full debug information (compiler and linker). |
Linux* OS command line: -g
|
Request moderate optimization. |
Linux* OS command line: -O2 or higher
|
Search for unresolved references in multithreaded, dynamically linked libraries. |
Linux* OS command line: -Bdynamic Windows* OS command line: /MD or /MDd Visual Studio* IDE: C/C++ > Code Generation > Runtime Library > Multi-threaded DLL (/MD) or Multi-threaded Debug DLL (/MDd) |
Enable dynamic loading. |
Linux* OS command line: -ldl |
To Do This |
Optimal Fortran Settings |
|---|---|
Search additional directory related to Intel Advisor annotation definitions. |
|
Request full debug information (compiler and linker). |
Linux* OS command line: -g
|
Request moderate optimization. |
Linux* OS command line: -O2 or higher
|
Search for unresolved references in multithreaded, dynamically linked libraries. |
Linux* OS command line: -shared-intel Windows* OS command line: /MD or /MDd Visual Studio* IDE: Fortran > Libraries > Runtime Library > Multithread DLL (/libs:dll /threads) or Debug Multithread DLL (/libs:dll /threads /dbglibs) |
Enable dynamic loading. |
Linux* OS command line: -ldl |
Do one of the following to set up your Linux* OS environment.
Run one of the following source commands:
For csh/tcsh users: source <advisor-install-dir>/advixe-vars.csh
For bash users: source <advisor-install-dir>/advixe-vars.sh
The default installation path, <advisor-install-dir>, is below:
/opt/intel/ for root users
$HOME/intel/ for non-root users
Add <advisor-install-dir>/bin32 or <advisor-install-dir>/bin64 to your path.
Run the <parallel-studio-install-dir>/psxevars.csh or <parallel-studio-install-dir>/psxevars.sh command. The default installation path, <parallel-studio-install-dir>, is below:
/opt/intel/ for root users
$HOME/intel/ for non-root users
Setting up the Windows* OS environment is necessary only if you use the advixe-gui command to launch the Intel Advisor standalone GUI (or the advixe-cl command to run the command line interface). To set up your Intel Advisor environment, run the <advisor-install-dir>\advixe-vars.bat or the <parallel-studio-install-dir>\psxevars.bat command.
The default installation path for both <advisor-install-dir> and <parallel-studio-install-dir> is below C:\Program Files (x86)\IntelSWTools\ (on certain systems, instead of Program Files (x86), the directory name is Program Files ).
Verify your application runs before trying to analyze it with the Intel Advisor.
Make sure you run the Intel Advisor in the same Linux* OS environment as your application.
Follow these steps (white blocks are optional) to get started using the
Threading Advisor in the
Intel Advisor.
Survey Report - Shows the loops and functions where your application spends the most time. Use this information to discover candidates for parallelization with threads.
Trip Counts analysis - Shows the minimum, maximum, and median number of times a loop body will execute, as well as the number of times a loop is invoked. Use this information to make better decisions about your threading strategy for particular loops.
Roofline chart - Applies to both Vectorization Advisor and Threading Advisor, but is most useful in Vectorization Advisor.
Annotations - Insert to mark places in your application that are good candidates for later replacement with parallel framework code that enables threading parallel execution. Annotations are subroutine calls or macros (depending on the programming language) that can be processed by your current compiler but do not change the computations of your application.
Suitability Report - Predicts the maximum speed-up of your application based on the inserted annotations and a variety of what-if modeling parameters with which you can experiment. Use this information to choose the best candidates for parallelization with threads.
Dependencies Report - Predicts parallel data sharing problems based on the inserted annotations. Use this information to fix the data sharing problems if the predicted maximum speed-up benefit justifies the effort.
For the Linux* standalone GUI: Run the advixe-gui command.
For the Windows* standalone GUI, do one of the following:
Run the advixe-gui command.
From the Microsoft Windows* 7 Start menu, select Intel Parallel Studio XE 201n > Analyzers > Advisor.
From the Microsoft Windows* 8/8.1/10 All Apps screen, select Intel Parallel Studio XE 201n > Intel Advisor 201n.
For the Visual Studio* IDE: Open your solution in the Visual Studio* IDE.
For the standalone GUI:
Choose File > New > Project… (or click New Project… in the Welcome page) to open the Create a Project dialog box.
Supply a name and location for your project, then click the Create Project button to open the Project Properties dialog box.
On the left side of the Analysis Target tab, ensure the Survey Hotspots Analysis type is selected.
Set the appropriate parameters, and binary/symbol search and source search directories.
Click the OK button to close the Project Properties dialog box.
On the left side of the Analysis Target tab, ensure the Survey Hotspots Analysis type is selected.
Set the appropriate parameters, and binary/symbol search and source search directories.
Click the OK button to close the Project Properties dialog box.
If you plan to run other threading analysis types, set parameters for them now, if possible.
If possible, use the Inherit settings from Survey Hotspots Analysis Type checkbox for other analysis types.
The Survey Trip Counts Analysis type has similar parameters to the Survey Hotspots Analysis type.
The Dependencies Analysis type consume more resources than the Survey Hotspots Analysis type. If Dependencies analysis take too long, consider decreasing the workload.
When necessary, click the tab at the top of the Workflow pane to switch between the Vectorization Workflow and Threading Workflow.
Under
Survey Target in the
Threading Workflow, click the
control to collect Survey data while your application executes. Use the resulting information to discover candidates for parallelization with threads.
If the
Workflow is not displayed in the Visual Studio IDE: Click the
icon on the
Intel Advisor toolbar.
This step is optional.
Before running a Trip Counts analysis, make sure you set the appropriate Project Properties for the Survey Trip Counts Analysis type. (Use the same application, but a smaller input data set if possible.)
Under
Find Trip Counts and FLOPS in the
Threading Workflow, select the
Trip Counts checkbox, then click the
control to collect Trip Counts data while your application executes.
After the Intel Advisor collects the data, it adds a Trip Counts column set to the Survey Report. Expand the column set to see all available data.
Pay particular attention to the hottest loops in terms of Self Time and Total Time. Optimizing these loops provides the most benefit. Outermost loops with significant Total Time are often good candidates for parallelization with threads. Innermost loops and loops near innermost loops are often good candidates for vectorization.
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. After inserting annotations, rebuild your application in release mode.
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.
Threading AdvisorHelp sample annotated source code you can copy into your editor:
Annotation Code Snippet |
Purpose |
|---|---|
Iteration Loop, Single Task |
Create a simple loop structure, where the task code includes the entire loop body. This common task structure is useful when only a single task is needed within a parallel site. |
Loop, One or More Tasks |
Create loops where the task code does not include all of the loop body, or complex loops or code that requires specific task begin-end boundaries, including multiple task end annotations. This structure is also useful when multiple tasks are needed within a parallel site. |
Function, One or More Tasks |
Create code that calls multiple tasks within a parallel site. |
Pause/Resume Collection |
Temporarily pause data collection and later resume it, so you can skip uninteresting parts of application execution to minimize collected data and speed up analysis of large applications. Add these annotations outside a parallel site. |
Build Settings |
Set build (compiler and linker) settings specific to the language in use. |
Choosing where to add task annotations may require some experimentation. If your parallel site has nested loops and the computation time used by the innermost loop is small, consider adding task annotations around the next outermost loop.
Before running a Suitability analysis, make sure you set the appropriate Project Properties for the Suitability Analysis type.
Under
Check Suitability in the
Threading Workflow, click the
control to collect Suitability data while your application executes.
The Suitability Report predicts maximum speed-up data 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.
Before running a Dependencies analysis, make sure you set the appropriate Project Properties for the Dependencies Analysis type. (Use the same application, but a smaller input data set if possible.)
Under
Check Dependencies in the
Threading Workflow, click the
control to collect Dependencies data while your application executes. Use the resulting information to fix the data sharing problems if the predicted maximum speed-up benefit justifies the effort.
This step is optional.
If you decide the predicted maximum speed-up benefit is worth the effort to add threading parallelism to your application,
Complete developer/architect design and code reviews about the proposed parallel changes.
Choose one parallel programming framework (threading model) for your application, such as Intel® Threading Building Blocks (Intel® TBB), OpenMP*, Microsoft Task Parallel Library* (TPL), or some other parallel framework.
Add the parallel framework to your build environment.
Add parallel framework code to synchronize access to the shared data resources, such as Intel TBB or OpenMP* locks.
Add parallel framework code to create parallel tasks.
As you add the appropriate parallel code from the chosen parallel framework during steps 4 and 5, you can keep, comment out, or replace the Intel Advisor annotations.
You can use the Intel Advisor command line interface, advixe-cl, to run analyses and reports. This makes it possible to automate many tasks as well as analyze an application running on remote hosts. You can then view results using the Intel Advisor GUI or command line reports.
Below are command line examples of typical Intel Advisor tasks.
To Do This |
Use This Command Line Model |
|---|---|
View a full list of command line options. (Applies to Vectorization Advisor & Threading Advisor.) |
advixe-cl -help Note:
You can also check the Intel AdvisorHelp document. |
Run a Survey analysis. (Applies to Vectorization Advisor & Threading Advisor.) |
Linux* OS: advixe-cl -collect survey –project-dir ./myAdvisorProj -- myTargetApplication Windows* OS: advixe-cl -collect survey -project-dir myAdvisorProj -- myTargetApplication |
After running a Survey analysis, run a Trip Counts and FLOPS analysis (Trip Counts applies to Vectorization Advisor & Threading Advisor; FLOPS is most useful in Vectorization Advisor.) |
Linux* OS: advixe-cl -collect tripcounts -flops-and-masks –project-dir ./myAdvisorProj -- myTargetApplication Windows* OS: advixe-cl -collect tripcounts -flops-and-masks -project-dir myAdvisorProj -- myTargetApplication |
After running a Survey analysis, build a Roofline chart for an application with floating-point operations. (Roofline applies to Vectorization Advisor & Threading Advisor, but is most useful in Vectorization Advisor.) |
Linux* OS: advixe-cl -collect tripcounts -flops-and-masks –project-dir ./myAdvisorProj -- myTargetApplication Windows* OS: advixe-cl -collect tripcounts -flops-and-masks -project-dir myAdvisorProj -- myTargetApplication Tip:
Make sure you use the same project directory for both the Survey analysis and Trip Counts and FLOPS analysis. |
Print a Survey Report to identify loop IDs for Refinement analyses. (Applies to Vectorization Advisor.) |
Linux* OS: advixe-cl -report survey –project-dir ./myAdvisorProj Windows* OS: advixe-cl -report survey -project-dir myAdvisorProj |
Run a Refinement analysis. (Applies to Vectorization Advisor.) |
Linux* OS: advixe-cl -collect [dependencies | map] -mark-up-list=[loopID],[loopID] –project-dir ./myAdvisorProj -- myTargetApplication Windows* OS: advixe-cl -collect [dependencies | map] -mark-up-list=[loopID],[loopID] -project-dir myAdvisorProj -- myTargetApplication |
Run a Dependencies analysis. (Applies to Threading Advisor.) |
Linux* OS: advixe-cl -collect dependencies -project-dir ./myAdvisorProj -- myTargetApplicaton Windows* OS: advixe-cl -collect dependencies -project-dir myAdvisorProj -- myTargetApplicaton |
Report a top-down functions list instead of a loop list. (Applies to Vectorization Advisor & Threading Advisor.) |
advixe-cl -report survey -top-down -display-callstack |
Report all compiler opt-report and vec-report metrics. (Applies to Vectorization Advisor.) |
advixe-cl -report survey -show-all-columns |
Report the top five self-time hotspots that were not vectorized because of a not inner loop msg id. (Applies to Vectorization Advisor.) |
advixe-cl -report survey -limit 5 -filter "Vectorization Message(s)"="loop was not vectorized: not inner loop" |
Click the appropriate
control in the
Workflow to generate the corresponding collection command line.
You can perform an MPI analysis only through the Intel Advisor command line interface; however, there are several ways to view an Intel Advisor result:
If you have an Intel Advisor GUI in your cluster environment, open a result in the GUI.
If you do not have an Intel Advisor GUI on your cluster node, copy the result directory to another machine with the Intel Advisor GUI and open the result there.
Use the Intel Advisor command line reports to browse results on a cluster node.
Use mpirun, mpiexec, or your preferred MPI batch job manager with the advixe-cl command to start an analysis. You may also use the -gtool option of mpirun. See the Intel® MPI Library Reference Manual (available in the Intel® Software Documentation Library) for more information.
Below are command line examples of typical Intel Advisor MPI tasks.
To Do This |
Use This Command Line Model |
|---|---|
Run 10 MPI ranks (processes), and start an Intel Advisor analysis on each rank. |
Linux* OS: $ mpirun -n 10 advixe-cl -collect survey --project-dir ./my_proj ./your_app Windows* OS: $ mpirun -n 10 advixe-cl -collect survey --project-dir my_proj your_app Intel Advisor creates a number of result directories in the current directory, named as rank.0, rank.1, ... rank.n, where n is the MPI process rank. Intel Advisor does not combine results from different ranks, so you must explore each rank result independently. |
Run 10 MPI ranks, and start an Intel Advisor analysis only on rank #1. |
Linux* OS: $ mpirun -n 1 advixe-cl -collect survey --project-dir ./my_proj ./your_app : -np 9 ./your_app Windows* OS: $ mpirun -n 10 advixe-cl -collect survey --project-dir my_proj your_app |
Linux* OS: Available offline documentation is installed below <advisor-install-dir>/documentation/<locale>/. The default installation path, <advisor-install-dir>, is below:
/opt/intel/ for root users
$HOME/intel/ for non-root users
Windows* OS: Available offline documentation is installed below <advisor-install-dir>\documentation\<locale>\. The default installation path, <advisor-install-dir>, is below C:\Program Files (x86)\IntelSWTools\ (on certain systems, instead of Program Files (x86), the directory name is Program Files).
Check online for the most up-to-date documentation.
Document/Resource |
Description |
|---|---|
Online training is an excellent resource for novice, intermediate, and advanced users. It includes links to videos, guides, featured topics, event recaps and archived webinars, upcoming events and webinars, and more. |
|
Contain up-to-date information about the Intel Advisor, including a description, technical support, and known limitations. This document also contains system requirements, installation instructions, and instructions for setting up the command-line environment. |
|
Sample applications can help you learn how to use the Intel Advisor. After you copy a sample application compressed file to a writable directory, use a suitable tool to extract the contents. To load a sample into the Visual Studio* environment, double-click the .sln file. Tutorials provide detailed steps that illustrate exactly what you will see when you perform the same steps with accompanying sample code. |
|
Windows* OS: | Intel Advisor 2018 Help Linux* OS: | Intel Advisor 2018 Help |
The Help is the primary documentation for the Intel Advisor. |
Offline Resources |
One of the key Vectorization Advisor features is a Survey Report that offers integrated compiler report data and performance data all in one place, including GUI-embedded advice on how to fix vectorization issues specific to your code. To help you quickly locate information that augments that GUI-embedded advice, the Intel Advisor provides Intel compiler mini-guides. You can also find complete Recommendations and Compiler Diagnostic Details advice libraries in the same location as the mini-guides. Each issue and recommendation in these HTML files is collapsible/expandable. |
More Resources |
Vectorization Advisor Glossary Vectorization Resources for Intel® Advisor Users Intel® Learning Lab (white papers, articles and more) |
You may encounter the following known issues when using the following to view documentation:
Microsoft Windows Server* 2012 system: Trusted site prompt appears. Solution: Add about:internet to the list of trusted sites in the Tools > Internet Options > Security tab. You can remove after you finish viewing the documentation.
Microsoft Internet Explorer* 11 browser: Topics do not appear when you select them in the TOC pane. Solution: Add http://localhost to the list of trusted sites in the Tools > Internet Options > Security tab. You can remove after you finish viewing the documentation.
Microsoft Edge browser: Context-sensitive (also known as F1) calls to a specific topic open the title page of the corresponding document instead. Solution: Set the Visual Studio* IDE to use a different default browser.
Microsoft Edge browser: Panes are truncated and a proper style sheet is not applied. Solution: Click the Menu <...> and select Open with Internet Explorer.
Intel, the Intel logo, Intel Xeon Phi, VTune, and Xeon are trademarks of Intel Corporation in the U.S. and/or other countries.
*Other names and brands may be claimed as the property of others.
Microsoft, Windows, and the Windows logo are trademarks, or registered trademarks of Microsoft Corporation in the United States and/or other countries.
© Intel Corporation