Taking Intel Parallel Studio 2011 For a Spin

Since the release of the second edition of Parallel Studio this month, I've spent a good amount of time with it, trying out the new features.

First, what's Parallel Studio? It's an add-in for Microsoft Visual Studio that gives you a large set of features for writing parallel code that targets multiple processor cores. It includes a new C++ compiler that gets run instead of the built-in Visual C++ compiler, allowing you to take advantage of several new features. Parallel Studio integrates with all the recent versions of Visual Studio: 2005, 2008, and 2010.

Parallel Studio 2011, which is the second version, is a significant improvement over the first version. The new features are:Cilk Plus: New C++ keywords (called Cilk Plus) that simplify the writing of parallel, threaded code.

BPP: Parallel Studio includes an entire template library called Parallel Building Blocks (PBB). PBB is built on Threading Building Blocks 3.0, an open-source threading library that was also created by Intel, along with Array Building Blocks. This threading library includes several classes that are similar to the ones in the standard C++ library, with the difference being they are totally thread-safe and will, when possible, run simultaneously on multiple cores. This takes away a lot of the hard work of programming for multiple threads, and that's one of the primary goals of Intel Parallel Studio 2011.

Intel Parallel Advisor: This is all new for 2011. (The earlier version included a "Lite" version.) The idea here is that you'll receive guidelines for developing parallel code. What I found impressive with Parallel Advisor is how smart it actually is. The idea is that it monitors your running program and finds places where you could benefit from parallelization. It includes a workflow window that takes you through the steps.

Test run through Parallel Advisor

The biggest improvement in version 2011 is with Parallel Advisor. This tool is pretty sweet. I took it through a test run to let it tell me where to add parallelism. Here it is analyzing the program: And here are the results, showing that the setQueen function is the bottleneck: And here's where it suggests adding parallelism: One question a lot of people have (including me) is this: Why does it analyze your running code and not the source code itself? The reason is that doing so provides far more accurate results. Analyzing source code can only go so far and would require some serious artificial intelligence to find ideal spots for parallelization. But by analyzing the running, the product can profile everything that's taking place, and actual determine in realtime where your program can benefit from parallelization.Pros and Cons People are often surprised at the gains in performance, but some feelings are positive and some are negative. For example, in one of the sessions at IDF, the Intel managers managed to speed up a sample application three times by dividing the work up on a quad-core processor. One person in the audience said he expected a much bigger difference, and I felt the same way. I think I was hoping to see double-digit or even 100-times improvements. However, the reality is that we were dealing with only four cores, and not everything can realistically be divided among the cores.

Perhaps one potential drawback is in the addition of three new keywords in C++. On one hand, these keywords greatly simplify the writing of parallel code. But the problem is you completely lose portability to other compilers. The reason this might be a problem is if you want to port your software to other platforms (such as handheld devices), then you might have problems. However, realistically, if you're porting to handheld devices, you'll probably be making lots of other changes to the code anyway, so having to work around these three keywords is probably the least of your problems. I would argue, then, that the additional keywords really aren't a big problem.

Conclusion
This is a fantastic product, and the new version adds some amazing tools that will hopefully get everybody thinking about targeting multiple cores with their software. There is, however, a learning curve involved in the product, and sometimes you might be disappointed with the performance increase. The price also might be a little prohibitive to individual developers, but larger software houses should have no problem affording it. The full product containing Advisor, Amplifier, Composer, and Inspector, $799. Or individual components $399 each. Free 30-day trial.