在uint8_t（C）中以原子方式存储值

Question

Let's assume we have a C structure that contains a uint8_t field:

typedef struct foo_s {
  uint8_t field;
  // other fields...
} foo_t;

If we want to atomically store a value in field using a particular memory order, what are the possibilities within the C language? From what I researched

• The C11 standard does not allow atomic stores ( atomic_store_explicit ) in non-atomic integer types. On top of that, there is no atomic integer type in the standard that is guaranteed to have a width of one byte.
• Another possibility (within C11) is to use a memory fence ( atomic_thread_fence ) and then store the value in field . But the standard requires this store to be atomic for the fence to work as intended, so we go back to the issue described in the previous item.

So the solution to our problem seems to be out of the C standard...is there any commonly used mechanism for atomically storing a byte?

Please note that we cannot change the type of field , since it belongs to a third-party library.

Answer 1

In GCC, the atomic store asked for can be achieved using __atomic_store_n , which is included in the Atomics extension and does work at the level of granularity of a byte. The GCC documentation for atomic builtins states that "GCC allows any integral scalar or pointer type that is 1, 2, 4, or 8 bytes in length". A peek at the implementation reveals that the HW store works at 4-byte granularity, but the SW will emulate byte stores by using compare and swap operations (ie, making sure that concurrent modifications to any other byte in the word are not lost).

My understanding is that the atomic modification works in any integer variable such as field - there is no need to change its type or modifiers.

Answer 2

It is not portable, due to endianess and perhaps alignment concerns, but you could alias another union structure to the foo_t structure. The alias union structure would have an atomic-sized field that overlaps the entire uint8_t field . Now you can update the overlapping field atomically. Since it overlaps the field, that will also be updated atomically.

By alias union structure I mean

typedef union alias_foo_u
{
    foo_t orig_foo;
    struct alias_foo_s
    {
        atomic_t field_overlap;
        ...
    } alias_foo;
} alias_foo_t;