Intel® VTune™ Performance Analyzer 9.1 Update 7 for Windows*

Release Notes

Contents

Overview
What's New
System Requirements
Installation
Usage
Known Limitations
Technical Support and Feedback
Documentation
Additional Information
Disclaimer and Legal Information

Overview

The VTune™ Performance Analyzer provides an integrated performance analysis and tuning environment that enables you to analyze your code's performance on Intel® architecture processors of the IA-32, Intel® 64 and Itanium® processor families.

To receive technical support and product updates, you need to register your purchase with Intel. The registration process is described in the Technical Support and Feedback section of these Release Notes.

Additional information on Intel's software performance products is available at http://www.intel.com/software/products/.

What's New

These are some of the key enhancements and new features introduced in this version:

• This update of VTune analyzer supports the Windows 7* OS with both event based sampling and counter monitor. For time based sampling or call graph capabilities on Windows 7*, please use Intel Parallel Amplifier’s “hotspot analysis” (statistical call tree). Parallel Amplifier can be downloaded from the Intel website and will recognize a current, valid VTune analyzer license. We do plan to move the “hotspot” analysis into a future version of VTune analyzer, until then, please use Parallel Amplifier. If you need to use the existing call graph capability in VTune analyzer, please use it on Windows XP* or Vista*.
• Support for profiling runtime generated and interpreted code (JIT Profiling API Support).
• Support for VTune™ Performance Analyzer Reader/Writer API (TBRW) This API enables you to read and write persisted data in an on-disk format that is compatible with the VTune™ Performance Analyzer. See TBRW.pdf for details.
• Microsoft* Symbol Server support. You can now specify paths to Microsoft symbol server using the standard format. Use this feature if you need debug symbols for system modules.
• GNU* debuglink support. The VTune analyzer supports debug information for Linux OS modules saved both with the module, or as a separate file. You can store the debug information file near the corresponding module, or specify the path to a directory with the debug information files in the search directory list for symbol files.
• Support for the following processors (for local analysis and on controlling and controlled Linux* systems):
  • Intel® Core™ i7 processor
  • 45nm Intel® Core™2 processor family
  • Intel® Core™2 Duo processor
  • Intel® Core™2 Quad processor
  • Dual-Core Intel® Xeon® processor 5100 Series
  • Quad-Core Intel® Xeon® processor 5300 Series
  • Dual-Core Intel® Xeon® processor 7100 Series
  • Intel® Pentium® D processor 900 Sequence
  • Dual-Core Intel® Xeon® processor 5000 Sequence
  • Dual-Core Intel® Xeon® processor 7000 Sequence
  • Dual-Core Intel® Itanium® 2 processor 9000 Sequence
  • Dual-Core Intel® Xeon Processor LV
  • Intel® Quad-Core processor support
• 32- and 64-bit system support for Microsoft* Windows* 7.
• 32- and 64-bit system support for Microsoft* Windows Vista.
• 32- and 64-bit system support for Microsoft* Windows Server 2008.
• 32- and 64-bit profiling integrated with Microsoft* Visual Studio* 2005.
• 32- and 64-bit profiling integrated with Microsoft* Visual Studio* 2008.
• Microsoft .NET* 3.0 support.
• Support for latest Linux* operating systems for remote data collection.
• Ability to install on systems with non-Intel processors to remotely profile systems with Intel® processors.
• New events for tuning multi-core processors:  Identify opportunities to improve threading, tune multi-core sharing of the bus, and optimize cache-line usage.
• Double Buffering when sampling a local system. When the sampling buffer is full and starts writing data to disk, the second buffer of the same size starts working. It prevents from losing samples and improves accuracy of sampling data.
• Support for latest JDK*: SUN* JDK* 1.6.0, BEA* JDK* 1.6.0 and IBM* JDK* 1.5.0.
• Call graph profiling of 32-bit applications on 64-bit operating systems.
• Compatibility with the Linux* Remote Data Collector of Intel® VTune™ Performance Analyzer for Linux* version 9.0 (and later).

System Requirements

The VTune™ Performance Analyzer is intended to execute on systems that meet the requirements outlined in this section. Supported Development Environments are also detailed in an additional subsection below.

NOTE:
The VTune analyzer supports two usage models, local and remote. The local model requires a single system, which is both the system under analysis and the system performing the analysis. In the remote model, a data collector is installed on one system (the remote system to analyze). The VTune analyzer is installed on the controlling system. After collecting data on the remote system, the output of the data collection is sent to the controlling system, where it can be viewed.

The following sections list the requirements list the requirements for the systems of both usage models.

Hardware Requirements

The hardware requirements below are for the single system for local analysis and also for the controlling system when using an optional second system for remote analysis. In both cases, this system is the system upon which the VTune analyzer is installed.

Processors Supported:

• Servers:
  • 45nm Intel® Core™2 processor family
  • Quad-Core Intel® Xeon® Processor 7xxx and 5xxx Series
  • Dual-Core Intel® Xeon® Processor 5100 Series
  • Dual-Core Intel® Xeon® Processor 5000 Sequence
  • Dual-Core Intel® Xeon® Processor 7100 Series
  • Dual-Core Intel® Xeon® Processor 7000 Sequence
  • Dual-Core Intel® Xeon Processor LV
  • Intel® Xeon® processor MP
  • Intel® Xeon® processor
  • Dual-Core Intel® Itanium® 2 processor 9000 sequence
  • Low Voltage Intel® Itanium® 2 Processor
  • Intel® Itanium® 2 processor
     
  Desktop:
  • Intel® Core™ i7 processor
  • 45nm Intel® Core™2 processor family
  • Intel® Core™2 Quad processor
  • Intel® Core™2 Extreme  processor
  • Intel® Core™2 Duo processor
  • Intel® Core™ Duo processor
  • Intel® Core™ Solo processor
  • Intel® Pentium® D processor 900 sequence
  • Intel® Pentium® D processor
  • Intel® Pentium® 4 processor Extreme Edition
  • Intel® Pentium® processor Extreme Edition
  • Intel® Pentium® 4 processor

  Mobile:

  • Mobile Intel® Pentium® 4 Processor - M
  • Intel® Pentium® M processor
  • Intel® Celeron® M processor
  • Intel® Celeron® D processor
  • Intel® Celeron® processor
  • Mobile Intel® Celeron processor

Note: Systems with the following processors can be a host for collecting data remotely on a system with a supported processor or viewing data previously collected on a support processor:

• IA-32 architecture-based processor - Intel® Pentium® 4 performance level or better
• Intel® 64 architecture-based processor or equivalent
• Intel® Itanium® 2 processor
• AMD* Athlon* or Opteron* processor

System Memory Requirements:

Disk Space Requirements:

• At least 105 Megabytes of available space on a local drive
• 20 Megabytes of disk space is required for system files on the drive containing the system directory (for example, C:\)

