CON42-C. Ensure that compound operations on shared variables are atomic

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 |=. 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 flag variable and provides a toggle_flag() method that negates the current value of flag.

static bool flag = false;
 
void toggle_flag() {
  flag = !flag;
}
 
_Bool get_flag() {
  return flag;
}

Execution of this code may result in a data race because the value of flag 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:

As a result, the effect of the call by t₂ 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.

static bool flag = false;
 
void toggle_flag() {
  flag ^= 1;
}
 
_Bool get_flag() {
  return flag;
}

Compliant Solution (Mutex)

This compliant solution restricts access to flag under a mutex lock.

static bool flag = false;
mtx_t flag_mutex;
int result;

/* initialize flag_mutex */
if ((result = mtx_init(&flag_mutex, mtx_plain)) == thrd_error) {
  /* handle error */
}
 
void toggle_flag() {
  if ((result = mtx_lock(&flag_mutex)) != thrd_success) {
    /* handle error */
  }
  flag ^= 1;
  if ((result = mtx_unlock(&flag_mutex)) != thrd_success) {
    /* handle error */
  }
}
 
_Bool get_flag() {
  _Bool temp_flag;
  if ((result = mtx_lock(&flag_mutex)) != thrd_success) {
    /* handle error */
  }
  temp_flag = flag;
  if ((result = mtx_unlock(&flag_mutex)) != thrd_success) {
    /* handle error */
  }
  return temp_flag;
}

The second execution order involves the same operations, but t₂ starts and finishes before t₁.  

Noncompliant Code Example (atomic boolean)

This noncompliant code example declares flag to be of type _Atomic _Bool.

static _Atomic bool flag;

atomic_init(&flag, false);


void toggle_flag() {
  _Bool temp_flag = atomic_load(&flag);
  temp_flag = !temp_flag;
  atomic_store( &flag, temp_flag);
}
  
_Bool get_flag() {
  return atomic_load(&flag);
}

Compliant Solution (atomic_compare_exchange_weak())

This compliant solution uses a compare and exchange to guarantee that the correct value is stored in flag. All updates are visible to other threads.

static _Atomic bool flag;

atomic_init(&flag, false);


void toggle_flag() {
  _Bool old_flag = atomic_load(&flag);
  _Bool new_flag;
  do {
    new_flag = !old_flag;
  } while (!atomic_compare_exchange_weak(&flag, &old_flag, new_flag));
}
  
_Bool get_flag() {
  return atomic_load(&flag);
}

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 INT32-C. Ensure that operations on signed integers do not result in overflow for more information.)

static int a;
static int b;
 
int get_sum() {
  return a + b;
}
 
void set_values(int new_a, int new_b) {
  a = new_a;
  b = new_b;
}

Noncompliant Code Example (Addition of Atomic Integers)

In this noncompliant code example, a and b are replaced with atomic integers.

static _Atomic int a;
static _Atomic int b;

atomic_init(&a, 0);
atomic_init(&b, 0);


int get_sum() {
  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.

Compliant Solution (Addition)

This compliant solution protects the set_values() and get_sum() methods with a mutex to ensure atomicity.

static _Atomic int a;
static _Atomic int b;
mtx_t flag_mutex;
int result;

/* initialize everything */
atomic_init(&a, 0);
atomic_init(&b, 0);
if ((result = mtx_init(&flag_mutex, mtx_plain)) == thrd_error) {
  /* handle error */
}

 
int get_sum() {
  if ((result = mtx_lock(&flag_mutex)) != thrd_success) {
    /* handle error */
  }
  int sum = atomic_load(&a) + atomic_load(&b);
  if ((result = mtx_unlock(&flag_mutex)) != thrd_success) {
    /* handle error */
  }
  return sum;
}
 
void set_values(int new_a, int new_b) {
  if ((result = mtx_lock(&flag_mutex)) != thrd_success) {
    /* handle error */
  }
  atomic_store(&a, new_a);
  atomic_store(&b, new_b);
  if ((result = mtx_unlock(&flag_mutex)) != thrd_success) {
    /* handle error */
  }
}

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.

Related Guidelines

Bibliography