std :: atomic | compare_exchange_weak与compare_exchange_strong [英] std::atomic | compare_exchange_weak vs. compare_exchange_strong

问题描述

我仍然不确定这是我不理解还是文档没有清楚地制定。
以下摘录摘自最新的草稿（N3126，第29.6节）：

I'm still unsure if it's me don't understanding or the documentation isn't clearly formulated. The following excerpt has been taken from the newest draft (N3126, section 29.6):

bool atomic_compare_exchange_weak(volatile A* object, C * expected, C desired);
bool atomic_compare_exchange_weak(A* object, C * expected, C desired);
bool atomic_compare_exchange_strong(volatile A* object, C * expected, C desired);
bool atomic_compare_exchange_strong(A* object, C * expected, C desired);
bool atomic_compare_exchange_weak_explicit(volatile A* object, C * expected, C desired, memory_order success, memory_order failure);
bool atomic_compare_exchange_weak_explicit(A* object, C * expected, C desired, memory_order success, memory_order failure);
bool atomic_compare_exchange_strong_explicit(volatile A* object, C * expected, C desired, memory_order success, memory_order failure);
bool atomic_compare_exchange_strong_explicit(A* object, C * expected, C desired, memory_order success, memory_order failure);
bool A::compare_exchange_weak(C & expected, C desired, memory_order success, memory_order failure) volatile;
bool A::compare_exchange_weak(C & expected, C desired, memory_order success, memory_order failure);
bool A::compare_exchange_strong(C & expected, C desired, memory_order success, memory_order failure) volatile;
bool A::compare_exchange_strong(C & expected, C desired, memory_order success, memory_order failure);
bool A::compare_exchange_weak(C & expected, C desired, memory_order order = memory_order_seq_cst) volatile;
bool A::compare_exchange_weak(C & expected, C desired, memory_order order = memory_order_seq_cst);
bool A::compare_exchange_strong(C & expected, C desired, memory_order order = memory_order_seq_cst) volatile;
bool A::compare_exchange_strong(C & expected, C desired, memory_order order = memory_order_seq_cst);

注：弱比较和交换
可能会错误地欺骗，
是，返回false，而留下
内存指向的
操作之前预期的操作是
，与对象相同
，并且与
操作后的预期相同。 [注意：这个假的
失败使得在更广泛的
类机器上实现
compare-and-exchange，例如，loadlocked
存储条件机器。虚假失败的结果是
，几乎所有使用弱
的比较和交换将在一个
循环中。

Remark: The weak compare-and-exchange operations may fail spuriously, that is, return false while leaving the contents of memory pointed to by expected before the operation is the same that same as that of the object and the same as that of expected after the operation. [ Note: This spurious failure enables implementation of compare-and-exchange on a broader class of machines, e.g., loadlocked store-conditional machines. A consequence of spurious failure is that nearly all uses of weak compare-and-exchange will be in a loop.

那么，这是什么意思？首先，它可能会错误地失败？为什么呢？他们如何定义可能？其次，我不知道为什么，但我还是不知道与_strong和_weak后缀的函数之间的区别是什么。

So, what does this mean? Firstly, it 'may' faild spuriously?! Why it does? And how do they define 'may'? Secondly, I don't know why, but I still have no idea what's the difference between the functions with "_strong" and "_weak" suffix.

希望任何人都可以帮助;）
最好的问候。

Hope anybody can help ;) Best regards.

编辑：
这是我在libstdc ++中找到的 - implementation（atomic_0.h）：

That's what I've found in libstdc++-implementation (atomic_0.h):

bool compare_exchange_weak(
    __integral_type& __i1,
    __integral_type __i2,
    memory_order __m1,
    memory_order __m2
)
{
    __glibcxx_assert(__m2 != memory_order_release);
    __glibcxx_assert(__m2 != memory_order_acq_rel);
    __glibcxx_assert(__m2 <= __m1);
    return _ATOMIC_CMPEXCHNG_(this, &__i1, __i2, __m1);
}

bool compare_exchange_strong(
    __integral_type& __i1,
    __integral_type __i2,
    memory_order __m1,
    memory_order __m2
)
{
    __glibcxx_assert(__m2 != memory_order_release);
    __glibcxx_assert(__m2 != memory_order_acq_rel);
    __glibcxx_assert(__m2 <= __m1);
    return _ATOMIC_CMPEXCHNG_(this, &__i1, __i2, __m1);
}

推荐答案

硬件实现的共享内存一致性模型。对于实现某种松弛一致性模型（例如，释放语义）的那些硬件体系结构，上面提到的强操作可能具有高开销，因此专家可以使用较弱的形式来实现在那些宽松的一致性上也执行良好的算法

It has to do with the shared memory consistency model that the hardware implements. For those hardware architectures that implement some kind of relaxed consistency model (e.g. release semantics), the strong operations you refer to above can have a high overhead, and thus experts can use the weaker forms to implement algorithms that perform well also on those relaxed consistency architectures.

有关详情，请参阅

http://www.hpl.hp.com/techreports/Compaq-DEC/WRL-95-7.pdf

中的第12章和附录C http://kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html

这篇关于std :: atomic | compare_exchange_weak与compare_exchange_strong的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！