Here is a test case: the function is used by many threads, and each thread computes value in local variable "lpot" in loop, and accumulates local value into global variable "pot"

1)  for( i=start; i<end; i++ ) {

      for( j=0; j<i-1; j++ ) {

        distx = pow( (r[0][j] - r[0][i]), 2 );

        disty = pow( (r[1][j] - r[1][i]), 2 );

        distz = pow( (r[2][j] - r[2][i]), 2 );

        dist = sqrt( distx + disty + distz );     

       lpot += 1.0 / dist;

      }

   }

   EnterCriticalSection(&cs);

      pot += lpot;

   LeaveCriticalSection(&cs);

In this implementation, time comsumption of sys-obj "CRITICAL_SECTION cs;" will be analyzed in the result of Intel® Thread Profiler

2) for( i=start; i<end; i++ ) {

      for( j=0; j<i-1; j++ ) {

        distx = pow( (r[0][j] - r[0][i]), 2 );

        disty = pow( (r[1][j] - r[1][i]), 2 );

        distz = pow( (r[2][j] - r[2][i]), 2 );

        dist = sqrt( distx + disty + distz );     

        lpot += 1.0 / dist;

      }

   }

  while (!spin) {

          spin = 1;

          pot += lpot;

   }

   spin = 0;

In this implementation, time consumption of user's "spin" will NOT be analyzed

3)  for( i=start; i<end; i++ ) {

      for( j=0; j<i-1; j++ ) {

        distx = pow( (r[0][j] - r[0][i]), 2 );

        disty = pow( (r[1][j] - r[1][i]), 2 );

        distz = pow( (r[2][j] - r[2][i]), 2 );

        dist = sqrt( distx + disty + distz );     

        lpot += 1.0 / dist;

      }

   }

   sync_prepare(&spin);

   while (!spin) {

          spin = 1;

          sync_acquired(&spin);

          pot += lpot;

   }

   sync_releasing (&spin);

   spin = 0;

In this implementation, time consumption of user's "spin" will be analyzed again.

Note that the user can get libittnotify's APIs as below

#include <ittnotify.h>

......

typedef void (*itt_notify_sync_prepare)(void *);

typedef void (*itt_notify_sync_acquired)(void *);

typedef void (*itt_notify_releasing)(void *);

HMODULE hMod;

itt_notify_sync_prepare sync_prepare;

itt_notify_sync_acquired sync_acquired;

itt_notify_releasing sync_releasing;

......
hMod = LoadLibrary("libittnotify.dll");

sync_prepare = (itt_notify_sync_prepare) GetProcAddress(hMod, "__itt_notify_sync_prepare");

sync_acquired = (itt_notify_sync_acquired) GetProcAddress(hMod, "__itt_notify_sync_acquired");

sync_releasing = (itt_notify_releasing) GetProcAddress(hMod, "__itt_notify_sync_releasing");

Microsoft* Visual Studio* 2008

Intel (R) VTune(TM) Performance Analyzer v9.1 Update 2 with Intel(R) Thread Profiler 3.1 Update 12

Intel(R) Thread Checker 3.1 Update 12

Intel(R) Parallel Studio, Initial Release

Problem:

The user installed VTune(TM) Performance Analyzer with Intel(R) Thread Profiler, Intel(R) Thread Checker first, then installed Intel(R) Parallel Studio. The icons of VTune(TM) Analyzer and other tools will be hidden in Toolbar's Options due to limited length of Toolbar. However if the user opened a solution and built project(s), then click on "Tuning Browser" tab, the user can't create a new advanced build activity since the icon was grayed.

Root-cause:

This is an unexpected error of the integration of Microsoft* Visual Studio* after installing Intel(R) Parallel Studio. For example, when the user has no solution file opened, all icons of tools should be inactive; When the user opens a new solution file, all icons of Intel(R) Parallel Studio are active, but some icons of old tools are inactive.

Resolution:

1. Click on "Tuning Browser" tab first
2. Click on "Solution Explorer" tab
3. Click on "Tuning Browse" tab again.
4. Click on the project in "Tuning Browser" window

The icon of "Advanced Activity Build" should be active.

This document provides guidelines for developing efficient multi-threaded applications across Intel® architecture-based symmetric multi-processors (SMP) and/or systems with Hyper-Threading Technology.

	Developing Multithread Applications [PDF]
	File Name: multithreadyuide.pdf Size: 2,173,605 bytes Date: 11/2004

Note: PDF Files require Adobe Acrobat* Reader^†

^† This link will take you off of the Intel Web site. Intel does not control the content of the destination Web Site.

This document introduces threading concepts and provides a methodology for threading serial applications and for tuning threaded applications for performance using the Intel® Threading Tools.

	Threading Methodology: Principles and Practices [PDF]
	File Name: methodology.pdf Size: 1,684,645 bytes Date: 11/2004

