Intel Software Network articles feed

Install Intel VTune performance analyzer for Linux on Moblin system

Tue, 20 Oct 2009 02:17:40 -0700

This article describes how to install Intel VTune performance analyzer for linux on Moblin system. In this tutorial, we use Intel VTune performance analyzer for linux version 9.1, and moblin 2.0 final version for netbook.
1. Install and set up moblin OS.
a. Download the moblin 2.0 OS from http://moblin.org/downloads , I use the moblin image from http://mirrors.kernel.org/moblin/releases/2.0/images/moblin-2.0-final-20090924-001.img
This is the Moblin 2.0 final version for netbooks. You may try to download a more recent OS version. The steps described in this article should be similar for more recent moblin OS.
b. Install OS on a netbook. After the OS installed successfully, you also need to install some other tools.
First, make sure your yum is working. It’s very convenient to install moblin software tools by yum.
Second, use yum to install gcc, make etc moblin tools. For example, use command ‘yum install gcc’ to install gcc in your moblin system.
Finally, during this tutorial, you may find the error that xxx is not installed. In this case, just use ‘yum install xxx’ to install the required software tools.
2. Install VTune
Now we will install VTune version 9.1 on Moblin. Goto VTune installation folder, run command:
$ ./install
Follow the installation message and install the VTune.
During the installation, it will report that the current distribution of Linux on your system is not validated. This is not a problem, input Yes to proceed with the install.
You don’t need to change any options during installation, you can use the default setting. Select 1 “Start installation” for next step.
Most likely, you will find the following messages during the final installation:
…
Please wait …
EntireX DCOM for Linux* component is being installed…
EntireX DCOM for Linux* component was successfully installed.
The Vtune™ Performance Analyzer Driver Kit component is being installed…
Searching a pre-built driver … FAILED
Building the driver for your kernel … FAILED
Installing sampling driver boot script … OK
Loading the driver … FAILED
…
According to the message, the VTune driver for Moblin is failed. This is fine. We will build the driver manually later. Press enter to finish the installation.
3. Build Moblin kernel
To build the VTune driver, we need the moblin kernel source. You can get the moblin kernel source package from http://repo.moblin.org/moblin/development/core/source/ . We use kernel-2.6.30.3-4.1.moblin2.src.rpm in this tutorial. Please make sure your kernel source is same as your OS kernel version.
a. Extract the rpm, the kernel source will be extract to rpmbuild folder. For example, in my system, the rpm package is located in /home/moblin/Download. The kernel source is extracted to /home/moblin/rpmbuild
$ rpm –ivh kernel-2.6.30.3-4.1.moblin2.src.rpm
b. Build the kernel
$ cd rpmbuild/SPECS
$ rpmbuild –bb ./kernel.spec
Normally, the kernel will be built successfully. Please refer to the http://moblin.org for the issues with kernel build. If the build is failed, ignore the error messages, you may still be able to continue for the next steps.
After this step, you will find the kernel source build environment in folder /home/moblin/rpmbuild/BUILD/kernel-2.6.30/linux-2.6.30
c. Set the build and source link. In folder /lib/modules/2.6.30.3-4.1.moblin2-netbook, there are two links, build and source. You need to reset it to the correct directory.
$ cd /lib/modules/2.6.30.3-4.1.moblin2-netbook
$ ln –s /home/moblin/rpmbuild/BUILD/kernel-2.6.30/linux-2.6.30 build
$ ln –s /home/moblin/rpmbuild/BUILD/kernel-2.6.30/linux-2.6.30 source

