Два разных процесса с двумя переменными std :: atomic на одном адресе?

Стандарт C ++ не касается нескольких процессов, поэтому формальных ответов быть не может. В этом ответе предполагается, что программа в отношении синхронизации ведет себя более или менее так же, как с процессами, так и с потоками.

Первое решение требует C ++ 20 atomic_ref

void* shared_mem = /* something */

auto p1 = new (shared_mem) int;  // For creating the shared object
auto p2 = (int*)shared_mem;      // For getting the shared object

std::atomic_ref<int> i{p2};      // Use i as if atomic<int>

Это предотвращает присутствие непрозрачных атомарных типов, существующих в разделяемой памяти, что дает вам точный контроль над тем, что именно там происходит.

Решение до C ++ 20 было бы

auto p1 = new (shared_mem) atomic<int>;  // For creating the shared object
auto p2 = (atomic<int>*)shared_mem;      // For getting the shared object

auto& i = *p2;

Или используя C11 atomic_load и _ 5_

volatile int* i = (volatile int*)shared_mem;
atomic_store(i, 42);
int i2 = atomic_load(i);

Да, в стандарте C ++ обо всем этом нет слов.

Если вы работаете в Windows (чего, вероятно, нет), вы можете использовать _ 1_ и т. д., которые предлагают всю необходимую семантику и не заботятся о том, где находится объект, на который указывает ссылка (это ДЛИННЫЙ *).

На других платформах в gcc есть несколько атомарных встроенных функций что могло бы помочь с этим. Они могут освободить вас от тирании авторов стандартов. Проблема в том, что сложно проверить, является ли полученный код пуленепробиваемым.

На всех основных платформах std::atomic<T> имеет тот же размер, что и T, хотя, возможно, более высокие требования к выравниванию, если T имеет alignof ‹sizeof.

Вы можете проверить эти предположения с помощью:

  static_assert(sizeof(T) == sizeof(std::atomic<T>), 
            "atomic<T> isn't the same size as T");

  static_assert(std::atomic<T>::is_always_lock_free,  // C++17
            "atomic<T> isn't lock-free, unusable on shared mem");

  auto atomic_ptr = static_cast<atomic<int>*>(some_ptr);
           // beware strict-aliasing violations
           // don't also access the same memory via int*
           // unless you're aware of possible issues
      // also make sure that the ptr is aligned to alignof(atomic<T>)
      // otherwise you might get tearing (non-atomicity)

В экзотических реализациях C ++, где это не так, людям, которые хотят использовать ваш код в общей памяти, нужно будет сделать что-то еще.

Или, если все доступы к разделяемой памяти из всех процессов последовательно используют atomic<T>, тогда нет никаких проблем, вам нужно только lock-free, чтобы гарантировать отсутствие адресов. (Вам необходимо проверить это: std :: atomic использует хеш-таблицу блокировок для неблокируемых. Это зависит от адреса, и отдельные процессы будут иметь отдельные хэш-таблицы блокировок.)