UNIX Portable Atomic Operations

Question

Is there a (POSIX-)portable way in C for atomic variable operations similar to a portable threading with pthread?

Atomic operations are operations like "increment and get" that are executed atomically that means that no context switch can interfere with the operation. In Linux kernel space, we have to atomic_t type, in Java we have the java.util.concurrent.atomic package.

On Linux, the atomic.h file provides atomic operations, but the include is platform dependent e.g. #include <asm-x86_64/atomic.h> and it is not available on Mac OS X in a similar way.

There are some GCC built-ins, [described here](http://gcc.gnu.org/onlinedocs/gcc-4.5.0/gcc/Atomic-Builtins.html). — caf, Jul 15 '09 at 08:09
and here for newer gcc: http://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html — osgx, Nov 24 '11 at 00:18

score 14 · Answer 1 · answered Nov 25 '13 at 20:11

14

For anyone who stumbles upon this in the future, C11 atomics are the best way to do this now - I believe they will be included in GCC 4.9.

answered Nov 25 '13 at 20:11

user3033869

149
1
2

15

Can you expand on this? – GraphicsMuncher Nov 25 '13 at 20:30
Minimal runnable C11 atomics + threads example: https://stackoverflow.com/questions/1130018/unix-portable-atomic-operations/54680209#54680209 – Ciro Santilli OurBigBook.com Feb 13 '19 at 22:08

score 14 · Accepted Answer · edited Dec 17 '17 at 18:22

As of C11 there is an optional Atomic library which provides atomic operations. This is portable to whatever platform that has a C11 compiler (like gcc-4.9) with this optional feature.

The presence of the atomic can be checked with __STDC_NO_ATOMICS__and the presence of <stdatomic.h>

atomic.c

#include <stdio.h>
#include <stdlib.h>
#ifndef __STDC_NO_ATOMICS__
#include <stdatomic.h>
#endif

int main(int argc, char**argv) {
    _Atomic int a;
    atomic_init(&a, 42);
    atomic_store(&a, 5);
    int b = atomic_load(&a);
    printf("b = %i\n", b);

    return EXIT_SUCCESS;
}

Compiler invocations

clang -std=c11 atomic.c
gcc -std=c11 atomic.c

score 11 · Answer 3 · answered Sep 07 '10 at 15:36

Since you asked for OS X:

(and since cross platformity was raised in this thread.)

OS X has functions OSAtomicAdd32() and friends. They are declared in "/usr/include/libkern/OSAtomic.h". See The Threading Programming guide, section "Using Atomic Operations".

And for Windows, there is InterlockedIncrement() and friends (see MSDN).

Together with the gcc builtins __sync_fetch_and_add() and friends (has been linked above), you should have something for every main desktop platform.

Please note that I did not yet use them by myself, but maybe will do so in the next few days.

score 5 · Answer 4 · answered Jul 15 '09 at 08:31

5

No, POSIX does not specify any portable lock-free/atomic operations. That's why they have pthreads.

You're either going to have to use non-standard ways or stick with ptrheads for portability.

answered Jul 15 '09 at 08:31

paxdiablo

854,327
234
1,573
1,953

Ciro Santilli OurBigBook.com · Answer 5 · 2019-05-21T15:35:18.057

C11 atomics minimal runnable example

With the addition of threads in glibc 2.28, we can do both atomics and threading in pure C11.

Example from: https://en.cppreference.com/w/c/language/atomic

main.c

#include <stdio.h>
#include <threads.h>
#include <stdatomic.h>

atomic_int acnt;
int cnt;

int f(void* thr_data)
{
    for(int n = 0; n < 1000; ++n) {
        ++cnt;
        ++acnt;
        // for this example, relaxed memory order is sufficient, e.g.
        // atomic_fetch_add_explicit(&acnt, 1, memory_order_relaxed);
    }
    return 0;
}

int main(void)
{
    thrd_t thr[10];
    for(int n = 0; n < 10; ++n)
        thrd_create(&thr[n], f, NULL);
    for(int n = 0; n < 10; ++n)
        thrd_join(thr[n], NULL);

    printf("The atomic counter is %u\n", acnt);
    printf("The non-atomic counter is %u\n", cnt);
}

Compile and run:

gcc -std=c11 main.c -pthread
./a.out

Possible output:

The atomic counter is 10000
The non-atomic counter is 8644

The non-atomic counter is very likely to be smaller than the atomic one due to racy access across threads to the non atomic variable.

A pthreads example can be found at: How do I start threads in plain C?

Tested in Ubuntu 18.04 (glibc 2.27) by compiling glibc from source: Multiple glibc libraries on a single host Ubuntu 18.10 has glibc 2.28 so things should just work there.

But in case we stuck with glibc 2.27 would stdatomic work with `pthreads`? — Some Name, Apr 08 '19 at 18:52

score 0 · Answer 6 · answered Jul 15 '09 at 08:01

0

AFAIK there are no cross-platform ways to do atomic operations. There may be a library out there but I don't know of. Its not particularly hard to roll your own, though.

answered Jul 15 '09 at 08:01

Goz

61,365
24
124
204

score 0 · Answer 7 · answered Jul 15 '09 at 08:04

I don't think there is.

One way of solving it, licenses permitting of course, would be to copy the relevant per-architecture implementations from e.g. the Linux kernel space. I haven't followed the evolution of those primitives closely, but I would guess that they are indeed primitives, i.e. don't depend upon other services or APIs in the kernel.

UNIX Portable Atomic Operations

7 Answers7

Linked