Intel Software Network articles feed

Use command line in Intel(R) Parallel Amplifier

Tue, 13 Oct 2009 14:21:51 -0700

The Intel® Parallel Studio software contains Intel® Parallel Amplifier. This tool runs as an add-in to Microsoft* Visual Studio*. However, sometimes we need to automate our measurement work (e.g., via a script), and not run the IDE to avoid (reduce) impact on the system.

Intel® Parallel Amplifier Update 1 has realized this feature.

After installing the product, open a Command Prompt window and run the following command:

> C:\Program Files\Intel\Parallel Studio\Amplifier\ampl-vars.bat

Now, the environment for command line has been configured and you can use the ampl-cl command.

You can run ampl-cl -help to get familiar with the syntax of command.

Usage:

ampl-cl <-action-option [-modifier-option] [[--] target [target options]]

Action-option contains：collect, collect-list, report, report-list, finalize, help, version

Modifier-option contains： cumulative-threshold-percent, resume-after, result-dir, search-dir, start-pause, user-data-dir, verbose

Examples:

List all data collectors
> ampl-cl -collect-list
run target application, collect hot functions, save results in default sub-directory
> ampl-cl -collect hotspots matrix.exe
run target application, collect hot functions, save result in specified sub-directory
> ampl-cl -collect concurrency -result-dir r009cc matrix.exe
run target application, delay 3000 million seconds (e.g., 3 sec) to collect times for all locks and waits, save results in default sub-directory
> ampl-cl -collect lockswaits -start-paused -resume-after=3000 matrix.exe
List all report types
> ampl-cl -report-list
Report a result for recent running
> ampl-cl -report perf
Report a result based on data from specified sub-directory, use comma as a delimiter
> ampl-cl -report perf-detail -csv-delimiter="," -result-dir r012hs
Report enumerates modules that consumes 80% of total CPU time
> ampl-cl -report perf -result-dir r012cc -cumulative-threshold-percent=80
Compare results for two sessions
> ampl-cl -report summary -result-dir r012cc -result-dir r009cc

Call stack is not full, contains [Unknown] functions or seems incorrect

Wed, 30 Sep 2009 06:12:05 -0700

Problem :

Intel® Parallel Amplifier provides a call stack for functions in the results view. For some applications these call stacks might appear incomplete or seem incorrect according to known application work flow, even with .pdb files for the project binaries. Additionally, there could be '[Unknown]' identifiers within the function call chain displayed in the stack view. Generally, the problem appears when there is difficulty defining the call path to the user code because of system functions on top of the stack.

See the illustrative Hotspot results of analysis the multithreaded test case below. Here are several run-time functions (called in ntdll.dll) on the top of the list. It is not clear from the Call Stack View or Top-Down Tree to which user functions those calls are descending though the stack. Additionally, there are ‘Unknown’ identifiers which refer to function and module names.

Let’s study the source code of the analyzed application. The ExtendBuffer function is extending a buffer chain by allocating some memory for a new node in the linked list of buffers. ExtendBuffer is supposed to take most of the program execution time as it's being called in the loop within many threads and there are no other functions that do enough calculations to consume noticeable CPU time.

#define THREAD_NUM 16

struct chain
{
	size_t size;
	char* buf;
	chain* p_c;
};

