What is data object access

Why is a program with only Atomics in SC-DRF but not in HRF-direct?

Hopefully they didn't say exactly, "A program that consists only of atomics is racial in SC-DRF." This is wrong

They say that "[in] Scoped Synchronization ... it is possible to write a Racey program made entirely of Atomics if those Atomics do not use Scopes properly" [top of page 2], which is a little different ( and uses the word "Racey" ambiguously, which may lead you to believe that you meant the wrong statement.) You should perhaps have said that scoped sync can do one instead not sequentially consistent Writing a program made entirely of atomics if those atomics are not using the ranges properly.

SC-DRF (roughly: the memory semantics for C ++ and Java) divide memory space into two classes, Synchronization objects, (sometimes called) and data objects. For the most part, it is guaranteed that all operations on synchronization objects are sequentially consistent . [1] ( Not run-free.) This is a limitation on the compiler, not the programmer. It is said that when the programmer says that a thread is writing an atomic object, then it is writing an atomic object, allThe writes are carried out in the threads in this order. (The compiler is not allowed to rearrange the accesses and must put the appropriate memory barriers and fences on computers that are not sequentially consistent.)

Sequentially consistent means that all threads on all processors agree on an overall order of all memory operations. When a thread believes the operation before the surgery has taken place , think all Threads that operation before the surgery has taken place . Sequentially consistent does not mean not racy and it doesn't mean deterministic . For example, two different threads could try to write the same synchronization variable at about the same time. These hits will be racing. A sequentially consistent system only guarantees that if a thread thinks that the write occurred before the write xyxyxy, all Threads agree that writing occurred before writing. Sequential consistency is useful because it allows you to create and justify useful nondeterministic synchronization objects such as mutexes and condition variables xy

SC-DRF then says that, if Your program Data Run free, the operations on Data become objects displayed become sequentially consistent . The compiler is allow reordering (or sometimes even eliminate) operations on data objects, and if the underlying machine is not sequentially consistent, the compiler will not need to insert memory barriers or fences. But the compiler Not to reorder operations on data objects in relation to operations on synchronization objects allowed.

Data Race Free is not the same as Race Free . And sequentially consistent is not the same as run free . A special program execution plan is Data If running free, if for each pair of data object accesses, and coming from two different threads (at least one of which is a write operation) we can use the (sequentially consistent) order of ordering object accesses to prove that either in front or in front has happened . If we don't have the proof provide can is this execution plan data racial .xyxyyx

A program is Free of Data races when all possible execution plans are free of data races. A program is data dependent, when there is an execution plan that is data dependent.

Data race to be free, is a limitation for the programmer, not the compiler. It is said that if your program is data-racial, your program has no semantics. The compiler can do anything it wants, including stopping the program, going into an infinite loop, or blowing the computer up.

Oh man. TL; DR! I haven't even mentioned SC-for-HRC!

In SC-for-HRC, the atomics must indicate to which Area you belong. Atomic accesses are guaranteed (by the compiler) that they are only sequentially consistent within their own area. All threads within the scope are the same in the order in which atomic accesses are made, but threads in a different scope may be the same Not match (and may not be able to see the accesses at all, let alone their order).

For example, all GPU threads might match that thread 19 acquired Mutex A and then Mutex B, but all CPU threads Not Agree (or know) that Thread 19 acquired Mutex A or Mutex B in the first place. SC-DRF has no "ranges", so this problem does not occur.

[1] The exceptions to the sequentially consistent atomics have to do with the explicit use. So don't do that. (And I'll ignore the exceptions in the rest of what I say.)