原子值的部分比较和完全交换

我认为您必须执行加载，然后是自定义条件，然后是比较和交换，其中比较是当前值完全等于读取值。如果最后一步失败，则循环。

template<class T, class F>
bool swap_if(std::atomic<T>& atomic, T desired, F&& condition) {
for (;;) {
T data = atomic.load();
if (!condition(data)) break;
if (atomic.compare_exchange_weak(data, desired)) return true;
}
return false;
}

http://coliru.stacked-crooked.com/a/a394e336628246a9

由于复杂性，您可能应该只使用互斥锁。 另外，std::atomic<Data>可能已经在幕后使用互斥锁，因为Data太大了。

就像C++一样，硬件CAS(如x86-64或ARMv8.1(在asm中不支持此功能，您必须自己推出。

在C++中，这相当简单：加载原始值并替换其中的一部分。 当然，如果另一个内核更改了您不想比较的另一个部分，这当然会导致虚假故障。

如果可能的话，使用unsigned m_index而不是size_t，所以整个结构在典型的64位机器上可以容纳8个字节，而不是16个字节。 16 字节原子在 x86-64 上较慢(尤其是纯负载部分(，或者在某些实现和/或某些 ISA 上甚至根本不是无锁的。 请参阅如何使用 c++11 CAS 实现 ABA 计数器？回复：x86-64lock cmpgxchg16b与当前的 GCC/clang 。

如果每个atomic<>访问单独使用锁，那么在整个自定义比较和设置周围只使用互斥锁会好得多。

我写了一个CAS尝试的简单实现(如cas_weak(作为示例。 您可以在模板专用化或派生类std::atomic<Data>中使用它，以便为atomic<Data>对象提供新的成员函数。

#include <atomic>
struct Data {
// without alignment, clang's atomic<Data> doesn't inline load + CAS?!?  even though return d.is_always_lock_free; is true
alignas(long long)  char m_data;
unsigned m_index;               // this last so compilers can replace it slightly more efficiently
};
inline bool partial_cas_weak(std::atomic<Data> &d, unsigned expected_idx, Data zz, std::memory_order order = std::memory_order_seq_cst)
{
Data expected = d.load(std::memory_order_relaxed);
expected.m_index = expected_idx;            // new index, same everything else
return d.compare_exchange_weak(expected, zz, order);
// updated value of "expected" discarded on CAS failure
// If you make this a retry loop, use it instead of repeated d.load
}

这在实践中与 x86-64 的 clang (Godbolt( 编译得很好，内联到传递编译时间常量order的调用者中(否则 clang 会在该orderarg 上疯狂分支以获得函数的独立非内联版本(

# clang10.0 -O3 for x86-64
test_pcw(std::atomic<Data>&, unsigned int, Data):
mov     rax, qword ptr [rdi]                  # load the whole thing
shl     rsi, 32
mov     eax, eax                              # zero-extend the low 32 bits, clearing m_index
or      rax, rsi                              # OR in a new high half = expected_idx
lock            cmpxchg qword ptr [rdi], rdx      # the actual 8-byte CAS
sete    al                                        # boolean FLAG result into register
ret

不幸的是，编译器太笨了，不能只加载他们实际需要的原子结构部分，而是加载整个东西，然后将他们不想要的部分归零。 (请参阅如何使用 c++11 CAS 实现 ABA 计数器？，以便在某些编译器上解决此问题。

不幸的是，GCC 制作了混乱的 asm，将临时文件存储/重新加载到堆栈中，导致存储转发停滞。 GCC 还会在char m_data(无论是第一个成员还是最后一个成员(后将填充清零，如果内存中的实际对象具有非零填充，则可能导致 CAS 始终失败。 如果纯存储和初始化始终使其为零，这可能是不可能的。

像ARM或PowerPC这样的LL/SC机器可以在汇编中轻松做到这一点(比较/分支是手动完成的，在加载链接和存储条件之间(，但没有库可以移植地公开它。 (最重要的是，它无法为 x86 等机器进行编译，并且您在 LL/SC 事务中可以执行的操作受到严重限制，并且本地变量的调试模式溢出/重新加载可能会导致代码始终失败。

如果使用std::mutex而不是atomic是一个选项，您可以将互斥锁放在您自己的类似原子的包装器中。

这是它的开始：

#include <iostream>
#include <type_traits>
#include <mutex>
template<typename T>
class myatomic {
public:
static_assert(
// std::is_trivially_copyable_v<T> && // used in std::atomic, not needed here
std::is_copy_constructible_v<T> &&
std::is_move_constructible_v<T> &&
std::is_copy_assignable_v<T> &&
std::is_move_assignable_v<T>, "unsupported type");
using value_type = T;
myatomic() : data{} {}
explicit myatomic(const T& v) : data{v} {}
myatomic(const myatomic& rhs) : myatomic(rhs.load()) {}
myatomic& operator=(const myatomic& rhs) {
std::scoped_lock lock(mtx, rhs.mtx);
data = rhs.data;
return *this;
}
T load() const {
const std::lock_guard<std::mutex> lock(mtx);
return data;
}
operator T() const {
return load();
}
void store(const T& v) {
const std::lock_guard<std::mutex> lock(mtx);
data = v;
}
myatomic& operator=(const T& v) {
store(v);
return *this;
}
// partial compare and full swap
template<typename Mptr, typename V>
bool exchange_if_equals(Mptr mvar, V mval, const T& oval) {
const std::lock_guard<std::mutex> lock(mtx);
if(data.*mvar == mval) {
data = oval;
return true;
}
return false;
}
template<typename Mptr>
auto get(Mptr mvar) const {
const std::lock_guard<std::mutex> lock(mtx);
return data.*mvar;
}
template<typename Mptr, typename V>
void set(Mptr mvar, const V& v) {
const std::lock_guard<std::mutex> lock(mtx);
data.*mvar = v;
}
private:
mutable std::mutex mtx;
T data;
};
struct Data {
size_t m_index;
char m_data;
};
int main() {
Data orig{10, 'a'};
Data zz; // some initialization
myatomic<Data> dd(orig);
dd.exchange_if_equals(&Data::m_index, 10U, zz);
std::cout << dd.get(&Data::m_index);
}