chain* ExtendBuffer(chain* p, size_t n)
{
	chain* p_new = new chain;
	p_new->p_c = 0;
	p_new->size = n;
	p_new->buf	= new char[n];
	p->p_c = p_new;
	return p_new;
}
DWORD WINAPI TestFunc(LPVOID param)
{
	chain* p = new chain;
	for (int i=0;i<10000;i++)
		p = ExtendBuffer(p, 4);
	return 0;
}
void main()
{
	DWORD idThread[THREAD_NUM];
	HANDLE hThread[THREAD_NUM];
	for(int i=0;i
 
Getting back to the Hotspot results there is no ExtendBuffer function in the list. If searching for the known user functions (e.g. ExtendBuffer or TestFunc), they might be found under '[Unknown frame(s)]' function identifier in the stack and the attributed CPU time is not that high as expected, which is confusing.
 

Root Cause : 

Such a problem with an incomplete call stack is caused by the absence of debug info in the system modules, like ntdll.dll. Many samples are taken from the kernel module, but the data collector was not able to unwind the stack properly due to stack frame info absence.



Resolution : 


Specify paths to the Microsoft* symbol server in the Microsoft Visual Studio*, for example, http://msdl.microsoft.com/download/symbols, in Tools > Options > Debugging >  Symbols page.



For more information regarding the Microsoft Symbol Server, please see http://www.microsoft.com/whdc/devtools/debugging/debugstart.mspx
Intel® Parallel Amplifier will use the symbol files cached in the C:\websymbols directory, as it is set in the example, and provide a more complete call stack:





Now the source lines are resolved properly and with a double click onto the hotspot function a user will be navigated to the right source code:

Parallel Implementation Methods with Intel® Parallel Composer Webinar Q&A

Wed, 19 Aug 2009 17:10:55 -0700

Q&A from Webcast: The webinar "Parallel Implementation Methods with Intel® Parallel Composer" was presented by Ganesh Rao, March 31^st, 2009, as part of our technical webinar series about Multithreading tools and techniques. The following questions were selected from the list of questions and answers generated by this web cast, and may be useful to other developers as reference.

Q: SSE2 is a standard and it is supported by AMD. Why is it set as "Intel Processor Specific
     Optimization?
A: The Intel® C++ compiler can generate code targeting any processor with SSE2 instruction set support,
     using /Qax:SSE2 or can generate code that is optimized for Intel processors with SSE2 support using /QxSSE2.
     The latter offers more optimizations and it does a cpu check when the application is executed.

Q: Do you need to #include to be able to use #pragma omp?
A: No, but you need to include omp.h if you want to call the OpenMP APIs such as omp_get_num_threads(),
     omp_thread_num(), etc.

Q: If I am using omp dlls, will concurrent omp applications (processes) compete for CPU resources the
     same way as it is when I use static omp libraries?
A:   Testing shows there is practically no performance advantage to linking mulitple processes with the static OpenMP runtime, as opposed to linking with the dynamic runtime (uses DLLs), which is the default. But in either linking scenario, you have to be careful not to oversubscribe the machine if using multiple OpenMP processes. With multiple, independent OpenMP processes running on a host, the OpenMP runtime library execution mode should be 'throughput' (environment variable KMP_LIBRARY), which is the default. On the other hand, if you have a dedicated host, the runtime library execution mode should be 'turnaround', which will minimize the execution time of a single OpenMP process.

Q: How is the binary compatibility between the Intel compiler and the Visual Studio compiler maintained when VS only supports OpenMP 2.5?
A: If you want to use any new features in OpenMP 3.0, you have to use the Intel® Parallel Composer, but if you only
     use the features from OpenMP 2.5, you can use Visual C++ 2005 or 2008 or the Intel Parallel Composer. Please
     refer to this knowledge base article for more information at:
           http://software.intel.com/en-us/articles/how-to-use-intelr-compiler-openmp-compatibility-libraries-on-windows/

Q: May be it's better to use 4 threads for 2 cores? (i.e. Number threads = Number Cores * 2?
A: Probably not unless the machine is hyperthreaded, and hyperthreading is enabled in the BIOS; otherwise you will
      oversubscribe the machine.  In general shouldn't give any OpenMP process more than the number of machine logical threads (number-of-processors * number-of-cores/processor * number-of-threads/core), and in fact you might find it better to limit the total of number of OpenMP threads to something less. Testing shows that the
      performance penalty by oversubscribing the machine can be severe. In general, it is OK to use all the machine's logical threads for one OpenMP process (and this is the default, unless you explicitly change the number by setting OMP_NUM_THREADS or by calling omp_set_num_threads()), but depending on your host usage scenario, you should set the environment for 'throughput' (multiple OpenMP processes running) or 'turnaround' (single, dedicated OpenMP process).

Q: What is the difference between using omp parallel task versus using omp parallel sections calling a task?
A: Calling a task within a section just creates extra overhead and cannot control and synchronize the tasks since
     each parallel section is independent of each other. OpenMP 3.0 tasking is more flexible and efficient compared to
     using parallel sections. With parallel sections, there is no way to coordinate the task in each section, so it is not
     possible to determine whether one section will be executed before another, regardless of which section comes first
     in the program source. On the other hand, the task directive can take an "if" clause to cause the task to be
     executed immediately or be deferred; a thread can be "hard wired" to a task (called "tied"), or can be "untied",
     which allows any available thread in the thread pool to start executing the task. Tasking has much better
     performance and scalability for nested parallel and recursive algorithms, compared to parallel sections. There is
     much more overhead creating and destroying the nested parallel regions (parallel sections tasking), versus
     executing tasks which are all created by a single parallel region containing a task directive. You can control the total number of threads (OMP_NUM_THREADS) with tasking, whereas with nested parallel regions (sections), with each newly created region you get OMP_NUM_THREADS new threads, and that can easily oversubscribe the host.

Q: Do you have a favorite textbook about OpenMP that you recommend?
A: Please look at the "Related Information" section in the product user guide where there is a mention of associated
     Intel Documents. A good recommended book to look at: "Using OpenMP: Portable Shared Memory Parallel
     Programming" by Barbara Chapman, Gabriele Jost, and Ruud van der Pas

How am I notified of updates for my registered products?

Mon, 10 Aug 2009 00:40:04 -0700

Problem :
How am I notified of updates for my registered products?

Resolution :
1) Login to the Intel® Registration Center by entering your Login ID and Password in the Registered Users Login section of the web page. You will see a list of all products you have subscribed;
2) Click on My account/Change notification preference on My products page below.