4. Build VTune driver
Now we will build the VTune driver manually.
a. goto VTune driver build directory.
$ cd /opt/intel/vtune/vdk/src
b. remove –Werror in Makefile.in
$ vi Makefile.in
Search “-Werror”, you will find lines:
DEBUG_FLAGS = -Werror
RELEASE_FLAGS = -Werror
This option is to treat warning as error during compilation. Just remove –Werror, otherwise, the build will be failed.
c. Build the VTune driver for moblin
$ ./build-driver
Use default setting during build.
C compiler to use: /usr/bin/gcc
Make command to use: /usr/bin/make
Kernel source directory: /lib/modules/2.6.30.3-4.1.moblin2-netbook/source
d. Normally the build will be successful. You can find the VTune driver file vtune_drv-x32-2.6.30.3-4.1.moblin2-netbooksmp.ko in the current folder. In some cases, if there are problems in your kernel source tree, the configuration will be failed. For example, if the configuration reports that the version.h is not found, you need to check if the version.h is in the kernel source folder /home/moblin/rpmbuild/BUILD/kernel-2.6.30/linux-2.6.30/include/linux. If it is not there, you may need to rebuild the kernel.
e. Load the driver.
$ ./insmod-vtune
It will report that the driver is loaded successfully.
5. A simple sampling test.
Now let’s have a simple test for the VTune. You can write a simple test.c to generate a simple test file for execution. Please note that you need root access for the sampling.
a. add VTune bin path to PATH.
$ export PATH=$PATH:/opt/intel/vtune/bin
b. run vtl
$ vtl activity –c sampling –app a.out run
VTune will report that the activity was successfully created and the sampling data was successfully collected. You can use vtune for performance analysis now. Enjoy.
6. Use VTserver for performance analysis.
You may try to use vtlec for Eclipse GUI based performance analysis. However it may be failed to lunch on moblin system. A better solution is to use VTserver. You can connect to VTserver from your other window machine, run the application remotely and get the performance data.
a. start up the VTserver
$ vtserver
b. connect to the server from window machine.
Open Intel VTune performance analyzer on your windows machine. Click Activity->New Activity, select Sampling Wizard for example. Set up user:password@host-ip in Remote Target Configuration. Set the application to launch, for example, /home/moblin/test and click finish. The application /home/moblin/test will be executed on Moblin and the sampling data will be collected to your windows machine for performance analysis.
c. For more information, please refer to the VTune documents.

Use VTuneAPI in your code to profile without launching VTune(TM) Analyzer

Thu, 15 Oct 2009 02:26:27 -0700

Intel(R) VTune(TM) Performance Analyzer provides VTuneAPI to allow profiling which is controlled by the user. The objective is not to collect unreasonable samples in the portion of user's code (usually the code looks like to call 3rd-party libraries, system functions, etc) when data collecting

Article <<An Introduction to Sampling and Time>> introduced how to use Pause and Resume API at page 8. However it also informed the user that checking "Start with Data Collection Paused" should be set on User Interface at page 9.

Believe me that VTune(TM) Performance Analyzer can not be launched when executing user's code which has VTune API calls, and you can get result file which can be analyzed on VTune(TM) Analyzer later.

How smart it is! How simple it is! You don't need to run VTune(TM) Analyzer to get performance data. Everything is controlled by the user, including Sampling Configure.

See below example -

// testVTuneAPI.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "VtuneApi.h"

int _tmain(int argc, _TCHAR* argv[])
{
U32 u32Return;

VTUNE_EVENT events[] = {
         { 10000, 0, 0, 0, "CPU_CLK_UNHALTED.CORE" }, // Sample After Value, Reserved, Reserved, Return Status, Event Name - my system is Intel(R) Core(TM) 2 Duo
         { 10000, 0, 0, 0, "INST_RETIRED.ANY" },             //  Use "vtl query -c sampling" to know all supported events in the system, in command prompt
     };

     U32 numEvents = sizeof(events) / sizeof(VTUNE_EVENT);
     VTUNE_SAMPLING_PARAMS params = {
         sizeof(VTUNE_SAMPLING_PARAMS),
         sizeof(VTUNE_EVENT),
         0, // sampling options
         0, // reserved
         0, // If 1, start sampling in pause mode
         0, // maximum number of samples to be collected.
         1000, // number of samples per buffer
         40,  // the sampling interval in milliseconds
         1, // "1" for event based sampling
         numEvents,  // number of events
         events, // event list array
         "results.tb5", // result file with simple or full path
         0, // reserved
         0, // "1" - generate a count file "tb5Filename.txt"
         "" // CPU mask
     };

     u32Return = VTStartSampling(¶ms); // start sampling since it is not in pause mode
     if (u32Return) {
         printf("Can't start sampling\n");
         exit(0);
     }
     for (int i=0; i<10000000L; i++); // do some work, data is captured

VTPauseSampling(); // pause data collection

for (int i=0; i<10000000L; i++); // do some work, data is NOT captured

     VTResumeSampling(); // resume data collection

     for (int i=0; i<10000000L; i++); // do some work, data is captured again

     u32Return = VTStopSampling(1); // stop collecting data and write result into TB5 file, use VTune(TM) Analyzer to import it!

     if (u32Return) {
         printf("Can't stop sampling\n");
         exit(0);
     }

return 0;
}

Where are my threads? - Part II

Wed, 14 Oct 2009 05:05:26 -0700

set KMP_AFFINITY=scatter or set KMP_AFFINITY=compact

By setting an affinity type, we are changing the default behavior of Intel compiler’s OpenMP runtime library. By default, runtime library does not bind OpenMP threads to particular thread contexts so that OS scheduler freely decides how to schedule each thread.

