// 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(&params); // 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;
}

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.

Target System : Linux*


Problem Description : We discovered a problem, it failed when connecting from VTune^TMAnalyzer on Windows* to Linux* Remote Data Collector (RDC). Two boxes can ping each other, SELINUX is disabled, VTune^TM Analyzer version and RDC versions are consistent.

Root-Cause : This is a firewall issue to prevent RDC connections. Default RDC port "500000" on Linux* machine is closed. Check iptables settings.  

Solution : Use port "80" (usually it is opened) instead of default RDC port on Linux* to start vtserver, like as:

"vtsever -p 80" on Linux* side

"user:password@ip-address:80" on "Remote" dialog of Windows* side



[DISCLAIMER: The information on this web site is intended for hardware system manufacturers and software developers. Intel does not warrant the accuracy, completeness or utility of any information on this site. Intel may make changes to the information or the site at any time without notice. Intel makes no commitment to update the information at this site. ALL INFORMATION PROVIDED ON THIS WEBSITE IS PROVIDED "as is" without any express, implied, or statutory warranty of any kind including but not limited to warranties of merchantability, non-infringement of intellectual property, or fitness for any particular purpose. Independent companies manufacture the third-party products that are mentioned on this site. Intel is not responsible for the quality or performance of third-party products and makes no representation or warranty regarding such products. The third-party supplier remains solely responsible for the design, manufacture, sale and functionality of its products. Intel and the Intel logo are trademarks or registered trademarks of Intel Corporation or its subsidiaries in the United States and other countries. *Other names and brands may be claimed as the property of others.]