3) You will be directed to the page below, check the box of Yes, I would like to receive Intel® Software Product update notifications.

4) Click Save Notification Prefences.

You will then receive the registered product update notifications.

Use VTuneAPI in Intel® Parallel Amplifier for selective code profiling

Wed, 29 Jul 2009 02:18:19 -0700

VTuneAPI is a set of APIs from VTune^TMPerformance Analyzer - the user can ignore (don't collect) the profiling data when the application is running on non-interest of code, e.g. 3rd-party libraries. VTuneAPI has Pause API and Resume API to set profiling control in user's C/C++ program, also there are other APIs to configure sampling / call graph data collection, and generate final result, etc. See http://cache-www.intel.com/cd/00/00/21/93/219345_sampling_vtune.pdf, page 8 in detail.

Dump VTuneAPI all export functions:

1 000012F4 VTBindSamplingResults

2 0000126C VTNameThread

3 00001234 VTPause

4 0000135C VTunePauseCounterMonitor

5 00001324 VTunePauseSampling

6 00001250 VTResume

7 00001378 VTuneResumeCounter Monitor

8 00001340 VTuneResumeSampling

9 00001294 VTStartSampling

10 000012C4 VTStopSampling

Fortunately Intel® Parallel Amplifier includes this feature in the product. Simply the user can use VTPause/VTResume to control data profiling. There is no necessary to use VTStartSampling/VTStopSampling since the user can do it on the Parallel Amplifier's user interface.

a) Include file - VtuneApi.h under Parallel Studio\Amplifier\include

b) Lib file - VtuneApi.dllunder Parallel Studion\Amplifer\bin32\runtime, or Parallel Studion\Amplifer\bin64\runtime

Here are steps to use VTuneAPI to control data collection.

Set new path for Vtuneapi.h in Include Directories, Microsoft* Visual Studio* ->Tools->Options->VC++ Directories->Include files
Copy VtuneApi.dll to Project's Release directory which includes generated application.
In Microsoft* Visual Studio, right-click on the project -> Intel Parallel Amplifier->Project Properties->check on "Start data collection paused" & check off "Resume collection after sec."
Insert VTuneAPI code in user's source such as below example, then rebuild the project

#include "Vtuneapi.h"

......

typedef void (*VTFUNC)(void);

HMODULE hMod;

VTFUNC vtResume, vtPause;

hMod = LoadLibrary("VtuneApi.dll");

vtResume = (VTFUNC) GetProcAddress(hMod, "VTResume");

vtPause = (VTFUNC) GetProcAddress(hMod, "VTPause");

......

(vtResume());

// code section 1 - collecting data

(vtPause());

// code section 2 - not collecting data

(vtResume());

// code section 3 - collecting data

......

Finally run the Parallel amplifier to get expected result

Q&A from Webinar - Solve Parallelism with Intel® Parallel Studio

Wed, 01 Jul 2009 15:25:29 -0700

Q&A from Webinar - Solve Parallelism with Intel® Parallel Studio.

Q1. Can I use Fortran language with Intel(R) Parallel Studio?

A: No. The Intel Parallel Studio is targeting Microsoft* Visual C++ developers.
If your program uses Fortran language, you should use the following tools:

Intel Visual Fortran Compiler Professional Edition for Windows