NOTE:
This additional hard disk space is needed for updating and installing the DLLs and OCXs that the VTune analyzer requires to be in the system directory. If you install the VTune analyzer on a hard disk other than the drive containing the system directory, make sure that you have at least 20 Megabytes free on the drive containing the system directory.

Software Requirements

The software requirements below are for the single system for local analysis and also for the controlling system when using an optional second system for remote analysis. In both cases, this system is the system on which the VTune analyzer is installed.

Free (non-checked) versions of these operating systems:

NOTE:
In all cases below, use the Microsoft* Windows* recommended virtual memory paging file size to prevent unexpected failures of the VTune analyzer.

32-bit operating systems supporting IA-32 processors:

• Microsoft* Windows* 7
• Microsoft* Windows XP Professional, up to Service Pack 3
• Microsoft* Windows Server 2003 Enterprise Edition Service Pack 1
• Microsoft* Windows Server 2003 R2 Enterprise Edition
• Microsoft* Windows Server 2008
• Microsoft* Windows Vista* SP1

64-bit operating systems supporting Intel® processors with Intel® EM64T:

• Microsoft* Windows 7 Professional
• Microsoft* Windows XP Professional x64 Edition Service Pack 1
• Microsoft* Windows Server 2003 Enterprise x64 Edition Service Pack 1
• Microsoft* Windows Server 2003 R2 Enterprise x64 Edition
• Microsoft* Windows Server 2008
• Microsoft* Windows Vista* SP1

64-bit operating systems supporting Intel® Itanium® architecture processors:

• Microsoft* Windows Server 2003 Enterprise Edition Service Pack 1
• Microsoft* Windows Server 2008

Remote Agent System Requirements for the Remote Usage Model

System Memory and Disk Space Requirements on Remote Machines:

• At least 128 Megabytes of RAM
• At least 20 Megabytes of available space on a local drive

Hardware Requirements for the Remote Agent System

Operating System Requirements for the Remote Agent System

This section explains the operating system requirements for the Linux* Remote Data Collector.

NOTE:
If you are not using a default kernel on the supported Red Hat* and SuSE* distributions listed below, use the VTune™ Performance Analyzer Driver Kit to compile drivers for your kernel. The VTune analyzer Driver Kit software is included with this VTune analyzer product, and can also be obtained via Intel® Premier Support. See Technical Support and Feedback section below for more information on the Intel® Premier Support.

Linux* Distributions Supported

The Remote Collector for Linux supports the following Linux distributions.  The kernel versions are supported for Linux systems with supported processors for both uniprocessor systems (UP) and multiprocessor systems (SMP), unless otherwise noted:

Call graph support on different platforms

Compilers and Development Environments Supported

The VTune analyzer supports applications generated with the following compilers and development environments (refer to the VTune analyzer online help for detailed instructions):

NOTE:
The Source Level Tuning Assistant is disabled as a default. To enable the Tuning Assistant to provide source-based tuning advice: select Configure > Options from the main menu, then select Intel® Tuning Assistant > Source Information from the Options tree. Uncheck the option Disable source-based tuning advice.

Installation

General Installation

• If you wish to use the Linux* Remote Data collector (vtserver) to profile an application in a firewalled environment, you need to do the following:
  1. Set: VTUNE_RDCPORT_IN environment variable before running the VTune analyzer. For example:
     set VTUNE_RDCPORT_IN=55555. This setting is communicated to vtserver so that it will initiate callback connections only to this port and the next nine ports above it.
  2. The network administrator must reserve a range of 10 ports for lab outgoing connections. In the above example: 55555-55564
   