After setting the affinity and running the application under VTune analyzer, we get the SOT results as shown in Figure 4. Comparing Figure 4 and Figure 1 (where no affinity was set) shows no significant differences; the two results look almost identical. However, the difference lies in the details. Zooming in on the timeline shown in Figure 4 will give us an idea of what has changed from the previous run.

Figure 4: SOT view after setting the thread affinity using KMP_AFFINITY

Figure 5 shows that both threads 17 and 64 remained on the same cores on which they were initially scheduled. Thread17 initially got scheduled to run on Core 0 and Core 1, but it stayed on Core 0 for the remainder of the run.

Figure 5: Results showing how setting thread affinity affects the application runtime

Where are my threads?

Wed, 30 Sep 2009 04:05:20 -0700

One common question developers ask is how their parallel workload is distributed or scheduled across the available cores/processors.

Intel® VTune^TM Performance Analyzer comes into help and makes such analysis easy. The event-based sampling (EBS) technology identifies system-wide software performance problems by sampling processor events, such as clockticks and cache misses (Figure 1). From the EBS data, you can determine which process, thread, module, function, and source line in a given application generated particular events. By leveraging this technology you can see how many events were sampled on each core as well as which thread generated them.

Figure 1

The Show/Hide CPU Information button in the sampling toolbar displays collected samples and events per processor in the Process, Thread, Module, and Hotspot sampling views (Figure 2).

Figure 2

We now know that this particular program (sort_mt1.exe) was executed on 2 cores and we can see the number of samples collected on each core. But what we don't know yet is how many threads this application created and how the threads executed on these cores. Selecting the Thread view when CPU button is also selected will show us the desired information. Figure 3 tells us that sort_mt1.exe created 2 threads (thread18 and thread 13) and each thread was executed on both cores (OS scheduled these threads to run on each core) during the analysis. If you look at the clockticks (CPU_CLK_UNHALTED.CORE) for thread18, it becomes clear that this particular thread was executed on each core while running most of the time on Processor 0.

Figure 3

If you are still curious and would like to see how these samples are distributed over time per thread and per core then the sampling over time (SOT) view can help you. By selecting SOT view in thread view (or in any other view) the samples collected will be displayed per thread and/or core(Figure 4). The view seen in Figure 4 is useful for many reasons. The SOT view can help you:

•· see how OS scheduled the threads to run,

•· identify scheduling problems (Figure 5),

•· identify load balancing issues among threads (Figure 6),

•· and correlate micro-architectural problems.

Figure 4

Figure 5: Manually setting thread affinity can create problems. Each thread is scheduled/pinned to the Core/Processor 0.

Figure 6: SOT showing a load balance issue.

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.

Intel® VTune™ Performance Analyzer for Linux* - How do I Supply Arguments for the Application to Run Under the Analyzer?

Fri, 19 Sep 2008 00:00:00 -0700

Symptom(s):

The VTune™ analyzer complains of a "Syntax Error" when you attempt to specify arguments or parameters to the application on the vtl command line.

Solution:

Use comma separation for arguments. For example,

vtl activity -c sampling -app /bin/ls,-Fa,/home run