Intel VTune™ Analyzer with Intel Thread Profiler for Windows

Intel Thread Checker for Windows*

Please visit http://software.intel.com/en-us/articles/intel-software-evaluation-center/ for more information.

Q2. Can you tell Intel Parallel Inspector to ignore the system DLLs? They probably don't contain threading errors, wouldn't you expect?

A: Yes, but most are already ignored by default.

Suppression can be used to suppress any errors reported in any DLL, source file, or function. See the Defining Private Suppression Rules topic in the Parallel Inspector help for more information.

Q3. What versions of Microsoft* Visual Studio* will the Intel Parallel Studio run in?

A: The Intel Parallel Studio can be used with Visual Studio 2005* standard edition or above, or Visual Studio 2008* standard edition or above.

Please see the Release Notes at http://software.intel.com/sites/products/documentation/studio/studio/en-us/2009/start/release_notes_studio.pdf for complete information.

Q4. Can you comment on the compatibility of OpenMP* with Windows Threads?

A: OpenMP and the native thread can be used together.
Be aware of the possibility of thread over subscription. You can control the number of threads for OpenMP to use from an environment variable or programmatically in the code.

There's one nice article talking about this at http://software.intel.com/en-us/articles/intel-threading-building-blocks-openmp-or-native-threads/

Q5. I have tried running Intel Parallel Amplifier on an interactive Embedded system and it quickly fails to start. What I would like to do is profile execution for a period of time and then get an analysis. Any tips for how to work with this type of application?

A: If the program can run within Microsoft Visual Studio, the Intel Parallel Amplifier should work. It might be a bug.
To report any issue about Intel Parallel Studio, please visit our Studio Forum http://software.intel.com/en-us/forums/intel-parallel-studio/.

Q6. Can Intel Parallel Studio help us detect cache thrashing, which is one of the bottlenecks of multi-core programming?

A: No.
Please use the Intel VTuneAnalyzer with Intel Thread Profiler for Windows*.

Q7. What about cross-compiling and MacOS X* & Linux* support?

A: No, that is not supported by the Intel Parallel Studio.

The cross compiling for a different architecture of the same OS is supported, but it's not supported for a different OS. i.e. you can cross compiling the application for Intel 64 Windows on an IA-32 Windows system. you can not cross compiling the application for Linux or MacOS X on a Windows system.

For Linux, please use the tools below:

Intel C++ Compiler Professional Edition for Linux

Intel VTune Analyzer for Linux

Intel Thread Checker for Linux

For MacOS X, we currently have only the following:

Intel C++ Compiler Professional Edition for MacOS X

Please visit http://software.intel.com/en-us/articles/intel-software-evaluation-center/ for more information.

Q8. Can I compile the MFC-based applications with Intel® Parallel Composer?

A: Yes if the code does not use "Attribute" or "CLR".
The Intel Parallel Studio only supports native or unmanaged C/C++ program.

Q9. Does the Intel Parallel Studio encompass all the features of Intel VTune Analyzer? Can Intel Parallel Studio replace Intel VTune Analyzer?

A: No.
Please see this article http://software.intel.com/sites/products/collateral/studio/Amplifier_VTune_Comparison.pdf for detail.

Q10. Surely your product targets the Intel architecture how about other brand CPUs. When we use your product it will also work in other CPUs without problem and still get the same performance?

A: Yes, the Intel Parallel Studio can be used on any other brand CPUs with Windows OS. The Intel Parallel Composer has options for targeting other CPUs and the performance should be better.

Please see this KB for detail - http://software.intel.com/en-us/articles/performance-tools-for-software-developers-intel-compiler-options-for-sse-generation-and-processor-specific-optimizations/

Q11. How long does it take to finish the Intel Parallel Amplifier and Intel Parallel Inpector analysis on a large application (32 MB)? I have been running one for hours, and it is still going.

A: The Intel Parallel Amplifier should not take too long like Parallel Inspector. Be sure to report problems to our Forum http://software.intel.com/en-us/forums/intel-parallel-studio/.

Q12. What happens if you have an application with languages other than C++? Can you still analyze it with Parallel Studio? What if a deadlock happens in your Visual Basic* code, for example?

A: No, the Intel Parallel Studio only supports C++ native code.
If the deadlock happens in a DLL of Visual Basic, the Parallel Inspector can not find it.