• When installing the VTune analyzer with a counted license, if the VTune analyzer is already running as many systems as is permitted by the counted license, the install will display an error message that the license is invalid. To work around this issue, close the VTune analyzer on one of the systems to free up a license and try installing again. [SCR #17508]
• If you are running the evaluation version of VTune analyzer on a multi-user system and it unexpectedly reports that the evaluation period for the machine has expired, it is probably because another user has already used the allocated evaluation period. Contact Customer Support at https://premier.intel.com/ for assistance in running the evaluation version under these circumstances.
• To preserve global setting changes from previously installed versions of the VTune analyzer, copy the file vtenv.stg (located in the ...shared\bin\<username> directory in some older versions of the VTune analyzer) to %APPDATA%\VTune.
• The VTune analyzer cannot be installed to a network drive.
• If you install the VTune™ analyzer on a Microsoft* Windows* Server 2003 system using the Terminal Server Client to connect to the system and do not reboot the system upon the installation program's request, make sure you log off and log on again to the system. Otherwise, you may experience problems with the VTune analyzer license file.
• The VTune analyzer cannot be installed into the %WINDIR%\System32 or %WINDIR%\SysWOW64 system folders on systems using Itanium® processors. [SCR #11705]
• The VTune analyzer may not operate correctly if installed by a non-administrator user using the "Run as Administrator" feature or by adding user to Administrators group and then installing the analyzer, if the user does not log out and log back in before attempting to run the VTune analyzer. [SCR#31422]

Handling Firewall Issues

The Windows* Firewall (initially introduced in Windows* XP Service Pack 2) may have the following implications on how the VTune analyzer accesses the network:

• It may block the VTune analyzer from collecting data remotely when the VTune analyzer is installed on a system running Windows with the Windows Firewall enabled;
• It may block the VTune analyzer from finding the license server (for floating licenses) if the license server is located on a system running Windows with Windows Firewall enabled.

If the VTune analyzer executables are not added to the firewall exceptions list, you may be prompted with a security dialog asking whether to block certain programs. When this happens, select Unblock this program to allow the remote data collection to proceed. Following are the programs that may be blocked:

• When connecting to the VTune analyzer’s Remote Agent installed on Linux: VTune™ Performance Environment, ATLBistroController Module, and CGExeCtrl Module;
• When collecting data remotely from within the Microsoft* Visual Studio* environment there may be an additional dialog to block the Microsoft* Visual Studio*.

Following are situations in which exceptions were not added to the firewall, but no security dialogs appear:

• Remote collection will fail without a security dialog prompt if exceptions were not added to the firewall on the system running the Remote Agent.
• If a license server is being used, the VTune analyzer will fail during startup with an error message indicating that it could not connect to the license server if that server is installed on a Windows system with the firewall enabled.

To resolve operational failures or stop security prompts caused by programs missing from the firewall exception list, you can add exceptions manually as follows:

From the Control Panel, click Windows Security Center>Windows Firewall, select Exceptions tab and add the programs listed below as exceptions where:

• <VTuneDir> is the directory where the VTune analyzer is installed;
• <VSNetDir> is the directory where Microsoft Visual Studio is installed;
• %CommonProgramFiles% is the standard Windows environment variable usually set to C:\Program Files\Common Files.

When your VTune analyzer license is located on a license server, add the following programs as exceptions on the system running your license server:

• %CommonProgramFiles%\Intel\FLEXlm\INTEL.exe
• %CommonProgramFiles%\Intel\FLEXlm\lmgrd.intel.exe

When collecting remote data, add the following programs as exceptions on the Windows system running the VTune analyzer:

• <VTuneDir>\Shared\Bin\VTuneEnv.exe
• <VTuneDir>\Shared\Bin\FileCopier.exe

When collecting remote data from a Linux system, add the following programs as exceptions on the Windows system running the VTune analyzer:

• <VTuneDir>\Shared\Bin\VTuneEnv.exe
• <VTuneDir>\Analyzer\Bin\ATLBistroController_LINUX.exe
• <VTuneDir>\Analyzer\Bin\CGExeCtrl_LINUX.exe

When collecting remote data using the VTune analyzer integrated within Microsoft* Visual Studio*, also add the following programs as exceptions on the Windows system running Microsoft Visual Studio in addition to the exceptions mentioned above:

• <VSNetDir>\Common7\IDE\devenv.exe

Make sure these programs have a check mark next to them after being added to the exceptions list.

Uninstalling the VTune Analyzer

There are 2 methods for uninstalling the VTune analyzer.

Method 1:

1. Go to:  Start menu > Programs > Intel® Software Development Tools > Intel® VTune™ Performance Analyzer > Add or Remove Components.
2. Follow the steps in the Modify/Repair/Remove wizard.

Method 2:

1. Open the Control Panel (Start > Settings > Control Panel).
2. Select the Add or Remove Programs applet.
3. Select Intel® VTune™ Performance Analyzer then select the Remove button.
4. Click Yes when prompted. Only the files installed by the VTune analyzer are deleted. Files that were created after installation, such as the database files (*.ldb and *.mdb), sampling output files, and call graph instrumentation files, are not deleted.

NOTES:
During the installation process, certain VTune analyzer files (DLLs, EXEs, and OCXs) are registered. Registration causes various entries to be added to the Windows* Registry. During uninstall, those files, which will no longer be used, are unregistered. Nevertheless, it is possible that after uninstall, some unnecessary registry entries may remain. While these leftover Registry entries are not harmful to the system, the only way to remove them after uninstall is to do so manually. Be advised however that Microsoft* warns that incorrect use of the Registry Editor can cause serious problems and to use it at your own risk. See the Microsoft* Knowledge Base article 256986 for more information.

Usage

General

• An extensive subset of the VTune analyzer capabilities is available from the command line. Refer to the Online Help for usage instructions.
• When sampling locally or remotely, the project directory should be a local drive. The VTune analyzer may not be able to record samples on a network or a mapped drive. [SCR #17179]
• To use an alternate symbol path for DBG files define the environment variable: _NT_SYMBOL_PATH. For instance, if your files are under D:\support\debug\i386\symbols\dll\*.dbg, you should set: _NT_SYMBOL_PATH to D:\support\debug\i386. You can also specify additional symbol directories using Tools > Options > Directories property page.
• The VTune analyzer online help provides descriptions of processor events and instructions. To access event descriptions, do the following:
  1. Click the Start button and select Programs (All Programs in Windows* XP).
  2. Select Intel® Software Development Tools > Intel® VTune™ Performance Analyzer > Reference.
• To use Sampling Over Time views, you must have the Display sampling results over time box checked in the Sampling Configuration dialog box. This is enabled by default.
• Pause/Resume APIs do not support multithreaded applications.

Minimum user rights requirements to work with VTune analyzer

Setting the rights manually

• To run sampling, your account or any user group it belongs to has to have Profile System Performance user right. To add a user right for an account or user group, do the following:

1. Click Start, click Run, type secpol.msc, and then click OK.
2. Expand Local Policies, and then click User Rights Assignment.
3. In the right pane, choose the user right you would like to add and double-click it.
4. Make sure that the user name or user group you want to have this user right is listed.
5. Click OK.

• To run Counter Monitor on Windows Server 2003 or Windows Vista, your account has to belong to Performance Log Users group. To add an account to a user group, do the following:
  1. Click Start, click Run, type compmgmt.msc, and then click OK.
  2. Expand Local Users and Groups, and then click Groups.
  3. In the right pane, choose the user group you would like to add the account to and double-click it.
  4. Make sure that the user name you want to add is listed.
  5. Click OK.
  
  Setting the rights automatically

  elevateUserRight.exe utility can be used by the system administrator to set appropriate rights for VTune analyzer users. It is located in <VTuneDir>\Analyzer\Bin directory where <VTuneDir> is the directory where the VTune analyzer is installed.

Using the Linux* Remote Data Collector

This version of the VTune analyzer is fully compatible with the Remote Data Collector of the VTune™ Performance Analyzer for Linux version 9.0 (and later). To configure a remote Activity, use the Remote Target Configuration dialog box and specify a remote target system (host, user, password, port). For more details, refer to the Remote Target Configuration Dialog Box topic in the online help.

In the Remote Target Configuration dialog box, you may specify only the IP address for the remote target system. In this case, make sure you set the user name for the remote system in the VTUNE_RDC_DEFUSER environment variable. To identify the user name for the remote Linux system, the VTune analyzer checks the VTUNE_RDC_DEFUSER environment variable, and then, if it is not set up, uses the local (Windows) account name.

Marvell PXA* family of processors Information

First, the Marvell PXA collector and documentation package must be downloaded separately.  Eventually the collectors will be moving to a Marvell hosted web-site, but for now they are available in the Intel® Registration Center download area with the VTune™ analyzer 9.0 for Windows* product under the Remote Agent link for the 9.0 release. (These collectors are only required if you are using the VTune™ analyzer to tune Marvell PXA processors.  Users tuning only non-PXA processors should not download the PXA collectors.)

Second, support for the analysis of PXA processors is now being provided by Marvell.  To receive a support account, send email to: account_req@support.marvell.com .   Once log-in details have been received, log onto the Marvell support website at:  https://support.marvell.com/.

Java Support

• The VTune analyzer supports simultaneous viewing of Win32* and Java* functions in the same call graph. Supported versions of Java* environments are detailed in the above table, Compiler and Development Environments supported.
• Remote profiling of Java* applications on Itanium® 2-based systems on Linux* has been introduced. It is supported via the standard wizard, using its Remote dialog box.
• IBM* JDK* 1.5.0 does not support the JAVA_TOOL_OPTIONS environment variable. You should manually include the -agentlib:javaperf (for sampling) or -agentlib:javaperf=cg (for call graph) option to the Java* command line when configuring an Activity in the wizard. [SCR #30763].

• When drilling down to Java* source code from sampling or call graph data using the IBM* JDK* versions 1.4 or 1.5, the source view will be opened on the last line of the method with all data associated with this line.  The behavior results because of missing or incomplete line information provided to the VTune analyzer by the JVM. [SCR #30826]

• When drilling down to Java* source code from sampling or call graph data using the IBM* or Sun* JDK* version 1.5, the message "Line number information is not available for this module. Only Disassembly view will be available. Do you want to continue?" may be displayed.  This is because for some methods, the mapping from JIT'd (i.e., native) code to managed (i.e., Java) code is not provided by the JVM.  Therefore, the VTune analyzer can only display disassembly instructions. [SCR#31305]

• There is a known issue with an apparent loss of samples when viewing sampling data collected for Java applications. It results from the Java Virtual Machine (JVM) re-jitting a method so that, during the life time of the app, there is actually more than one instance of the method. If you drill down to the source view from the hotspot view while viewing hotspots "Grouped by Function", the total number of samples displayed for the method in the source view may not match the number displayed in the hotspot view. If this occurs, view the hotspots "Grouped by RVA" and then examine the "Function Name" column to see the method name. By drilling down from the "Grouped by RVA" hotspot view, you can examine each instance of the JIT'd method. [SCR#30827]

Microsoft* Visual Studio Support

• The VTune analyzer plugs into the following versions of Microsoft* Visual Studio*:
  • Microsoft* Visual Studio* .NET 2002
  • Microsoft* Visual Studio* .NET 2003
  • Microsoft* Visual Studio* 2005
  • Microsoft* Visual Studio* 2008
    • Visual Studio 2008 integration is available on all supported platforms except 64-bit editions of Vista and Windows Server 2008 on Intel® 64 processors.  VTune analyzer does integrate with Visual Studio 2005 on Vista 64-bit and also works standalone on Intel® 64 processors.  Integration with Visual Studio 2008 on Vista 64-bit is planned for a future update.
• Data collection can be directly launched from the Microsoft* Visual Studio IDE. The VTune analyzer can also be launched as an independent tool from the IDE.

Microsoft* Symbol Server Support

You can now specify paths to Microsoft* symbol server in a standard convention.  For example, "SRV*c:\websymbols*http://msdl.microsoft.com/download/symbols", in Configure > Options > Directories preference page for Symbol Files, or in _NT_SYMBOL_PATH environment variable. Use this feature if you need debug symbols for system modules.

See more information about Microsoft Symbol Server, see http://www.microsoft.com/whdc/devtools/debugging/debugstart.mspx

• This does not affect Call Graph instrumentation.
• Specifying a path for the Microsoft Symbol Server may slow down the following operations, especially with a slow Internet connection:
  • Opening Sampling hot spot views
  • Source View drill down
  • Call Graph symbols resolution
  • Static module viewer

JIT Profiling API Support

• The VTune™ Performance Analyzer’s JIT (Just-In-Time) Profiling API provides functionality to profile runtime generated code. This API allows analysis of runtime generated code with both sampling and call graph profilers which are already available with VTune™ Performance Analyzer.  See jit_profiling_API.pdf for details of the API.
• To enable JIT profiling support, set the environment variable ENABLE_JITPROFILING=1
• In order to perform JIT profiling on a remote Linux OS system, define the BISTRO_COLLECTORS_DO_JIT_PROFILING environment variable in the shell where vtserver executes.  For example, export BISTRO_COLLECTORS_DO_JIT_PROFILING=1

Known Limitations

General

• Only sampling data collection is supported on Microsoft* Windows* 7 OS. Call graph, Counter Monitor and Thread Profiler will not work on this OS.
• On systems running Windows* 2003 Server, Service Pack 1, you may have the following problems when accessing the VTune™ Performance Analyzer help files:
  • If you integrate the VTune™ analyzer with Microsoft* Visual Studio* during installation, links from the VTune analyzer help integrated into Visual Studio to VTune analyzer's chm files do not work.
  • If topics in the chm files use Dynamic HTML effects, the Microsoft* Internet Explorer provides a warning message.

  To correct this problem, you must adjust the Security settings of the Internet Explorer Internet Options as follows:

  • In the Microsoft* Internet Explorer, select Tools >Internet Options
  • Click the Security tab
  • Click the Custom Level button
  • Scroll down to the Miscellaneous section
  • Scroll down to the Web sites in less privileged web content zone can navigate into this zone and click the Prompt choice.
  • Click OK

  Using these settings will not make your other websites vulnerable. [SCR #25845]

• Certain HTML Help features may not work from a remote location after you install Microsoft* Windows* XP security update 896358 or security update 890175. To workaround this problem, see http://support.microsoft.com/kb/892675.
• You cannot view results of an Activity if you move a project manually. Use File > Pack and Go to properly pack and move the files.
• The VTune™ analyzer cannot pack files that are larger than 2 GB.  [SCR #29391]
• In the case where the sampling result does not unpack correctly from a packed project ile, the .TB5 file may be viewed by using the Open File menu item.
• Projects packed with versions of the VTune analyzer prior to version 6.1 cannot be unpacked with the current version. [SCR#7736]
• You cannot create projects in the %WINDIR%\System32 directory on systems using Itanium® 2 processors. [SCR #11705]
• Function splitting can cause inaccurate results in the sampling view, call graph, or from the Tuning Assistant. A function is split when it has multiple non-contiguous relative virtual address (RVA) ranges. A compiler can generate split functions for a variety of reasons, usually when doing optimizations or for exception handling in C++. For example, using the Intel® C/C++ compiler 7.x and 8.x with the options Qprof_use or Qprof_gen (associated with profile guided optimization) often creates split functions. In addition, some exception handling routines in C++ may create split function. You can, however, tell the Intel® C/C++ compiler not to create split functions by using the Qfnsplit- option. A detailed description of this issue follows: [SCR #12424] [SCR #12427]
  • When split functions occur from using the Intel® C/C++ Compiler, the sampling view feature is impacted. Parts of a symbol are considered as separate symbols. So, in a sampling view there might be a few records for one symbol. The data itself is valid as a sum of all parts.
  • When split functions occur from using the Intel® C/C++ Compiler, the call graph feature is significantly impacted. The call graph data may be incorrect.
  • The Tuning Assistant is only impacted when the user asks for advice at the hotspot or source level. In this case, the advice generated by the Tuning Assistant for split functions may either be non-existent or partial. This behavior exists for split functions that were created by either the Intel® C/C++ Compiler or the Microsoft* Visual C/C++* Compiler.

    NOTE:
    When using the Intel® C/C++ compiler Qipo option, symbol information is lost. VTune analyzer features that require symbol information may not work.

• An extremely long delay can occur (creating the impression of a software hang) when opening views containing a large number of entries. Extremely slow response has been reported when a view contains tens of thousands of entries. In one case, a drill down view containing 87,000 entries took over 30 minutes to appear. This is more likely to occur when viewing (sampling) Hotspots by RVA or by Functions, especially when a lot of samples with unique addresses were collected, or when viewing call graph results of a very large module (for example, 250MB module size and symbols). [SCR #12377] [SCR #13943] [SCR #13987]
• The online help contains incorrect links to some of the events for the processor code named Montecito.  If you run into this problem, perform a manual search for this event to view its description. [SCR #25878]

On Windows Vista and Windows Server 2008:

• This release does not support working with non-administrator privileges. That is, you must be a local administrator to run the VTune analyzer.
• Call graph profiling may not work on Windows Server 2008 running on Itanium® architecture systems. [SCR #31633]

On Systems Using Itanium® 2 Processors:

• When running an Activity with the sampling or counter monitor data collector that launches an application and has the Terminate Application when Activity ends setting unchecked (a setting which may be accessed via the data collector's configuration pages), if the application is not stopped manually before the Activity finishes running, some processes associated with the VTune analyzer will not terminate after exiting the VTune analyzer. These processes may be safely terminated using the Windows* Task Manager. The following process names may show up in the Task Manager and should be terminated: FileDialogW64.exe.exe, FileSvr64.exe, StandardExeCtrl64PT.exe, vtunecca.exe, and VTuneEnv.exe.
• Sampling 32-bit Java Virtual Machines or 32-bit .NET execution on Itanium® 2 processors is not supported in this release.
• Static analysis is not supported on Itanium® 2 processors. [SCR #12400]
• The vtl global option symbol_search_dirs does not work on systems using Itanium® 2 processors and Intel® processors with Intel® EM64T running a 64-bit operating system. [SCR #20983]
• Sampling of 32-bit applications on Itanium® 2 processors attributes all samples to "Other64", resulting in the inability to drill down on hotspots.  [SCR #31392]
• JIT Profiling API is not supported on systems using Itanium® 2 processors.

On Systems Using Pentium® 4 Processors:

When monitoring the event "Streaming SIMD Extensions Input Assists (TI)," note that not all requests for assists are actually taken. This event is known to overcount. It counts requests for assists from instructions on the non-retired path that do not incur a performance penalty.

Sampling

Windows* Sampling:

• Sampling data collection may fail on Itanium® 2 Processor Family systems running Microsoft* Windows* Server 2003 with Service Pack 1 installed. This is because build 1289 of the operating system turned on CPU C-State in the operating system so if the processor is not busy, it drops the processor into CPU sleep mode (C-State). C-State can be turned off by setting the following registry entry:

  [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Power "IdleFrom0Delay"=dword:0 [SCR #23269]

• The VTune analyzer can only run one sampling session at a time. Attempting to run multiple instances of the analyzer with multiple sampling sessions results in a warning being displayed. Use the Advanced Activity Configuration option to choose multiple sampling counters instead.
• You cannot view sampling data in an Activity result containing more than 64 runs. To view data from a series of events that normally generate more than 64 runs, split sampling data collection into multiple Activities, making sure each Activity generates 64 runs or less. The Events tab on the Configure Sampling dialog box (Configure > Modify <Activity> Collector...) displays the number of sampling runs that are generated by the selected events. [SCR #17086]
• Sampling Over Time views display wall clock time on the time axis relative to the wall clock time at the start of the sampling session. The wall clock values are computed from the processor timestamp counter recorded with every sample collected. On processors with Intel SpeedStep® Technology, the timestamp to wall-clock conversion is not accurate if the processor changes frequency during a sampling session. This results in an incorrect time-axis. However, the sample distribution shown in the view is still in order and can still be useful for analyzing the performance changes over time. To prevent the processor from changing frequencies in Microsoft* Windows*, go to Control Panel > Power Options > Power Schemes and change the OS power scheme to Always On.
• The Sampling Over Time views can only show sampling data for a single run. If you invoke the Sampling Over Time view from sampling results comprised of multiple runs, the view shows the data for events collected in the first run.

Linux* Remote Sampling:

• The Linux* Remote Data Collector from the VTune analyzer for Linux 8.0 can not be used with this product. You must use the Linux* Remote Data Collector that comes with this distribution.
• Sampling fails on 2.6.20 and higher kernels.  A solution is being investigated. [SCR #30638]
• The pre-built sampling drivers for IA-32 RedHat* Linux kernels are compiled for kernels with hardware type “i686” (e.g., kernel-*-2.6.xyz.i686.rpm). You can check which hardware your kernel is built for by typing the command uname –m. If your kernel is built for a hardware type different than “i686”, then the pre-built sampling driver may fail to operate. To fix this problem, build the sampling driver manually for your kernel by following the instructions in /opt/intel/vtune/vdk/src/README. The latest VTune analyzer Driver Kits may be downloaded from: http://www.intel.com/software/products/opensource/vdk/.
• Thread View for sampling data is not supported on Linux.
• The VTune analyzer cannot profile 32-bit applications running on a Linux system with an Itanium® processor. [SCR #10040]
• To get tuning advice for function-level code regions for a remote sampling collection on Linux, you must drill down from the module view to the HotSpot view while still connected to the remote machine. The VTune analyzer copies over the required binary files. If these files contain the desired symbol information, the next time the Tuning Assistant is invoked on a corresponding module, the advice report contains insights or advice for function-level code regions.
• In certain cases some events may occur more frequently during sampling than in calibration. This can result in very large data files. To overcome this issue, disable calibration or manually set the Sampling After value to a reasonable value to prevent generating too big files but still keep the results reliable. [SCR #20782]
• If the remote Linux* application to launch is a command-line program that expects user input from standard input (stdin), then that application may not be directly launched by vtserver. To overcome this issue, use one of the following procedures:
  1. Run the command-line program manually on the Linux* system (not launched through vtserver).
  2. If the Linux* system is running X Windows*, and vtserver has access to $DISPLAY, then the command-line program can be launched indirectly through an xterm. In the "Application/Module Profile Configuration" dialog box, specify the remote application to launch as follows:

  Filename: /usr/bin/X11/xterm

  Command line arguments: –e /path/to/command-line/program arg1 arg2...

  See the man pages on xterm for further details.

Call Graph

Call Graph on Windows*:

• You may not be able to configure a call graph activity from an activity that was configured from a previous version of the analyzer.  If this happens, copy the files from C:\Documents and Settings\<user_name>\Application Data\VTune\MasterProjects32 to <Install Dir>/Analyzer/Bin for IA32 based systems.  For Itanium®-based systems copy the files from C:\Documents and Settings\<user_name>\Application Data\VTune\MasterProjects64 to <Install Dir>/Analyzer/Bin.  [SCR #28120]
• Call graph profiling of ASP .NET applications using a 64-bit operating system on an Intel® EM64T system may cause the operating system to reboot. The problem is due to the fact that the VTune analyzer tries to shutdown some IIS-related services after collection finishes. To workaround this problem never agree to terminate processes/services when performing a Call graph session for an ASP .NET application. [SCR # 25710]
• Call graph profiling of ASP .NET applications may not work on systems with .NET CLR 2.0 Beta2 installed. This version of .NET CLR is available on Windows Vista Beta 1 and Windows Longhorn Server Beta 1 by default. The application does not start, Internet Explorer shows error "Server Application Unavailable". The problem does not appear on released version of .NET CLR 2.0, hence the workaround is to upgrade the Beta2 version to a released one. [SCR #25440]
• Call graph profiling of ASP .NET applications in mixed mode does not instrument native modules on 64 bit operating systems running on Intel® EM64Tsystems and Itanium® architecture systems. Therefore, you will only see the results for jit modules. [SCR #25819]
• Call graph support is based on binary instrumentation. There can be several reasons why a function may not be instrumented:
  • There is no symbol for the function in the binary.
  • When the optimizing compiler uses jump to call to another function (instead of a call instruction), or the same function has multiple entry points. In this case, the two functions are treated as one, and only one of the entry points will be instrumented.
  • The first basic block of a function is smaller than 5 bytes.
  • For 64-bit operating systems running on Intel® processors with Intel® EM64T, the module does not have enough free space to insert instrumentation code.
• Call graph Activities created in VTune analyzer 6.1 cannot be re-run using this version of the VTune analyzer. The results can be opened and analyzed successfully, but to get new results, you need to recreate the Activity.
• Applications build with Cygwin* are not supported.  [SCR #26059]
• You cannot profile screen savers (*.scr) on Microsoft* Windows* with call graph. [SCR #13858]
• Profiling binaries with coff format debug info is not supported. This type of binary is produced by using the /debugtype:coff linker option. The debug information might not be accurate and the instrumented application might crash during run-time. [SCR #14226, 14238, 14242]
• When profiling a Windows* Service executable, launch the application outside of VTune analyzer using the no-application-to-launch or external launcher modes. Be sure to set the service Log-On property to use the account of the user that does the profiling. To do this:

• Go to Control Panel > Administrative Tools > Services.

• Right-click Services and select Properties.

  The <Service Name> Properties dialog box opens.

• Select Log On tab.

• Select This account option and specify the account of the user that does profiling.

To profile out-of-process COM servers or executables launched by Visual Test or a similar testing suite with call graph, select No application to launch or some other launch application (remove the launch application from the modules of interest) and select Yes in the Force Instrumentation column for the profiled executable in the Configure Call Graph dialog box.

• When using no-application-to-launch mode or external launcher mode, instrumentation of system executables may not work, depending on operating system and version used. The reason is that the operating system detects changes in system executables, and restores the original executable if someone changes it.
• Call graph profiling does not support COM methods profiling on systems using Itanium® 2 or Intel® processors with Intel® EM64T with 64-bit operating systems installed.
• If a native function is called from managed code, all its native callees will appear as callees of the original managed function. [SCR #14743]
• Fibers and COM activities are not supported when profiling a DLL in stand-alone-dll mode (meaning: only dll modules in the modules of interest list).
• When profiling 32-bit applications on systems running Itanium® 2 processors and running a call graph where there are copies of the same Microsoft* DLLs in both the execution and %WINDIR%\System32 directories, an error may occur. To prevent this error from happening, delete all copies of Microsoft* DLLs in the execution directory so the %WINDIR%\System32 ones are used instead. [SCR #11173]
• The VTune(TM) analyzer callgraph technology instruments or changes the disk image of the binary or executable. Where the OS or system takes special protective action to prevent changes to binaries and files, such as Windows* File Protection (WFP) service on Windows 2003 Server, this callgraph technology, which is core to its design, will not work. As a result the analyzer, unfortunately, will not be unable to profile the application. The only best work around at this time is to disable the file protection, which may require reverting to an older release of the OS. [SCR#31701]
• In order to profile an ISAPI extension you need to ensure the following:
  • The original non-instrumented extension is unloaded before the beginning.
  • VTune analyzer-generated instrumented extension is unloaded after the end. Perform the following steps:
    1. Open Command Line Windows and run iisreset command in order to restart IIS server and unload all loaded extensions.
    2. Run the VTune analyzer and create call graph project with no application to launch and all extension DLLs as modules of interest.
    3. Run the project.
    4. Run your benchmark.
    5. After benchmark has finished open Command Line Windows and run iisreset command in order to restart IIS server and unload all loaded extensions.
    6. Press Stop button in the VTune analyzer to stop profiling and view gathered profile data.
• Call graph data collection is not yet supported using the Windows* command line interface of the VTune analyzer. Use the VTune analyzer GUI for call graph data collection instead.
• Profiling applications with modified Windows compatibility mode is not supported. [SCR #20704]
• The VTune Analyzer may display the follow message when attempting to instrument a signed Windows* binary image for call graphing:
  
  <your_app.exe> - Bad Image
  <binary_image_of_some_file> is either not designed to run on Windows or it contains an error. Try installing the program again using the original installation media or contact your system administrator or the sofware vendor for support.
  
  
  Click the OK button on the message and continue. The application will run correctly, though profiling data related to the affected image will be missing in the results. Since the interactive message may be unacceptable (for example, automated testing, scripts, console applications), it is recommended that you reduce the instrumentation level of the affected image to "Minimal." [SCR#32326]
   

Linux* Remote Call Graph:

• The following types of Linux* binaries are not supported:
  • Static Linux* applications that have no symbols
  • The Linux* kernel and any kernel modules
  • The Linux* loader (/lib/ld-Linux*.so*)
• When creating an Activity for an application launched from a script, specify the actual application as a module of interest. Note the following:
  • Prior to running the VTune analyzer’s remote agent, the LD_LIBRARY_PATH must match its value when the application is launched from the script. Otherwise, the remote agent may not find the dependent libraries of the application. You may need to add all relevant libraries to the path if they are not currently listed there.
  • Before the application of interest is called by the launching script, the application is renamed back to its original name. If vtserver is terminated abnormally or seemed to hang before the application was called, you need to restore the environment manually. (The original application is stored at the same directory with the __bistro_orig suffix.)
• When an instrumented application calls the exec system call, the whole image context is replaced with the new image. If the application calls to exec with original name of the instrumented image, then the instrumented image is used. In the other cases, the original (non-instrumented) image is called, and no results will be generated from this point in the run.
• Linux* call graph does not support setuid images. The setuid mechanism is used to give a user process the effective user ID of another user, usually root. You can use call graph and run the setuid executable only if you are logged in as the same user as the owner of the setuid executable.
• Call graph results are written during the regular termination procedure of the process. This means that if the process did not terminate properly, no call graph results will be generated. There are a few reasons why an application may not terminate properly:
  • There was some type of crash (like an access violation) during the termination procedure.
  • The application terminated because a termination signal was caught by the application (e.g., SIGKILL, SIGTERM).

  To generate call graph results in the above three cases, you need to cause a proper termination before it is improperly terminated by itself. There are two ways to perform a proper termination:

  • Press the Stop button in the GUI.
  • In the Linux* machine you can send a special signal to the instrumented application. The number of the signal should be in the _Bistro_Exit_Signal_ environment variable, or the SIGUSR2, by default.
• Call graph implements the same search algorithm as the standard loader for locating executables and shared objects. Therefore, if you use a private version of the loader with a different search algorithm, call graph may not find the required files.
• Call graph supports dynamically loaded images loaded with dlopen (from libdl). There is no support to images loaded directly with the mmap system call.
• VTune analyzer may hang if a non-existing module of interest was specified when creating a call graph Activity. [SCR #19801]
• The call graph run creates Unix* pipes and uses file locking on the Linux* file system. Therefore the Linux* file system on which the cache directory resides must support these operations. Intel recommends using a local disk for the call graph cache directory on the Linux* system.
• The NFS automount utility (also known as the amd) may unmount directories specified in the call graph collection but not used continuously during the run. This may cause unexpected behavior and the VTune analyzer may fail to run or generate results. Try to avoid using automounted directories. If your Linux* system uses automounted directories, turn off automount and manually mount any necessary directories before running a call graph session.
• Call graph results from Linux* remote system are collected and stored in memory on the Windows* local system. In some cases, the required memory may exceed the available physical memory. To limit the amount of memory used during the run, select Configure > Options > Call Graph and change the memory setting in the dialog box. Te maximum call graph results size is limited to about 800Mb. Set the system virtual memory size as large as possible.
• Statically linked executables are not fully supported. You may see problems, especially when C++ exception handling is used. To avoid this problem, dynamically link your application for call graph profiling.
• The call graph information of an application is kept in memory during the run. The buffer size is set by default to 128MB unless your system has less then 256MB - then it will be half of the physical memory. Setting other value to the buffer size can be done using Configure > Options > Call Graph > Collector property page.
• Call graph does not support applications that use two different shared objects with the same name, even if they are located in different directories. This may cause an abnormal termination of the VTune analyzer. [SCR #14986]
• If you packed an Activity result of the call graph data collection and try to unpack and run it on another controlling system, be sure you re-launched vtserver on a Remote Agent system. Otherwise, the error can occur on the controlling system. [SCR #21236] 

Online Help

• The Explain Event and Explain Ratio buttons may not work for some processors. To view event/ratio description, go to Help > Contents > VTune™ Performance Analyzer > Reference > Processor Events and Advice, and search for the required information.

Command Line Interfacee

• When using any of the VTune analyzer commands, the total length of any pathname and filename combination cannot exceed 250 characters due to a limitation in the database. [SCR #15423]
• The vtl global option symbol_search_dirs does not work on systems using Itanium® 2 processors and Intel® processors with Intel® EM64T running a 64-bit operating system. [SCR #20983]

Counter Monitor

• Counter monitor under Windows Server 2003 with Power User privileges may not work, saying that: "The performance system on this computer does not work properly; some performance objects can’t be initialized. Registry corruption could be a possible reason."  If you see this error, run Counter Monitor with Administrator privileges.

Static Analysis

• Static analysis is not supported on Itanium® 2 processors. [SCR #12400]
• You may see mismatches between functions and source files in Static Module View for binaries containing Microsoft* .NET Common Language Runtime functions. [SCR #11650]
• In the Source View static analysis, the default processor, as represented in the Change Processor context menu, is used and not the Activity results processor. The default processor is set as the host processor type. If the module is for a different processor architecture than that of the host, the default processor is set as the latest processor in the architecture family. [SCR #14267] [SCR #12407]

Tuning Assistant

• The Tuning Assistant only supports tuning advice for the following processors:
  • Intel® Pentium® 4 processor
  • Intel® Pentium® M processor
  • Intel® Core™ Solo processor
  • Intel® Core™ Duo processor
  • Intel® Core™2 Duo Processor
  • Dual-Core Intel® Xeon® Processor 5100 Series
  • Intel® Itanium® 2 processor
• The Tuning Assistant may report errors related to source-based advice generation when invoked from Source View when the source code uses advanced features of Microsoft* Visual C++* .NET. To work around this problem, disable source-based advice in the Intel® Tuning Assistant / Source Information section of the Options (Configure > Options) dialog box.
• The Tuning Assistant doesn't support comparing two different binaries in the HotSpot or Source View. The Tuning Assistant will continue generating invalid messages, or none at all. It generates the following error message: "A valid comparison cannot be made because the RVA values selected in these views will not correlate to the same functions in the two different binaries." To avoid this problem, only request advice from the Process or Module Views when comparing two different binaries.
• MOB Replays Retired may not report correct data in precise mode. Precise mode is enabled by default for this event. To disable precise mode, add it to the Select Events list and uncheck the Precise Event checkbox. Then simply double-click the event.
• Occasionally, when Automatically generate tuning advice is selected in the sampling wizard, after sampling data collection finishes, the Tuning Assistant may report "No Sampling data for the selected context". When automatically generating tuning advice, the Analyze the current selection option is selected by default in the Tuning Assistant Options for Sampling dialog. This causes the Tuning Assistant to try to analyze samples that were collected in the process that was selected in Application to launch (in the Sampling Wizard) and in modules that were selected in the modules of interest list (in the Sampling Wizard). If this combination of process and modules did not receive any samples, the "No Sampling data for the selected context" error message will be generated. (For example: this may occur when the Application to launch is a script that invokes the actual application containing the modules of interest). In this case, after sampling data is collected, select the processes and/or modules for which you would like advice, then manually invoke the Tuning Assistant (by pressing F8 or selecting Get Tuning Advice from the View menu).
• After zooming in to a specified time range in Sampling Over Time View, switching to Classic Sampling View, and invoking the Tuning Assistant, the resulting Tuning Assistant report is for the entire workload time range, not the specified zoom-in time range.
• Getting tuning advice for imported results is not supported [SCR #17452]

Technical Support and Feedback

Register for Intel® Premier Support

To receive technical support for the tools provided in this product and technical information including FAQs and product updates, register for an Intel® Premier Support account via the Intel® Registration Center when registering your serial number. Click Intel® Premier Support on that site to start the registration.

NOTE: Registering for support varies for release product or pre-release products (alpha, beta, etc.) and only released products have support web pages on http://support.intel.com/.

If you have forgotten your password and cannot reset it via the service provided at the Intel® Registration Center, please submit a request to: Startup Support. Do not email technical issues using this mechanism because it is not secure.

Self-Help and User Forums

Intel provides a rich repository of online self-help product information, such as tutorials, getting started tips, known product issues, product errata, compatibility information and answers to frequently asked questions.

Accessing Intel® Software Development Products Technical Support:

The Intel® Software Development Products: Technical Support Web site is a wealth of information.

http://www.intel.com/software/products/support/

It's a great place to find answers quickly and to gain additional insight into using our products effectively.

Accessing VTune™ Performance Analyzer Product Support:

The VTune analyzer product support web site provides access to technical issues, frequently asked questions, product documentation and product errata.

http://support.intel.com/support/performancetools/vtune/

Accessing the VTune™ Performance Analyzer Development Forum:

Users of the VTune analyzer software are invited to participate in open forum discussions regarding this and other VTune analyzer software, ranging from non-technical to highly technical in nature, at the Intel® Developer Services Forums.

http://softwareforums.intel.com/ids

The forums are moderated, but all discussions regarding VTune analyzer experiences are invited, including functionality, usability, bug workarounds and general usage.

Submitting Issues

Your feedback is important to us. To submit an issue via the Intel® Premier Support web site:

1. Go to http://www.intel.com/software/products/registrationcenter/index.htm and login.  Java* and JavaScript* must be enabled in your web browser to submit an issue.
2. Click on the Intel® Premier Support link in the lower right, after logging in.
3. Read the Confidentiality Statement and click the I Accept button.
4. Click on the Submit Issue link in the left navigation bar.
5. Choose Initiatives, technologies & tools from the Product Type drop-down list.
6. Choose VTune™ Performance Analyzer from the Product Name drop-down list and select your version in the appropriate field.
7. Enter your question and complete the fields in the windows that follow to successfully submit the issue.
   1. Describe the problem or enter your suggestion. For problem reports, be as specific as possible, so that we may reproduce the problem. For compiler problem reports, include the compiler options and a small test case, if possible.

   2. Describe your system's configuration information. Be sure to include information applicable to your setup: the operating system name, version and build number, the name and version number of installed applications, and anything other information that will help us to address your concern(s).  You can execute the vtqfagent.cmd script file, normally in C:\Program Files\Intel\VTune.  This will create a vtqfagent_log directory in your My Documents directory.  You can zip up/compress that directory and attach it to your issue, using the Attach File link.  All information in the vtqfagent_log directory is text and can be reviewed for confidentiality, prior to uploading.

A technical support engineer will respond within one (1) Intel business day.

Documentation

• these Release Notes
• Installation instructions for the VTune™ Performance Analyzer Linux* Remote Agent
• Online help, with several demos of the main features in the VTune Performance Analyzer > Demos book
• Instruction Set Reference manuals (PDF)
• An excerpt from the book: VTune™ Performance Analyzer Essentials, Measurement and Tuning Techniques for Software Developers
• Profiling Runtime Generated and Interpreted Code using the VTune™ Performance Analyzer (PDF)

Online Help

Complete information on using the VTune analyzer is contained in the VTune analyzer online help. This help is in HTML Help 1 format and can be viewed in an HTML Help viewer. When the VTune analyzer is integrated in the Microsoft* Visual Studio* .NET environment, a small Help 2 module titled VTune™ Performance Tools is available from the Microsoft* Visual Studio* .NET Help collection. This module covers key VTune analyzer concepts and has links to topics in the main online help in the HTML Help 1 format.

Access the online help from the Help menu, or access the context-sensitive help in one of the following ways:

• Hit the F1 key to display the overview help topic corresponding to the active VTune analyzer window. From the overview help topic, you can navigate to related help topics.
• Go to Start > Programs > Intel® Software Development Tools > Intel® VTune™ Performance Analyzer and select one of the available help files in the program group.
• Right-click an item in a dialog box or view and select What's This?

Additional Information

Related Products and Services

Information on Intel® software development products is available at http://www.intel.com/software/products. Visit the following product-related sites for additional information:

• The Intel® Software College provides interactive tutorials, documentation, and code samples that teach Intel® architecture and software optimization techniques.
• The Intel® C++ Compiler and Intel® Fortran Compiler enable software to run at top speeds and fully support the latest Intel® IA-32 and Itanium® processors.
• The Intel® Performance Library Suite provides a set of routines optimized for various Intel® processors. It is not part of this product.
• The Intel® Math Kernel Library provides developers of scientific and engineering software with a set of linear algebra, fast Fourier transforms and vector math functions optimized for the latest Intel® Pentium® and Intel® Itanium® processors.
• The Intel® Integrated Performance Primitives consists of cross platform tools to build high-performance software for several Intel® architectures and several operating systems.

Disclaimer and Legal Information

INFORMATION IN THIS DOCUMENT IS PROVIDED IN CONNECTION WITH INTEL® PRODUCTS. NO LICENSE, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, TO ANY INTELLECTUAL PROPERTY RIGHTS IS GRANTED BY THIS DOCUMENT. EXCEPT AS PROVIDED IN INTEL'S TERMS AND CONDITIONS OF SALE FOR SUCH PRODUCTS, INTEL ASSUMES NO LIABILITY WHATSOEVER, AND INTEL DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY, RELATING TO SALE AND/OR USE OF INTEL PRODUCTS INCLUDING LIABILITY OR WARRANTIES RELATING TO FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR INFRINGEMENT OF ANY PATENT, COPYRIGHT OR OTHER INTELLECTUAL PROPERTY RIGHT.
UNLESS OTHERWISE AGREED IN WRITING BY INTEL, THE INTEL PRODUCTS ARE NOT DESIGNED NOR INTENDED FOR ANY APPLICATION IN WHICH THE FAILURE OF THE INTEL PRODUCT COULD CREATE A SITUATION WHERE PERSONAL INJURY OR DEATH MAY OCCUR.
Intel may make changes to specifications and product descriptions at any time, without notice. Designers must not rely on the absence or characteristics of any features or instructions marked "reserved" or "undefined." Intel reserves these for future definition and shall have no responsibility whatsoever for conflicts or incompatibilities arising from future changes to them. The information here is subject to change without notice. Do not finalize a design with this information.
The products described in this document may contain design defects or errors known as errata which may cause the product to deviate from published specifications. Current characterized errata are available on request.
Contact your local Intel sales office or your distributor to obtain the latest specifications and before placing your product order.
Copies of documents which have an order number and are referenced in this document, or other Intel literature, may be obtained by calling 1-800-548-4725, or by visiting Intel's Web Site.

Intel processor numbers are not a measure of performance. Processor numbers differentiate features within each processor family, not across different processor families. See http://www.intel.com/products/processor_number for details.

BunnyPeople, Celeron, Celeron Inside, Centrino, Centrino logo, Core Inside, FlashFile, i960, InstantIP, Intel, Intel logo, Intel386, Intel486, Intel740, IntelDX2, IntelDX4, IntelSX2, Intel Core, Intel Inside, Intel Inside logo, Intel. Leap ahead., Intel. Leap ahead. logo, Intel NetBurst, Intel NetMerge, Intel NetStructure, Intel SingleDriver, Intel SpeedStep, Intel StrataFlash, Intel Viiv, Intel vPro, Intel XScale, IPLink, Itanium, Itanium Inside, MCS, MMX, Oplus, OverDrive, PDCharm, Pentium, Pentium Inside, skoool, Sound Mark, The Journey Inside, VTune, Xeon, and Xeon Inside are trademarks of Intel Corporation in the U.S. and other countries.

* Other names and brands may be claimed as the property of others.

Copyright (C) 2006–2009, Intel Corporation. All rights reserved.