¿Es correcta esta implementación de C ++ AtomicInt?

Premisa: estoy trabajando con un entorno ARM integrado (casi desnudo) donde ni siquiera tengo C ++ 11 (con std::atomic<int>) disponible, así que evite respuestas como " solo use C ++ estándarstd::atomic<int> ": no puedo .

¿Es correcta esta implementación ARM de AtomicInt? (suponga que la arquitectura ARM es ARMv7-A )

¿Ves algún problema de sincronización? ¿Es volatilerequerido / útil?

// File: atomic_int.h

#ifndef ATOMIC_INT_H_
#define ATOMIC_INT_H_

#include <stdint.h>

class AtomicInt
{
public:
    AtomicInt(int32_t init = 0) : atom(init) { }
    ~AtomicInt() {}

    int32_t add(int32_t value); // Implement 'add' method in platform-specific file

    int32_t sub(int32_t value) { return add(-value); }
    int32_t inc(void)          { return add(1);      }
    int32_t dec(void)          { return add(-1);     }

private:
    volatile int32_t atom;
};

#endif

// File: arm/atomic_int.cpp

#include "atomic_int.h"

int32_t AtomicInt::add(int32_t value)
{
    int32_t res, prev, tmp;

    asm volatile(

    "try:    ldrex   %1, [%3]\n"     // prev = atom;
    "        add     %0, %1, %4\n"   // res = prev + value;
    "        strex   %2, %0, [%3]\n" // tmp = outcome(atom = res); // may fail
    "        teq     %2, #0\n"       // if (tmp)
    "        bne     try"            //     goto try; /* add failed: someone else modified atom -> retry */

    : "=&r" (res), "=&r" (prev), "=&r" (tmp), "+mo" (atom)  // output (atom is both in-out)
    : "r" (value)                                           // input
    : "cc");                                                // clobbers (condition code register [CPSR] changed)

    return prev; // safe return (local variable cannot be changed by other execution contexts)
}

Además, estoy tratando de lograr una cierta reutilización del código, es por eso que aislé solo una función básica para implementar en el código específico de la plataforma ( add()método dentro arm/atomic_int.cpp).

¿Es atomic_int.hrealmente portátil como lo es a través de diferentes plataformas / arquitecturas / compiladores? ¿Es factible este enfoque ? (Con factible quiero decir factible para cada plataforma para garantizar la atomicidad implementando solo el add()método ).

Aquí está la implementación correspondiente de ARM GCC 8.3.1 de la misma función. Aparentemente, la única diferencia real es la presencia de dmbantes y después. ¿Son realmente necesarios en mi caso? ¿Por qué? ¿Tienes un ejemplo donde mi AtomicInt(sin dmb) falla?

ACTUALIZACIÓN: implementación fija, get()método eliminado para resolver problemas de atomicidad y alineación. Ahora el se add()comporta como un estándar fetchAndAdd().

Si usa gccmay be puede usar las funciones integradas heredadas __syncpara el acceso a la memoria atómica :

void add(int volatile& a, int value) {
    __sync_fetch_and_add(&a, value);
}

Genera :

add(int volatile&, int):
.L2:
        ldxr    w2, [x0]
        add     w2, w2, w1
        stlxr   w3, w2, [x0]
        cbnz    w3, .L2
        dmb     ish
        ret