Q13. Some operating systems like AIX* allow application developers to have threads to be rescheduled on the same processor -- does this tool presently (or a later version may) capture processor cache hits/misses?

A: Not right now. A future version of the Parallel Studio will support cache miss detection.

Please use the Intel VTune Analyzer with Intel Thread Profiler for Windows.

Static Analysis and Intel® C++ Compilers Webinar Q&A

Wed, 01 Jul 2009 15:19:42 -0700

Q&A from Webcast: The webinar "Static Analysis and Intel® C++ Compilers" was presented by Dmitry Petunin, June 2^nd 2009, as part of our technical webinar series about Multithreading tools and techniques. The following questions were selected from the list of questions and answers generated by this web cast, and may be useful to other developers as reference.

Q: Can the Static Analysis capability verify the correctness of say a Producer-Consumer problem with multiple threads?
A: No, we do not have any specific checks for such a problem.

Q: Does parallel composer run on Linux?
A: No, the Intel® Parallel Composer is presently for Windows* only. But, you can
     use the latest "Intel® C++ Compiler Professional Edition" for Linux.

Q: What is meant by "Compiler's interprocedural analysis capability, and can correctness of
     multiprocess applications using synchronization primitives in shared memory be checked?
A: The inter-procedural analysis capability enables the compiler to analyze the code to determine if there is benefit in
     optimizations such as: inline function expansion, inter-procedural constant propagation, passing arguments in
     registers, dead code elimination, multi-file optimizations etc. Also, no, the correctness of multiprocess applications
     using synchronization primitives in shared memory cannot be checked.

Q: If "parallel lint" does not report on data dependencies in my program, does it mean that I can be
     sure that my program is free of data dependencies?
A: No. In addition, the theorem of Heodel says that this task cannot be resolved at all.

Q: Is parallel lint a part of Compiler 11.1?
A: Yes. In Compiler 11.1, there is a complete source checker tool in addition too.

Q: Hello, I am sort of confused! When we talk of compiler, is it the one integrated in the Parallel Studio
     or the stand alone compiler version 11 or both?
A: Parallel lint is available in both Intel® Parallel Composer (which is available as an individual product, and is also
     integrated as a component of Intel® Parallel Studio) and the standalone Intel® C++ Compiler Professional Edition
     product.

Q: Are there plans to support Intel®Threading Building Blocks with Parallel lint?
A: Presently, there is no announced plans at this time, but will update as soon as any plan for this is available.

Q: Is Parallel Lint available for Fortran? Any plan to support Fortran if not supported right now?
A: Yes, it is available

Useful links:

http://software.intel.com/en-us/articles/parallel-lint/

Easy Ways to Solve Parallel Performance Challenges Webinar Questions and Answers

Wed, 01 Jul 2009 11:34:27 -0700

During "Easy Ways to Solve Parallel Performance Challenges" webinar presented by Gary Carleton, April 21, we received the following questions and we thought we would share them with you:

Q. What is the website for the Webinars?

A. Visit the webinars website https://event.on24.com/event/36/88/3/rt/1/index.html

Q. Does Intel® Parallel Studio provide any support for Microsoft Visual* Studio* 2003?

A. Microsoft* Visual Studio* 2005 and 2008 are supported. Please check: http://software.intel.com/sites/products/documentation/studio/studio/en-us/2009/start/release_notes_studio.pdf

Q. What operating systems are supported?

A. Please check system requirements here: http://software.intel.com/sites/products/documentation/studio/studio/en-us/2009/start/release_notes_studio.pdf

Q. Does code need to be compiled with the Intel® Compiler or can Microsoft Compilers be used?

A. You can use either the Intel® or the Microsoft compilers.

Q. Does code need to be compiled in any special way to enable source-code views?

A. To provide accurate performance data, the Intel(R) Parallel Amplifier requires debug information for binary files it analyzes. Generating debug information should not affect compiler optimizations but the linker may turn off some default optimizations, therefore verify that the optimization switches are enabled. If debug information does not exist, the Amplifier may not unwind the call stack correctly. Note, in some cases the finalization of results for modules without debug information can take much longer than the finalization with debug information present.

Q. Do I need to use Intel® VTune^TM Performance analyzer or Intel® Thread Checker etc. any more since I found that Intel® Parallel Studio can do what VTune analyzer always do?