will cause the analyzer to launch `/bin/ls -Fa /home'. No spaces are allowed before or after the commas.

Alternately, you can enclose all application arguments within double quotes, e.g.,

vtl activity -c sampling -app /bin/ls,"-Fa /home" run

Note that no spaces are allowed after the comma following the application name.

Operating System:

SUSE* Linux

Intel® VTune™ Performance Analyzer for Linux* - Documentation and command-line help

Fri, 19 Sep 2008 00:00:00 -0700

The documentation for the Intel® VTune™ Performance Analyzer for Linux* is presented in these formats:

Documentation Index
Readme File
Installation Guide
Administrator's Guide
Readme File for the VTune Analyzer Remote Agent
Command-line Help
Man Pages
HTML Reference, User's Guide and Getting Started Tutorial for vtl
Integrated Eclipse platform environment help

Command-line Help

Enter vtl -help to view command syntax and options for vtl.
Enter vtl -help -c where is either callgraph or sampling, for detailed help on collecting data.
Enter vtl -help -v where is either callgraph, sampling or source, for detailed help on viewing data.
Enter ActivityController -help to view command syntax and options for the ActivityController.

Manual Pages

To view manual entries for the VTune analyzer, enter the appropriate command:

man vtl for the vtl command man page
man vtlec for the vtlec command man page
man ActivityController for the ActivityController man page
man sampling for the sampling collector man page
man callgraph for the callgraph collector man page
man source or man 7 source or man code for the source view man page

Note: To view the man pages in the local language, set the system variables LESSCHARSET and LANG as follows: LESSCHARSET=utf-8
LANG=zh_CN.utf8

HTML Documentation

The HTML documentation for the VTune analyzer consists of these components:

Documentation Index. Open this document in the browser to view the list of available documentation. This document is available at < install_dir>/doc/doc_index.htm.
VTune(TM) Performance Environment User's Guide. To access the guide, launch the index.htm file from the /doc/users_guide subdirectory.
Reference Guide. To access the reference, launch the index.htm file from the /doc/reference subdirectory.
Getting Started Tutorial. To access the tutorial, launch the index.htm file from the /doc/training/gs_vtune subdirectory.
Java* Managed Run Time Environment Frequently Aske d Questions. To access the document, launch java_faq.htm file from the directory.
These Release Notes

Where: is the installation directory. The default installation directory is: /opt/intel/vtune.

Viewing HTML Documentation

The HTML documentation can be viewed with any web browser, although a browser that supports HTML 4.0 is recommended. Older versions of browsers (especially Netscape* and Konqueror*) may not display some of the HTML documents correctly.

Integrated Eclipse Platform Environment Documentation

The VTune analyzer documentation in the integrated Eclipse platform environment is available from the Eclipse user interface. Go to Help » Help Contents and click to expand the following books: VTune™ Performance Environment, VTune™ Performance Analyzer or VTune™ Performance Analyzer Reference.

Intel® VTune™ Performance Analyzer for Linux* - Java* Development Kits (JDKs)

Fri, 19 Sep 2008 00:00:00 -0700

The VTune analyzer in the integrated Eclipse platform environment has been tested for operation on the following JDK:

BEA* JRockit* 5.0

The VTune analyzer has been tested for profiling under the following JDKs. The latest releases of these JDKs may be used:

On IA-32 systems:
Sun* J2SE 5.0 and 6<
IBM* JDK 1.4.2 and 5.0
BEA JRockit 1.4.2, 5.0 and 6

On Intel® Itanium® architecture systems:

IBM JDK 1.4.2
BEA JRockit 1.4.2 and 5.0

On systems with Intel® 64:

Sun J2SE 5.0 and 6
BEA JRockit 5.0 and 6
Note: The VTune analyzer will crash under Eclipse if you run it with BEA JRockit 5.0 under Red Hat Enterprise Linux*

4.0 for Intel® 64 - Do one of the following to avoid this situation:

Install the errata kernel for Red Hat Enterprise Linux 4.0
Use Red Hat Enterprise Linux 4.0 U1
Use the Sun JVM 5.0

Intel® VTune™ Performance Analyzer for Linux* - Temporary and project files for VTune™ Analyzer for Linux* location

Fri, 19 Sep 2008 00:00:00 -0700

There are several places where VTune™ analyzer for Linux* stores its temporary and project files: user files, instrumented binaries for the current user, and symbol cache files for all VTune users. The default location for VTune user files including data files associated with activities and activity results is the user home directory. It can be changed by using VTUNE_USER_DIR environment variable. If the variable is not set then the default location is $HOME/VTune in case you are using VTune in command line (vtl).

If you are using Eclipse* GUI (vtlec) then the following directories are also created $HOME/.eclipse and ECLIPSE_WORSKPACE (it is set during Eclipse startup). The default location for instrumented binaries and shared objects is "/tmp/vtune_$USER/Cache" directory. You can change it via "vtl global-options" by setting "cache-directory" set of parameters. For example "vtl global-options cache-directory=/new/cache/location/Cache". If you are using Eclipse GUI then you can change it for every Call Graph activity using Configure Call Graph Collectors » Advanced tab. The default location for symbol cache files is "/opt/intel/vtune/global-data/" directory. You can change it by setting VTUNE_GLOBAL_DIR environment variable.

Intel® VTune™ Performance Analyzer for Linux* - What is VTune™ VDK? Should I update it every time new VDK is released?

Fri, 19 Sep 2008 00:00:00 -0700

The VTune™ Analyzer Driver Kit is a package that is needed to do sampling profiling and build VTune sampling driver on Linux* for a non-supported version of Linux kernel. It consists of two parts: pre-compiled drivers for supported Linux distributions and source code of Linux kernel sampling driver. If you're installing VDK on one of unsupported Linux distributions you might need to recompile the driver to use sampling. To do that you also need development version of Linux kernel package or Linux kernel source package installed and configured properly. There are several versions of VDK.

Please check the Intel VDK site for the recent version of VDK package for your VTune version and more details. You only need to update VDK package in case Linux kernel was updated to the last released and installed VDK did not work with it. You can perform Call Graph profiling without loading sampling driver at all.