Compound operations are operations that consist of more than one discrete operation. Expressions that include postfix or prefix increment (++
), postfix or prefix decrement (--
), or compound assignment operators always result in compound operations. Compound assignment expressions use operators such as *=
, /=
, %=
, +=
, -=
, <<=
, >>=
, ^=
and , and |=
. Compound operations on shared variables must be performed atomically to prevent data races.
Noncompliant Code Example (Logical Negation)
This noncompliant code example declares a shared _
Bool
Bool
flag
variable and provides a toggle_flag()
method that negates the current value of flag
.: #ffcccclanguage | cpp |
---|
|
#include <stdbool.h>
static |
_Bool0false;
void toggle_flag(void) {
flag = !flag;
}
|
_Boolbool get_flag(void) {
return flag;
} |
Execution of this code may result in a data race because because the value of of flag
is is read, negated, and written back.
Consider, for example, two threads that call toggle_flag()
. The expected effect of toggling flag
twice is that it is restored to its original value. However, the following scenario leaves flag
in the incorrect state:
reads Reads the current value of flag , true , into a cache |
2 | true
| t 2 |
reads Reads the current value of flag , (still) true , into a different cache |
3 | true
| t 1 |
toggles Toggles the temporary variable in the cache to false |
4 | true
| t 2 |
toggles Toggles the temporary variable in the different cache to false |
5 | false
| t 1 |
writes Writes the cache variable's value to flag |
6 | false
| t 2 |
writes Writes the different cache variable's value to flag |
As a result, the effect of the call by t 2 is not reflected in flag
; the program behaves as if toggle_flag()
was called only once, not twice.
Noncompliant Code Example (Bitwise Negation)
The toggle_flag()
method may also use the compound assignment operator ^=
to negate the current value of flag
.
Code Block |
---|
|
static _Bool flag = 0;
void toggle_flag() {
flag ^= 1;
}
_Bool get_flag() {
return flag;
}
|
This code is also not thread-safe. A data race exists because ^=
is a nonatomic compound operation.
Compliant Solution (Mutex)
This compliant solution restricts access to flag
under a mutex lock.
:
Code Block |
---|
|
#include <threads.h>
#include <stdbool.h>
static |
_Bool0int result;
/* Initialize flag_mutex */
bool init_mutex(int type) {
/* |
initializeflag_(resultthrd_success != mtx_init(&flag_mutex, |
mtx_plain == thrd_error) {
handleReport error */
}
return true;
}
void toggle_flag(void) {
|
intresult;
(resultthrd_success != mtx_lock(&flag_mutex)) |
!= thrd_success) handle^1(resultthrd_success != mtx_unlock(&flag_mutex) |
) != thrd_successhandle_Boolint result;
_Bool (resultthrd_success != mtx_lock(&flag_mutex) |
) != thrd_successhandleHandle error */
}
temp_flag = flag;
if ( |
(resultthrd_success != mtx_unlock(&flag_mutex) |
) != thrd_successhandleHandle error */
}
return temp_flag;
} |
This solution guards reads and writes to
the the flag
field field with a lock on the flag_mutex
. This lock ensures that changes to flag
are visible to all threads. Now, only two execution orders are possible
, one of which is shown in the following scenario. In one execution order, t1 obtains the mutex and completes the operation before t 2 can acquire the mutex, as shown here:
reads Reads the current value of flag , true , into a cache variable |
2 | true
| t 1 |
toggles Toggles the cache variable to false |
3 | false
| t 1 |
writes Writes the cache variable's value to flag |
4 | false
| t 2 |
reads Reads the current value of flag , false , into a different cache variable |
5 | false
| t 2 |
toggles Toggles the different cache variable to true |
6 | true
| t 2 |
writes Writes the different cache variable's value to flag |
The second other execution order involves the same operations, but is similar, except that t 2 starts and finishes before t 1.
Noncompliant Code Example Compliant Solution (atomic
boolean)This noncompliant code example declares flag
to be of type _Atomic _Bool
.
_compare_exchange_weak()
)
This compliant solution uses atomic variables and a compare-and-exchange operation to guarantee that the correct value is stored in flag
. All updates are visible to other threads.
#ffccccstatic _Atomic _Bool flag = 0;
void toggle_flag() {
_Bool temp_flag = atomic_load(&flag);
temp_flag = !temp_flag;
atomic_store( &flag, temp_flag);
}
_Bool get_flag(#include <stdatomic.h>
#include <stdbool.h>
static atomic_bool flag;
void init_flag(void) {
|
return loadThis code suffers from the same potential race condition as the first noncompliant code example.
Compliant Solution (atomic boolean)
This compliant solution declares flag
to be of type _Atomic _Bool
.
Code Block |
---|
|
static _Atomic _Bool flag = 0;
void toggle_flag(void) {
_Boolbool old_flag = atomic_load(&flag);
_Boolbool new_flag;
do {
new_flag = !old_flag;
} while (!atomic_compare_exchange_weak(&flag, &old_flag, new_flag));
}
_Boolbool get_flag(void) {
return atomic_load(&flag);
}
|
The flag
variable is updated using the atomic_compare_exchange_weak()
function on the atomic boolean variable. All updates are visible to other threads.
An alternate An alternative solution is to use the atomic_flag
datatype data type for managing
boolean Boolean values atomically.
Noncompliant Code Example (Addition of Primitives)
In this noncompliant code example, multiple threads can invoke the set_values()
method to set the a
and b
fields. Because this code fails to test for integer overflow, users of this code must also ensure that the arguments to the set_values()
method can be added without overflow . (See rule see INT32-C. Ensure that operations on signed integers do not result in overflow for more information).)
#ffcccc |
static int a;
static int b;
int get_sum(void) {
return a + b;
}
void set_values(int new_a, int new_b) {
a = new_a;
b = new_b;
} |
The get_sum()
method contains a race condition. For example, when a
and b
currently have the values 0
and INT_MAX
, respectively, and one thread calls get_sum()
while another calls set_values(INT_MAX, 0)
, the get_sum()
method might return either 0
or INT_MAX
, or it might overflow. Overflow will occur when the first thread reads a
and b
after the second thread has set the value of a
to INT_MAX
, but before it has set the value of b
to 0
.
Noncompliant Code Example (Addition of Atomic Integers)
In this noncompliant code example, a
and and b
are are replaced with atomic integers.
#ffcccc |
#include <stdatomic.h>
static atomic_ |
Atomic Atomic int b;
void init_ab(void) {
atomic_init(&a, 0);
atomic_init(&b, 0);
}
int get_sum(void) {
return atomic_load(&a) + atomic_load(&b);
}
void set_values(int new_a, int new_b) {
atomic_store(&a, new_a);
atomic_store(&b, new_b);
} |
The simple replacement of the two int
fields with atomic integers fails to eliminate the race condition in the sum because the compound operation a.get() + b.get()
is still non-atomic. While a sum of some value of a
and some value of b
will be returned, there is no guarantee that this value represents the sum of the values of a
and b
at any particular moment.
Compliant Solution (_Atomic struct
)
This compliant solution uses an atomic struct, which guarantees that both numbers are read and written together.
Code Block |
---|
|
#include <stdatomic.h>
static _Atomic struct ab_s {
int a, b;
} ab;
void init_ab(void) {
struct ab_s new_ab = {0, 0};
atomic_init(&ab, new_ab);
}
int get_sum(void) {
struct ab_s new_ab = atomic_load(&ab);
return new_ab.a + new_ab.b;
}
void set_values(int new_a, int new_b) {
struct ab_s new_ab = {new_a, new_b};
atomic_store(&ab, new_ab);
} |
On most modern platforms, this will compile to be lock-free.
Compliant Solution (
AdditionMutex)
This compliant solution synchronizes the protects the set_values()
and and get_sum()
methods methods with a mutex to ensure atomicity.:
Code Block |
---|
|
#include <threads.h>
#include <stdbool.h>
static |
_Atomic _Atomicint result;
/* Initialize everything */
bool init_all(int type) {
/* |
initializeflag_mutex type */
a = 0;
b = 0;
if ( |
(resultthrd_success != mtx_init(&flag_mutex, |
mtx_plain== thrd_error) {
handleReport error */
}
return true;
}
int get_sum(void) { |
int result;(resultthrd_success != mtx_lock(&flag_mutex)) |
!=thrd_success) handleHandle error */
}
int sum = |
atomic_load(&)atomic_load(&)(resultthrd_success != mtx_unlock(&flag_mutex)) |
!=thrd_success) handleHandle error */
}
return sum;
}
void set_values(int new_a, int new_b) { |
int result;(resultthrd_success != mtx_lock(&flag_mutex)) |
!=thrd_success) handleatomic_store(&a,)atomic_store(&b,)(resultthrd_success != mtx_unlock(&flag_mutex) |
) != thrd_successhandle
Thanks to the mutex, it is now possible to add overflow checking to the get_sum()
function without introducing the possibility of a race condition.
Risk Assessment
When operations on shared variables are not atomic, unexpected results can be produced. For example, information can be disclosed inadvertently because one user can receive information about other users.
CON42mediumprobablemedium Automated Detection
Tool | Version | Checker | Description |
---|
CodeSonar | | CONCURRENCY.DATARACE | Data Race |
Bibliography
Image Added
|
Image Removed Image Removed Image RemovedImage Added Image Added