A. VTune analyzer provides additional functionality. For example, VTune Event Based Sampling (the ability to track processor level events) is one such area. The Intel(R) Parallel Amplifier, an Intel(R) Parallel Studio tool, provides information on the performance of your code. Use the Parallel Amplifier to analyze the following types of performance issues in your threaded applications:

- Identify the most time-consuming (hot) functions

- Locate sections of code that do not effectively utilize available processor time

- Determine the best sections of code to optimize for sequential performance and for threaded performance

- Locate synchronization objects that affect the program performance

- Find whether, where, and why your program spends time on input/output operations

- Identify and compare the performance impact of different synchronization methods, different numbers of threads, or different algorithms

Q. Are there many overlapped functions between Intel® Parallel Studio and other threading tools?

A. There are some. Moreover, Parallel Studio is built on the latest technology (PIN) for faster analysis. Also, Parallel Inspector includes memory checking in addition to "Thread Checking". Parallel Amplifier has Statistical Call Graph for profiling your applications with low overhead to detect where time is spent in your application. See Intel® Parallel Amplifier vs. Intel® VTune^TM Analyzer Comparison.

Q. Does the analysis done by Intel® Parallel Amplifier go to the level of identifying contention on global heap (so not just locking in the user's code, but also deep inside libraries)?

A. The data collector interrupts a process, collects samples of all active instruction addresses, and reproduces a call sequence (stack) upon each sample. Intel® Parallel Amplifier can identify contention on the system libraries. If you do not have the source code for those libraries, you will see just the library name and you can walk the stack back up to the New/Malloc/etc in your code.

Q. Can the Intel® Parallel Amplifier attach to a running process?

A. Currently, this is not a supported functionality. However, a running process can be analyzed via VTune analyzer.

Q. Does Intel® Parallel Studio support Linux?

A. Currently Intel® Parallel Studio is designed for Microsoft Windows*/Microsoft Visual* Studio* only. We do have an existing line of tools, including Intel® VTune analyzer, Intel® Thread Checker, and the Intel® Compiler, which run on Linux*.

Q. Is it possible to see the specific function in source code in concurrency view?

A. The source/Assembly window displays accurate information provided that:

- Your code is compiled with the debug information and debug information is written correctly in the debug information file (or symbol file).

- The source code file exists.

If there is no correct debug information, or symbol file is unavailable, the assembly data may be incorrect. In this case, the Amplifier uses heuristics to define function boundaries in the binary module.

Q. Does Amplifier support Open MP3.0 task, Win32 API and Intel® Threading Building Block?

A. Yes these are supported. Note for Intel® Threading Building Block, the Intel® Parallel Studio analysis obtained will only be thread based (not task based).

Q. Does Intel® Parallel Studio work with the Intel® Fortran compiler?

A. Intel® Parallel Studio is designed and targeted and tested for C++ software. The analysis is based on the binary not the source, how well it works with Fortran may vary. Please be aware that in addition to Intel Parallel Studio product, Intel offers a HPC line of products that offer full support for Fortran. This includes the Intel® Fortran compiler of course, but also Intel® VTune Performance Analyzer and Intel® Thread Checker. The Intel Math Kernel Library also includes full Fortran interfaces to BLAS, LAPACK, FFT and other common numerical algorithms. Most Fortran developers use the HPC line of Intel products.

The Key to Scaling Applications for Multicore Webinar Questions and Answers

Wed, 01 Jul 2009 11:30:10 -0700

During "The Key to Scaling Applications for Multicore" webinar, May, 5, by Paul Petersen and Mark Davis we received the following questions and we thought we would share them with you:

Q. Does Intel® Parallel Studio provide any support for Microsoft Visual* Studio* 2003?

A. Microsoft* Visual Studio* 2005 and 2008 are supported. Please check system requirements at: http://software.intel.com/sites/products/documentation/studio/studio/en-us/2009/start/release_notes_studio.pdf

Q. What operating systems are supported?

A. Please check requirements at: http://software.intel.com/sites/products/documentation/studio/studio/en-us/2009/start/release_notes_studio.pdf

Q. Where does the profiling information come from? Is it an Intel tool?

A. Yes, you can use Intel(R) Parallel Amplifier to find hotspots in your program/application. The Intel(R) Parallel Amplifier, an Intel(R) Parallel Studio tool, provides information on the performance of your code. Use the Parallel Amplifier to analyze the following types of performance issues in your threaded applications:

- Identify the most time-consuming (hot) functions

- Locate sections of code that do not effectively utilize available processor time

- Determine the best sections of code to optimize for sequential performance and for threaded performance

- Locate synchronization objects that affect the program performance

- Find whether, where, and why your program spends time on input/output operations

- Identify and compare the performance impact of different synchronization methods, different numbers of threads, or different algorithms

Q. How do I get the material to the previous seminars and technical sessions I missed?

A. Go to www.intel.com/go/parallel under "Related Links" on the right and click "Free, on-demand parallelism webinars".

Q. Is there any Intel software tool for parallelism under Linux platform?

A. Yes. We do have an existing line of tools, including Intel® VTune analyzer, Intel® Thread Checker, and the Intel® Compilers, which run on Linux.

Q. What is the difference between Intel® VTune^TM analyzer/Intel® Thread Checker and Intel® Parallel Studio? Or can they be used in a good combination somehow?

A. Yes. Moreover, Parallel Studio is built on the latest technology (PIN) for faster analysis. Also, Parallel Inspector includes memory checking in addition to "Thread Checking". Parallel Amplifier has Statistical Call Graph for profiling your applications with low overhead to detect where time is spent in your application. See Intel® Parallel Amplifier vs. Intel® VTune^TM Analyzer Comparison.

Q. Have you had any experience using Intel Parallel Studio with large programs (500,000 lines)? I have used VTune analyzer in the past and it was difficult to use because the size of the program I was working with was large.

A. The Intel® Parallel Studio offers a more streamlined and simplified usage model for hotspot analysis similar to VTune analyzer. The sampling methodology used is the same. This means that with big applications you have to watch for sampling overhead and the influence this has on your application sampling. You may want to consider focusing your sampling on application subsets and individual application components rather than the whole application and use a stepped approach or an approach with a smaller input data stream. All this depends a bit on the exact architecture of your application. See Intel® Parallel Amplifier vs. Intel® VTune^TM Analyzer Comparison.

Q. Is Intel® Threading Building Blocks (TBB) open source, and where may I get the source for OpenMP*?

A. Intel® Threading Building Blocks (TBB) source files can be downloaded here: http://www.threadingbuildingblocks.org/download.php. Intel's implementation of OpenMP* is not an open source project.

Q. If Intel® Parallel Advisor Lite finds the hotspot in the code, do we still have a need to use the Intel® Parallel Amplifier for finding hotspot?

A. Intel® Parallel Advisor Lite works on the serial portions of your application. It leverages Intel® Parallel Amplifier's hot spot analysis to help identify likely areas in your serial application to experiment with parallelism - in particular, we recommend using Parallel Amplifier's "Top Down" view where one would work up the call tree to find a likely site.

If all you need are hot spots, then Parallel Advisor Lite has already found them for you by leveraging Parallel Amplifier. However, once you have added parallelism, Parallel Amplifier can help you tune the parallelism using the Concurrency analysis to see where the threading is being used effectively, and the Locks and Waits analysis to determine if the program is wasting resources in synchronization sequences.

Q&A from Webcast “The Simplifying Parallelism Implementation with Intel® Threading Building Blocks”

Wed, 01 Jul 2009 11:00:24 -0700

Q&A from Webcast "The Simplifying Parallelism Implementation with Intel® Threading Building Blocks" presented by Michael D'Mello on 5/26/2009

Q: Is the thread-to-core ratio hardwired 1:1 in Intel® Threading Building Blocks (Intel® TBB) or is it configurable?
A: The number of worker threads in Intel TBB thread pool equals the number of logical cores by default. The default number can be changed: you can specify the desired number of threads as a parameter to the constructor of Intel TBB initialization object task_scheduler_init. Please visit http://www.threadingbuildingblocks.org/documentation.php and read the related chapter in the tutorial for the complete example.

Q: What if my code contains data-dependency? Can Intel® Threading Building Blocks (Intel® TBB) detect it?
A: No, Intel TBB doesn't analyze code to detect data dependencies. Intel TBB is a library that provides generic algorithms and data structures that simplify threading and it is recommended that all data dependencies are known before applying threading. Data races arguably constitute the most commonly encountered errors in parallel code, and this type of error occurs when data dependencies are not properly handled by the programmer. Intel® Parallel Inspector is a developer oriented tool for finding data races in threaded applications.

Q: What is the advantage of re-implementing ChangeArray(A) as a functor?
A: Most of Intel® Threading Building Blocks (Intel® TBB) algorithms take a functor object as a parameter. To take advantage of easy threading and "future proof" parallelism, which Intel TBB algorithms deliver, a developer should implement the logic of a parallel task as a functor. A less highly touted feature of Intel TBB is that the library provides excellent mechanisms to handle task-based parallelism while still emphasizing the data parallelism model. For simple loops, one may well question the advantages of using Intel TBB as opposed to other threading models. However, for more complicated loops, Intel TBB seems to provide much more flexibility than other threading models. One example of this is to consider iterating over a collection of items which is not indexed by an integer.

Q: What do you mean by a "warmer" task describing the effectiveness of task scheduling performed by Intel® Threading Building Blocks (Intel® TBB)?
A: A warmer task is a task which is most likely to still reside in the cache. Executing "warm" tasks while they are still in the cache is more efficient than executing "cold" tasks whose data will have to be fetched into the cache first. Intel TBB task scheduler's approach to scheduling tasks favors "warm" tasks over "cold" tasks which makes scheduling highly efficient.

Q: Just thinking about use of cache_aligned_allocator vs. scalable_allocator - does Intel® Threading Building Blocks (Intel® TBB) provide an API for obtaining any metrics about the processor caches/cache-lines etc?
A: No. That type of information can be examined using the Intel® VTune Performance Analyzer, which can monitor processor-specific events including cache misses and other cache-related activity.

Q: Your examples are for the for-loop, is it also true for while-loop? How do I parallelize non-indexed loops with Intel® Threading Building Blocks (Intel® TBB)?
A: Intel TBB implements several template classes and functions to simplify threading of non-indexed loops. For example, parallel_do (for while-loops) and pipeline (data flow pipelines). Please see the Intel TBB documentation to learn more: http://www.threadingbuildingblocks.org/documentation.php.

Q: Does Intel® Parallel Studio require a C++ compiler or is one included?
A: Intel® C++ Compiler is included in Intel Parallel Studio; it is one of the components of Intel® Parallel Composer.

Q: Which versions of Microsoft Visual Studio* are supported by Intel® Parallel Studio?
A: Microsoft Visual Studio* 2005 and 2008.

Q: What do I gain when I compile the source code with Intel® C++ Compiler compared to Microsoft's compiler? If there is a gain, several projects are impossible to convert to Intel® Compiler, such as COM-projects using attributes. And projects using BOOST are cumbersome since I need to compile BOOST*-versions for the Intel Compiler. It would be great if Intel provided already compiled BOOST library dlls and libs?
A: That is correct. COM attributes are not supported right now. We don't provide special builds of 3^rd party libraries but it should be easy to compile them with Intel C++ Compiler. Also, binaries built with Intel C++ Compiler are fully compatible with binaries built with Microsoft's compiler so both types of binaries can be safely mixed within one application. Therefore, you should be able to link object files created with the Intel compiler and your source code with the BOOST libraries created with the Microsoft compiler. If you have any issues compiling BOOST with Intel C++ Compiler, please let us know via a forum: http://software.intel.com/en-us/forums.

Q: I know Intel® Threading Building Blocks (Intel® TBB) works with AMD processors, will Intel® Parallel Studio?
A: Intel® Parallel Studio runs on platforms with an IA-32 or Intel® 64 architecture processor supporting the Intel® Streaming SIMD Extensions 2 (Intel® SSE2) instructions (Intel® Pentium 4 processor or later, or compatible non-Intel processor).

Q: Does Intel® Parallel Studio work under Microsoft Windows* 7 and Visual Studio* 10?
A: The first releases of Intel Parallel Studio have not been validated against Microsoft Windows* 7 and Visual Studio* 10, since neither is a released product. We will, of course, move forward closely aligned with the Microsoft roadmap and validate those platforms in future releases.

Q: Is Intel® Threading Building Blocks (Intel® TBB) aware of dynamic logical partitioning activity like 2 cores out of say 8 being pulled out during application-runtime?
A: Intel TBB does not have any dynamic mechanisms to detect such situations. The number of threads is selected during initialization of the Intel TBB task scheduler. The user either chooses how many threads will be created or allows Intel TBB to take the default (which is 1 thread per logical core). For the situation you mention, provided the logical partitioning mechanism does not interrupt normal code execution (due to some system level dependency), Intel TBB code will continue to execute with a thread pool of size determined at time of the scheduler initialization.