Data Race Atomic Operations

Hello,

I want to understand if data race condition is a bug in atomic operations.

Because: When using atomic operations, if "Data Race including atomic operations" is selected under Concurrency in the Bug Finder Analysis section, 'Data race ' error comes and Critical Protection is recommended to prevent it. should i follow it ?

Polyspace uses the Pointer size for your Target processor type as the threshold to compute atomicity.

If 'Data Race including atomic operations' is selected, analysis shows the error on var else it does not show. Ist it important the select this defect ?

int var;
void begin_critical_section(void);
void end_critical_section(void);

void increment(void) {
var++; 
}

void task1(void)  { 
increment();
}

void task2(void)  { 
increment();
}

void task3(void)  { 
begin_critical_section();
increment();
end_critical_section();
}

https://www.mathworks.com/help/bugfinder/ref/datarace.html?searchHighlight=data%20race%20including%20atomic&s_tid=srchtitle_data%2520race%2520including%2520atomic_1

you can see the example from the link

Answer 1

[Akshat Dalal]

Hi,

Data races occur when multiple threads access shared data at the same time, with at least one thread performing a write operation. This can lead to unpredictable behavior. While atomic operations are indivisible and prevent interference during their execution, they don't synchronize access between different threads, so data races can still occur without proper synchronization.

Critical sections are essential for ensuring mutual exclusion, allowing only one thread to execute a block of code at a time. This prevents data races by coordinating access to shared resources, which is crucial when atomic operations alone aren't enough to ensure synchronization.

Polyspace's "Data Race including atomic operations" setting is useful for identifying potential data races involving atomic operations. By enabling this option, you can detect areas where additional synchronization is necessary, highlighting where critical sections should be applied to prevent race conditions.

Following Polyspace's recommendations to use critical sections is advisable, even when operations are atomic. Critical sections protect the entire sequence of operations, preventing race conditions and maintaining data integrity, ensuring that concurrent processes do not interfere with each other.

In your example, `var++` is atomic, but tasks `task1` and `task2` can still cause data races if they run concurrently. `task3` uses critical sections around `increment()`, ensuring safe execution without interference. This practice helps avoid concurrency bugs and ensures robust, error-free programming.

Hope this helps!