These are a few of my favorite tools!

Welcome to my first blog!  I have previously co-authored a couple of articles but this one is truly my first blog. Those of you who loved "The Sound of Music" may find the title of this blog familiar. For the rest, this blog is really about sharing with you some of the tools I work with and like.

In my role of Technical Consulting Engineer here at Intel® Corp, I support and use performance and threading analysis tools. The performance analysis tools I use include VTune™ Performance Analyzer and Intel Parallel Amplifier. The Threading Analysis Tools include Intel Thread Profiler, Intel Thread Checker and Intel Parallel Inspector. I also use Intel Performance Tuning Utility (a technology showcase of several performance analysis features) and Intel Parallel Advisor Lite (a first of its kind tool which aids developers incorporate parallelism).

You may have heard of some of those product names before. What follows is a brief description of these tools for those of you who are less familiar with them. The descriptions are mine and are illustrative - they are not meant to be a formal description of the tools themselves but rather a conversational description for a lay geek. :)

In no particular order, here are the tools:

    • VTune Performance Analyzer - my favorite performance analysis tool. You can gain performance insights at the system level (using Event Based Sampling or Time Based Sampling) or at the application level (using Call Graph feature).

    • Intel Performance Tuning Utility - often called PTU, this technology showcase has some excellent performance analysis features which are worth your attention! I use the Statistical Call Graph feature which is much lower overhead than the VTune™ call graph. Another really cool feature is the Data Access Profiling which can help locate memory hotspots.

    • Intel Thread Profiler - it is midnight - do you know what your threads are doing? :) Thread Profiler shows you what your threads are doing in its "Timeline view".

    • Intel Thread Checker - hunts for threading issues (races, deadlocks, etc) lurking in multithreaded code. If you use no other tools, please be sure to use Thread Checker or Parallel Inspector.

    • Intel Parallel Composer is a C/C++ compiler, associated libraries and debugger. It is integrated directly into Microsoft Visual Studio and is very to use!

    • Intel Parallel Inspector is a correctness analyzer for your code and helps check your code for memory issues (leaks, incorrect usage, etc) and threading issues (data races, deadlocks, etc). This is one must-use tool!

    • Intel Parallel Amplifier is a performance analyzer and helps identify hotspots, scalability issues and locking bottlenecks in your code.



Parallel Composer, Parallel Inspector and Parallel Amplifier are part of Intel Parallel Studio product suite and integrate directly into Microsoft Visual Studio IDE. So does Advisor Lite. They are very easy to use! The rest of the tools are available on various flavors of Unix and Windows OSes, for the most part.

I also use Intel Threading Building Blocks (TBB) threading library. If you use Parallel Studio, you already have a version of TBB available in the installation. It provides high level abstractions for incorporating parallelism into software. TBB scales your code automatically based on the number of cores in the underlying machine. This many-core enabling is one big reason why I like to use it.

My recent favorite tool is really the Parallel Advisor Lite. The feature of this tool that I really find very useful is "Correctness Modeling". Using this feature, you can model correctness of a potential parallel "site" in your program using annotations (which are like macros in C/C++ code). Annotations spare you the effort of actually having to actually parallelize your code as all of that hard work is done behind the scenes by Parallel Advisor Lite. Thanks to this feature, you can experiment with software parallelization and find out all potential data sharing issues before you actually modify the code for incorporating any parallelism. Any potential data sharing issues found can be fixed before parallelizing code and this can give the developer more confidence in the correctness of code. Pretty neat, isn't it?

In my future blog postings, I will delve into more details and share with you some of the things that I like about these tools. Have you used any of these tools? Which tools and tool features do you like most? Please share!

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

For more complete information about compiler optimizations, see our Optimization Notice.