Minimizing Data Collection, Result Size, and Execution Time (Dependencies)

Using Pause or Stop Buttons to Minimize Data Collection

After you initiate data collection with the button under Check Dependencies in the Advisor Workflow tab, you can click the nearby button to pause data collection. To continue the collection, use the button.

Click the button under Check Dependencies in the Advisor Workflow tab to stop data collection, finalize, and display the partially collected data. You might click this button if you already see many types of problems reported during collection and do not wish to wait for additional analysis to occur.

Using Pause Collection and Resume Collection Annotations to Minimize Data Collection

The Dependencies tool recognizes all annotations, including:

• Pause Collection: Stops data collection to skip uninteresting parts of the target program's execution. This minimizes the data collected, speeds up the analysis of medium-large applications, and minimizes execution time.

• Resume Collection: Resumes data collection previously paused to collect data about the interesting parts of your program.

Place Pause Collection and Resume Collection annotations outside the parallel site code regions, which are defined by parallel site begin and parallel site end annotations.

Reducing the Input Data Set with Adequate Code Coverage in Parallel Sites

When you run your program with the Dependencies tool, it is very important that you choose appropriate input data for the specified parallel sites. There are two concerns:

• Execution time: Running the Dependencies tool is expensive. A program may take 50 to hundreds of times longer to run than it does normally. For example, if you run your program with an input data set that would normally take 25 minutes to process, the Dependencies tool may take a day or more to run your program. The Dependencies tool only collects data as it executes within the selected loop or site. To minimize increased program run times, choose input data sets that minimize the number of instructions executed within a parallel site while thoroughly exercising your program's control flow paths. For example, the same data sharing problem will be detected whether you execute a loop once or a million times - but executing a loop a million times takes much longer.

• Code coverage: It is even more important to choose input data that will cause most of the code within the loop or parallel sites to be executed with the same sort of control flow as when it is processing real data. The Dependencies tool is an excellent tool, but it is not magic. The only information that Intel Advisor has about your program comes from watching the data accessed by the code executed within loops or sites, including interleaved parallel operations within parallel tasks. It can find potential conflicts, but only between operations that are executed.

For example, consider this code:

int best_thing(thing *array, int size)
{
    int best = array[0];
    ANNOTATE_SITE_BEGIN(site_array);
    for (int i = 1; i < size; ++i) {
        ANNOTATE_ITERATION_TASK(task_array);
        if (better(array[i], array[best])) best = array[i];
    }
    ANNOTATE_SITE_END();
    return best;
}

This code has a potential conflict between the write to best in one task and the write to best in any other task, and a potential conflict between the read of best in one task and the write to best in any other task. Intel Advisor will report these conflicts - if the write to best is executed.

But what will happen if, with the input data provided for the Dependencies tool run, the first thing in the array is the best thing? In that case, there will be no writes to best executed in any iteration of the loop. Since the Dependencies tool will not see any writes to best, it will not be able to report the potential conflicts.

So, you should choose input data for your Dependencies run that will thoroughly exercise your program's control flow paths, but will not make your program run any longer than necessary.