CERT C++: CON41-C

Function that can spuriously fail not wrapped in loop occurs when the following atomic compare and exchange functions that can fail spuriously are called from outside a loop.

The functions compare the memory contents of the object representations pointed to by obj and expected. The comparison can spuriously return false even if the memory contents are equal. This spurious failure makes the functions faster on some platforms.

An atomic compare and exchange function that spuriously fails can cause unexpected results and unexpected control flow.

Wrap atomic compare and exchange functions that can spuriously fail in a loop. The loop checks the failure condition after a possible spurious failure.

#include <atomic>
#include <stdbool.h>
using namespace std;
static atomic<bool> flag(false);
void toggle_flag(void)
{
	bool old_flag = atomic_load(&flag);
	bool new_flag;
	if (!atomic_compare_exchange_weak(&flag, &old_flag, new_flag)){//Noncompliant
		new_flag = !old_flag;
	}

}

bool get_flag(void)
{
	return atomic_load(&flag);
}

In this example, the functiontoggle_flag uses atomic_compare_exchange_weak() to compare flag and old_flag. If the variables are identical, flag is toggles to new_flag. When atomic_compare_exchange_weak() fails spuriously, the flag is toggled unnecessarily.

One possible correction is to wrap the call to atomic_compare_exchange_weak() in a while loop. The loop checks the failure condition after a possible spurious failure.

#include <atomic>
#include <stdbool.h>
using namespace std;
static atomic<bool> flag(false);


void toggle_flag(void)
{
  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(void)
{
    return atomic_load(&flag);
}