User Guide

Contents

Verify Whether Incidental Sharing Exists

Sharing is incidental only if the task writes to the memory location before any read of the memory location
anywhere in the dynamic extent of the task
. This is easy to check when the task is a few lines of code in a single function. It is much harder when the task is hundreds or thousands of lines of code, and involves calls to many functions in many source files.
Even worse, the sharing is not incidental if any code that might execute after the task completes, or in any other task that might run at the same time as the task, could read a value written by the task to that memory location.
There is no "magic bullet" to prove that the requirements are met, but there is a simple technique that you might find useful. Add statements that write a known bad value into the memory location immediately after the
ANNOTATE_ITERATION_TASK(taskname);
, and then test your serial program. If the sharing is incidental, these assignments will have no effect. If  not, there is a good chance that the changes will change the program behavior. Of course, the effectiveness of this technique depends on how good your test system is at detecting the resulting bugs.
For example, if you want to confirm that the variable
x
is incidentally shared in
the_task()
:
extern int x; // ... ANNOTATE_SITE_BEGIN(site1); for (i = 0; i != n; ++i) {     ANNOTATE_ITERATION_TASK(task1);     x = 0xdeadbeef;     the_task();     x = 0xdeadbeef; } ANNOTATE_SITE_BEGIN();
To identify stray memory references, consider using the C/C++ special-purpose annotations
ANNOTATE_OBSERVE_USES()
and
ANNOTATE_CLEAR_USES()
.

Product and Performance Information

1

Performance varies by use, configuration and other factors. Learn more at www.Intel.com/PerformanceIndex.