Note: PDF Files require Adobe Acrobat* Reader^†

^† This link will take you off of the Intel Web site. Intel does not control the content of the destination Web Site.

• What is instrumentation?
• What is binary instrumentation?
• Does Intel® Intel Thread Profiler support source instrumentation?
• Does Intel Thread Profiler for OpenMP* use binary instrumentation?
• What system resources does instrumentation use?
• What instrumentation level should I use?
• How do I set the default instrumentation levels?

What is instrumentation?
Intel Thread Profiler for Windows* or Pthreads* API instruments software before tracing it to find errors. Instrumentation adds benign Intel Thread Profiler library calls into the software to be traced. The Intel Thread Profiler library calls record information about threads, including thread interactions and concurrency.

What is binary instrumentation?
Binary instrumentation is added at run-time to an already built (made) binary module, including applications and dynamic or shared libraries. The instrumentation code is automatically inserted when you run a Intel Thread Profiler for Windows* or Pthreads* API activity in the VTune™ environment or the Microsoft .NET* Development Environment. Both Microsoft Windows* and Linux* executables can be instrumented for IA-32 processors, but not for Itanium® processors. Binary instrumentation can be used for software compiled with any of the supported compilers.

Does Intel Thread Profiler support source instrumentation?
No. Intel Thread Profiler for Windows* or Pthreads* API does not support source instrumentation or instrumentation added at compile-time.

Does Intel Thread Profiler for OpenMP* use binary instrumentation?
Application executables and dynamic or shared libraries are not instrumented. Instead the Intel® Compilers ship with OpenMP run-time libraries that are pre-instrumented already.

What system resources does instrumentation use?
The process of adding instrumentation to your software takes time (CPU MIPs) and memory. Once the instrumentation has been added, your software will both run slower and use more memory than it usually does. This is because as your software runs, the Intel Thread Profiler library is recording information about your software's threads as your software runs. The first run of your software under Intel Thread Profiler for Windows* or Pthreads* API will accumulate the overhead of instrumentation and reflect the overhead in the results. All subsequent runs of the same executable code will generally show very little of this overhead.

What instrumentation level should I use?
Generally using the default instrumentation level of "API Imports" is recommended for User code (application executables, dynamic or shared library files). You should not reduce the instrumentation level below "API Imports" (that is to "Module Imports") for your User code because then Intel Thread Profiler may not produce accurate results.

How do I set the default instrumentation levels?
First, select or create a Intel Thread Profiler for Windows* or Pthreads* API activity. Then follow these steps:

1. In the VTune™ environment, use the Configure » Options... » Intel Thread Profiler » Instrumentation Levels dialog.
2. In the Microsoft .NET* Development Environment, use the Tools » Options... » VTune™ Performance Tools » Intel Thread Profiler » Instrumentation Levels dialog. Note: Setting the default levels in one environment, such as the VTune™ environment, does not propagate the changes to other environments, such as the Microsoft .NET* Development Environment.

• Intel® Thread Profiler for Windows* or Pthreads* API
• General Tips on Preparing Source Code
• Run-time Warnings
• API: Can I use it without source code?

• Intel Thread Profiler for OpenMP*

• General Tips on Preparing Source Code
• Run-time Warnings
• API: Can I use it without source code?

For Windows* or Pthreads* API: General Tips on Preparing Source Code
The following are general tips for preparing source code for Intel Thread Profiler for Windows or Pthreads API. Build (make) your source with the following switches:

• For Windows*: Be sure to build thread-safe by compiling with the /MD, /MDd, /MT or /MTd switches to use the multi-threaded libraries.

Note: On Windows*, the default for Microsoft and Intel® Compilers is the /ML or /MLd switch and this does not use thread-safe libraries.

• Be sure to provide symbols. For Windows* generate symbols by compiling with the /Zi, /ZI or /Z7 switches and link with the /DEBUG switch. For Linux* generate symbols with the -g switch. Symbols will enable Intel Thread Profiler to specify source code information (file name and line number) with its results.

Note: Symbols can be generated with a "release" (optimized) build.

• You can use either an optimized "Release" or a non-optimized "Debug" build. A Debug build for Windows* will disable optimization with the /Od switch, and on Linux* a debug build will use the -O0 switch. Of course, just like when using a debugger, the Intel Thread Profiler Results (especially line numbers) may not be accurate, if you use an optimized build.

• On Windows*, executable software must be built so that it contains a relocation section which allows for relocation in memory and relocation is required for instrumentation. Most dynamic-link library (.dll) files can be relocated by default. However by default, most executable (.exe) files cannot be relocated. So always link with the /FIXED:NO switch to allow for relocation.

Windows* Tip: Instead of changing your project's settings, set the (system) environment variable "LINK" to the value "/FIXED:NO" and re-link your code to add a relocation section.

