Как гарантировать, что 64-разрядные записи являются атомарными?

На Intel MacOSX можно использовать встроенную систему атомарные операции. Нет обеспеченного атомарного, получают или устанавливают для любой целые числа на 32 или 64 бита, но можно создать это из обеспеченного CompareAndSwap. Можно хотеть искать документацию XCode различные функции OSAtomic. Я записал 64-разрядную версию ниже. 32-разрядная версия может быть сделана со столь же именованными функциями.

#include <libkern/OSAtomic.h>
// bool OSAtomicCompareAndSwap64Barrier(int64_t oldValue, int64_t newValue, int64_t *theValue);

void AtomicSet(uint64_t *target, uint64_t new_value)
{
    while (true)
    {
        uint64_t old_value = *target;
        if (OSAtomicCompareAndSwap64Barrier(old_value, new_value, target)) return;
    }
}

uint64_t AtomicGet(uint64_t *target)
{
    while (true)
    {
        int64 value = *target;
        if (OSAtomicCompareAndSwap64Barrier(value, value, target)) return value;
    }
}

Примечание, что функции OSAtomicCompareAndSwap Apple атомарно выполняют операцию:

if (*theValue != oldValue) return false;
*theValue = newValue;
return true;

Мы используем это в примере выше для создания Метода установки первым захватом старого значения, затем пытаясь подкачать значение целевой памяти. Если подкачка успешно выполняется, который указывает, что значение памяти является все еще старым значением во время подкачки, и этому дают новое значение во время подкачки (который самой является атомарным), таким образом, мы сделаны. Если это не успешно выполняется, то некоторый другой поток вмешался путем изменения промежутка значения, когда мы захватили его и когда мы пытались сбросить его. Если это происходит, мы можем просто циклично выполниться и попробовать еще раз только с минимальным штрафом.

идея позади Получить метода состоит в том, что мы можем сначала захватить значение (который может или не может быть фактическим значением, если другой поток вмешивается). Мы можем затем попытаться подкачать значение с собой, просто проверить, что начальный захват был равен атомарному значению.

я не проверил это по своему компилятору, поэтому извините любые опечатки.

Вы упомянули OSX а именно, но в случае, если необходимо работать над другими платформами, Windows имеет, много Взаимно блокировались* функции, и можно искать документацию MSDN их. Некоторые из них работают над Windows 2000 Pro и позже, и некоторые (особенно некоторые 64-разрядные функции) являются новыми с Vista. На других платформах, версии GCC 4.1 и позже имеют разнообразие __ синхронизация* функции, такой как __ sync_fetch_and_add (). Для других систем Вы, возможно, должны использовать блок, и можно найти некоторые реализации в браузере SVN для проекта HaikuOS, внутри src/system/libroot/os/arch.

GCC имеет intrinsics для атомарных операций; я подозреваю, что можно сделать похожий с другими компиляторами, также. Никогда не полагайтесь на компилятор для атомарных операций; оптимизация почти наверняка рискнет превращать даже очевидно атомарные операции в неатомарные, если Вы явно не скажете компилятору не делать так.

Если Вы хотите сделать что-то вроде этого для межпотока или межпроцессного взаимодействия, то у Вас должны быть больше, чем просто атомарная гарантия чтения-записи. В Вашем примере кажется, что Вы хотите значения, записанные, чтобы указать, что некоторая работа происходит и/или была завершена. Необходимо будет сделать несколько вещей, не, все из которых являются портативными, чтобы гарантировать, что компилятор сделал вещи в порядке, Вы хотите их сделанный (энергозависимое ключевое слово может помочь до некоторой степени), и та память последовательна. Современные процессоры и кэши могут выполнить работу, не в порядке без ведома к компилятору, таким образом, Вам действительно нужна некоторая поддержка платформ (т.е., блокировки или определенные для платформы взаимно блокируемые API), чтобы сделать то, что кажется, что Вы хотите сделать.

"Забор памяти" или "барьер памяти" являются условиями, которые можно хотеть исследовать.

На X86 самый быстрый способ атомарной записи выровненного 64-битного значения - использовать FISTP. Для невыровненных значений вам необходимо использовать CAS2 (_InterlockedExchange64). Операция CAS2 выполняется довольно медленно из-за BUSLOCK, поэтому часто бывает быстрее проверить выравнивание и выполнить версию FISTP для выровненных адресов. Действительно, именно так Intel Threaded Building Blocks реализует атомарную 64-битную запись.