Cfrgtkky

I have 2 atomic variables:

atomic_ulong overwrap_cnt = 0;

atomic_ulong overwrap_read_cnt = 0;

One thread does the increasing of overwrap_cnt (once):

overwrap_cnt++;

Another thread does the comparison in an endless loop:

while(1)

{

 if (overwrap_read_cnt == overwrap_cnt)

 {

  printf("or:%lu, ow:%lu n",overwrap_read_cnt, overwrap_cnt);

 }

 usleep(100000);

}

However, the result is always the following:

or:0, ow:1

or:0, ow:1

or:0, ow:1

Somehow during the comparison the variables were equal, but when we printf them - we see that they are different. The result is the same for every iteration.

Can't I compare atomic variables like this? Or what is wrong?

It's on centos 7.5 with gcc (GCC) 4.9.2 20150212 (Red Hat 4.9.2-6)

Thanks.

Although the variables are individually atomic, your comparison loop is not. Perhaps counter-intuitively, reading an atomic variable may generate more instructions than reading a non-atomic.

Consider for example if you had written code with the same behavior using GCC's atomic builtins:

while(1)

{

  unsigned long _tmp1 = __atomic_load_n(&overwrap_read_cnt, __ATOMIC_RELAXED);

  unsigned long _tmp2 = __atomic_load_n(&overwrap_cnt, __ATOMIC_RELAXED);

  if (_tmp1 == _tmp2)

  {

    _tmp2 = __atomic_load_n(&overwrap_cnt, __ATOMIC_RELAXED);

    _tmp1 = __atomic_load_n(&overwrap_read_cnt, __ATOMIC_RELAXED);

    printf("or:%lu, ow:%lu n", _tmp1, _tmp2);

  }

  usleep(100000);

}

Although the values fetched for the comparison were determined to be equal, they may no longer be at the time they're fetched again for the printf call.

If you want to ensure the values used later are the same as those in the if statement, you should fetch them only once, and then use the cached values throughout the rest of the loop iteration.