For Windows* or Pthreads* API: Run-time Warnings
On Windows*, if you get the warning "modules were created without base relocations" when you run a Intel Thread Profiler for Windows* API activity in the VTune™ environment or Microsoft .NET* Development Environment, your code probably doesn't contain a relocation section. Link with the /FIXED:NO switch to add a relocation section.

For Windows* or Pthreads* API: Can I use it without source code?
Yes -- But on Microsoft Windows*, do not expect to get any results for the application (.exe) file itself because typically on Windows the executable does not have a relocation section. But Intel Thread Profiler is designed to help you locate threading performance issues in source code.

For OpenMP*: General Tips on Preparing Source Code
The following are general tips for preparing source code for Intel Thread Profiler for OpenMP*.

• You must compile with Intel® Compilers to get support for OpenMP.
• On Windows*, be sure to build thread-safe by compiling with the /MD, /MDd, /MT or /MTd switches to use the multi-threaded libraries.
  Note: On Windows*, the default for Intel® Compilers is the /ML or /MLd switch and this does not use thread-safe libraries.
• Do not compile with the /Qtcheck or -tcheck switch.
• Symbols and line numbers are not required.
• Use an optimized "Release" build.
• When running in the VTune™ environment or Microsoft .NET* Developer Environment, compile with one of Windows* /Qopenmp or Linux* -openmp* switch or one of Windows* /Qopenmp_profile or Linux* -openmp switch, but not both. That is don't build with both /Qopenmp and /Qopenmp_profiler nor both of -openmp and -openmp_profile.
• To run from the Windows* shell or DOS* command-prompt, compile with the /Qopenmp_profile switch. To run from the Linux* shell, build with -openmp_profile.

For OpenMP*: Run-time Warnings
I get a warning "The application you chose to launch has not been instrumented to generate OpenMP* statistics". What is this about? You built your software without Intel® Compilers, or your executable file was compiled without any of the /Qopenmp, /Qopenmp_profile, -openmp or -openmp_profile switches. This may be okay if you are using dynamic (.dll) or shared (.so) library file(s) that are compiled with one of the OpenMP* switches. If you're using OpenMP in library files, be sure to specify these .DLL files in the Modules of Interest dialog.
For OpenMP*: Can I use it without source code?
Yes. However, Intel Thread Profiler for OpenMP* is designed to help you locate threading performance issues in source code.

• I don't have source code. Can I use Intel® Thread Profiler?
• DOS* Shell Redirection for Input (<) or Output (>)
• I'm using OpenMP* threads. Can I use Thread Profiler for Windows* API?
• How do I view source code in Intel Thread Profiler for Windows* or Pthreads* API results?
• Is there an Intel® Thread Profiler for Linux* product?

I don't have source code. Can I use Intel® Thread Profiler?
Yes. However, Intel Thread Profiler is designed to help you locate and understand threading performance issues in source code. Also note that on Windows*, Intel Thread Profiler for Windows* or Pthreads* API requires an executable file that has a relocation section, and without this no results will be produced for the .EXE file itself. For more information, visit Preparing Your Software: Building or Making Source Code.

DOS* Shell Redirection for Input (<) or Output (>)
My application uses DOS* command-shell redirection for input (<) or output (>). Can I still use Intel Thread Profiler? Yes. Use a .BAT file as the application. For example, create a myStart.bat file with this line:

myProgram.exe < myInputFile > myOutputFile

And then follow these steps:

1. Specify myProgram.exe as the Application to launch with the Intel Thread Profiler Wizard.
2. Enable (check) Modify default configuration when done with wizard.
3. Select Advanced Activity Configuration » Application/Module profiles.
4. Select your application, which would be myProgram in this example, and then press the Configure... button.
5. Disable (un-check) Add to Modules of Interest List, and then change the Application to Launch Filename: from myProgram.exe to myStart.bat.

I'm using OpenMP* threads. Can I use Intel Thread Profiler for Windows* API?
Yes. You can use Intel Thread Profiler for Windows* API provided you use the Intel® Compilers v8.0, or higher. The Intel Thread Profiler for OpenMP* will show you OpenMP-specific results using OpenMP constructs. Note: If Intel Compiler versions lower than v8.0 are used, then the Intel Thread Profiler for Windows* API results will not be correct.

How do I view source code in Intel Thread Profiler for Windows* or Pthreads* API results?

• To view Thread Create, Close or Entry source code, go to the Profile view and group by Thread or Object. Right-click on any Thread or Object, and then select Creation Source View. If the Creation Source View entry on the menu is not available (grayed-out), then the source code is unknown.
• To view thread transition source code, go to the Profile view and group by Object. Right-click on an object and Filter and Show Source locations Finally right-click on an impact-time bar and select Transition Source View.
• Another way to view thread transition source, is with the Timeline view. Zoom into a section of the time-line, and right-click on an overhead transition. Select Transition Source View.