Reading and writing C ++ int Atomic?

Question

I have two threads, one of which updates int and one reads it. This is a statistical value in which the reading and writing order does not matter.

My question is: do I need to synchronize access to this multibyte value? Or, in another way, part of the record may be filled and interrupted, and then reading will occur.

For example, think of a value = 0x0000FFFF that gets an increased value of 0x00010000.

Is there a time when the value looks like 0x0001FFFF that I have to worry about? Of course, the larger the type, the more likely something like that.

I always synchronized these types of access, but I was curious what the community was thinking.

Answer 1

At first you might think that reading and writing the machine’s own size is atomic, but there are a number of problems related to cache coherency between processors / cores. Use atomic operations such as Interlocked * on Windows and the equivalent on Linux. C ++ 0x will have an “atomic” template to wrap them in a nice and cross-platform interface. At the moment, if you use the platform abstraction layer, this can provide these functions. ACE , see class template ACE_Atomic_Op .

Answer 2

Boy, what a question. The answer to which:

Yes, no, hmm, well, it depends

It all comes down to the system architecture. On IA32, a correctly aligned address will be an atomic operation. Unexpressed entries can be atomic, it depends on the caching system used. If the memory is in the same line of the L1 cache, then it is atomic, otherwise it is not. The width of the bus between the processor and RAM can affect the atomic nature: a correctly aligned 16-bit record on 8086 was atomic, while the same record on 8088 was not because 8088 had only an 8-bit bus, while 8086 was 16- bit bus.

In addition, if you use C / C ++, do not forget to mark the general value as volatile, otherwise the optimizer will assume that the variable is never updated in one of your threads.

Answer 3

IF you read / write a 4-byte value AND it is DWORD-aligned in memory AND you work in the I32 architecture, THEN the read and write are atomic.

Answer 4

Yes, you need to synchronize calls. In C ++ 0x this will be data race and undefined behavior. With POSIX streams, this already works undefined.

In practice, you can get bad values ​​if the data type is larger than the native word size. In addition, in another thread, the value recorded due to optimizations moving the read and / or write will never be visible.

Answer 5

You have to synchronize, but on some architectures there are effective ways to do this.

It is best to use routines (possibly disguised as macros) so that you can conditionally replace implementations with platform ones.

The Linux kernel already has some code.

Answer 6

On Windows, *** Exchange *** lock *** Add is guaranteed to be atomic.

Answer 7

To repeat what everyone said above, the pre-C ++ 0x language cannot guarantee anything about accessing shared memory from multiple threads. Any guarantees will be up to the compiler.

Answer 8

No, they are not (or at least you cannot assume that they are). Having said that, there are some tricks to do this atomically, but they are usually not portable (see Compare-and-swap ).

Answer 9

I agree with many, and especially Jason . In the windows you can use InterlockedAdd and his friends.

Answer 10

Pay attention to the cache problem mentioned above ...

If you transfer code to a processor with a smaller register size, it will no longer be atomic.

IMO, threading problems are too complex to take risks.

Answer 11

Let's look at this example.

int x; x++; x=x+5; 

The first statement is considered atomic because it is converted to a single INC assembly directive, which takes one CPU cycle. However, the second assignment requires several operations, so this is clearly not an atomic operation.

Another for example

 x=5; 

Again, you need to parse the code to see what exactly is happening here.

Answer 12

T, I think that at that moment when you use a constant (for example, 6), the instruction will not be completed within one machine cycle. Try to see the x + = 6 instruction set compared to x ++

Answer 13

Some people think ++ c is atomic, but watch out for the assembly you created. For example, using "gcc -S":

 movl cpt.1586(%rip), %eax addl $1, %eax movl %eax, cpt.1586(%rip) 

To increment an int, the compiler first loads it into a register and saves it back to memory. It is not atomic.

Answer 14

Finally, NO! This answer is from our top authority C ++, M. Boost:
Operations with "ordinary" variables are not guaranteed to be atomic.

Answer 15

The only portable way is to use the sig_atomic_t type defined in the signal.h header for your compiler. In most C and C ++ implementations, this is int. Then declare the variable as "volatile sig_atomic_t."