Intel Software Network articles Feed

How to Implement Task Parallelism with Advisor

Fri, 24 Sep 2010 19:00:00 -0700

There are many different ways to add parallelism to an application. One of the most popular techniques is to parallelize the iterations of a loop, which is sometimes referred to as Data Parallelism. This method is thoroughly covered in the Advisor documentation, but it is not the only type of parallelism that can be added with the help of Advisor. Task Parallelism, sometimes referred to as function parallelism, in which multiple tasks/functions run in parallel can also be modeled by Advisor. Figure 1 shows a code snippet representing some basic statistical analysis:

Figure 1

This code is used to determine a running average and a running standard deviation on an array of values. Figure 2 shows the Survey Report created by Advisor.

Figure 2

This report shows that the majority of the time is being spent in two loops, one in the runningStdDev function and the other in the runningAvg function. If the source code was available for these functions, these loops would be good targets for Advisor annotations. However, it could be the case that these functions are in library code for which the source is not available. In this case, Advisor annotations can be used to model running both of these functions in parallel. Figure 3 shows how this would be done.

Figure 3

The suitability analysis of this parallel experiment is shown in Figure 4.

Figure 4

Figure 4 shows that there is substantial speedup available from running these two functions in parallel. It also shows that the speedup does not scale beyond two cores. This is understandable because there are only two tasks that will be executing at the same time.

While task parallelism may not be the most scalable form of parallelism, it can still add substantial performance improvements and may be available when data parallelism is not. Advisor annotations can be used to model task parallelism in an application in addition to data parallelism. The next step is to model Correctness with Advisor to make sure that no conflicts will arise from running both of these functions in parallel.

The Difference Between Advisor Survey and Amplifier Hotspots

Sun, 12 Sep 2010 19:00:00 -0700

Intel(R) Parallel Advisor 2011 (Advisor) and Intel(R) Parallel Amplifier 2011 (Amplifier) both provide tools to determine where time is spent in a running application. This is referred to as Survey in Advisor and Hotspots in Amplifier. The following list details similarities and differences between the two tools:

1. Both tools use the same low-overhead statistical sampling technology
2. Advisor Survey shows time spent in loops in addition to total time while Amplifier Hotspots does not
3. Advisor only provides a top-down call tree to help identify sites for parallelism, whereas Amplifier provides a top-down and bottom-up tree to help tune hot paths as well as individual functions
4. Advisor Survey is integrated into the Advisor Workflow

If you plan on using Advisor to help parallelize your existing application, it is recommended that you use Advisor Survey as the first step.

How to Use the Summary in Intel Parallel Advisor 2011 to Make Informed Decisions

Mon, 30 Aug 2010 21:00:00 -0700

In order to efficiently add parallelism to existing code, it is important to gather the best possible data about the application and use it to manage expectations and developer workloads intelligently. The Summary Report in Intel(r) Parallel Advisor 2011 (Advisor) provides this information in an easy-to-read format.

After profiling code with the Advisor's Survey tool, Figure 1 shows the breakdown of time spent in functions and loops in the application.

Figure 1

There are two loops in two different functions that are consuming most of the run time, chainedSeed() and orderedSeed(). Figure 2 shows the code for these functions.

Figure 2

Both functions are populating an array in a for loop whose iterations may be parallelizable. Figure 3 shows the functions after adding Advisor Annotations.

Figure 3
After Advisor Suitability and Correctness modeling tools have been run on the annotated code, the Summary Report (Figure 4) combines the information from both tools, to help users make informed decisions about how to proceed with parallelizing their code.

Figure 4

Figure 4 shows that both sites have the possibility of near-linear speedup on two cores (Maximum Self Gain = 1.99x). It also shows that the ChainedSeedSite has a correctness issue, while the OrderedSeedSite is free of correctness issues. The suitability and correctness data summarized here aid the decision making process when considering how to move forward with adding parallelism. Parallelizing both sites would improve speedup similarly. However, it may be less trouble to parallelize the OrderedSeedSite because there are no glaring correctness issues to fix. Having this program-wide performance and correctness information and using it properly, can greatly reduce wasted time and effort to parallelize code that is very difficult or almost impossible to thread.

1. By installing or copying all or any part of the software components in this site, you agree to the terms of the Intel Sample Source Code License Agreement.
2. By accessing and using the Intel Corporation Web Sites and Materials, you acknowledge and agree to abide by the following Terms of Use.

How to Find Promising Sites for Parallelism Using Intel® Parallel Advisor 2011

Sun, 29 Aug 2010 19:00:00 -0700

Intel® Parallel Advisor 2011 (Advisor) along with the other Intel® Parallel Studio 2011 tools lay out a multi-step process to aid developers in transitioning their serial code to efficient and correct parallel code. This article will focus on the first step of the process: How to determine where to add parallelism in an application.

Advisor provides an easy to use GUI interface as a plug-in to Microsoft® Visual Studio. The first step in using Advisor is to run the Survey tool, which will help determine where most of the time in the application is being spent. These “Hotspots” are good starting points when deciding where to add parallelism in an application. Figure 1 shows a screenshot of some profile data generated by Advisor on a K-Nearest Neighbors application.

Figure 1

Figure 1 shows that the majority of the program (59.3%) is spent in a function called std::::vector() and 20.9% in a loop in the method called KNN::distance. Navigating to the vector function reveals that it is part of the Standard Template Library (STL). The best return on investment will most likely be to focus on the KNN::distance method as opposed to the STL. With one mouse click, Advisor will automatically navigate to the source code (definition) of this method. Figure 2 shows the breakdown of time spent in KNN::distance.

Figure 2

Looking at this method, it can be seen that a single call should not take very long. It only calculates the distance between two points and it spends quite a bit of time returning the value in addition to the calculation.

If this was all the information that Advisor presented, it may be difficult to continue parallelizing because the bulk of the work doesn’t appear to be very conducive to parallelism. However, the Survey Report provides much more detailed information.

Figure 3

Figure 3 revels that the KNN::predict method is making calls to distance and the Survey Report also shows that these calls are made in the body of a loop (see the highlighted "loop" line).

This loop identifies another possible site for parallelism that still focuses on the Hotspots of the code. This site appears to be a loop with independent iterations (the execution of one iteration isn’t dependent on a previous iteration), which is a prime candidate for parallelization.

The way Advisor encourages the use of profile information can be very useful in uncovering the not-so-obvious locations where introducing parallelism may greatly improve performance. The Survey Report can present call path information that may reveal better locations to introduce parallelism while still focusing on the Hotspots. The timing breakdowns also reveal interesting characteristics about applications that may not be obvious, such as the heavy overhead of vector operations.

After locating ideal sites for parallelism, the next steps in the Advisor Workflow are to insert Advisor Annotations to gather Suitability and Correctness data about the proposed parallelism to determine the easiest and most efficient way to parallelize an application.