相关疑难解决方法(0)

假设我有一个非易失性的int字段,以及一个它Interlocked.Increment的线程.另一个线程可以直接安全地读取它,还是读取也需要互锁？

我以前认为我必须使用互锁读取来保证我看到当前值,因为毕竟,该字段不是易失性的.我一直在Interlocked.CompareExchange(int, 0, 0)努力实现这一目标.

但是,我偶然发现了这个答案,这表明实际的普通读取总会看到Interlocked.Incremented值的当前版本,并且因为int读取已经是原子的,所以不需要做任何特殊的事情.我还发现了Microsoft拒绝Interlocked.Read(ref int)请求的请求,进一步表明这完全是多余的.

那么我能真正安全地阅读这样一个int领域的最新价值Interlocked吗？

(这是重复:如何正确读取Interlocked.Increment'ed int字段？但是,在阅读了答案和评论之后,我仍然不确定正确的答案.)

有些代码我不拥有,也无法更改为使用在几个不同线程中增加int计数器(numberOfUpdates)的锁.所有通话都使用:

Interlocked.Increment(ref numberOfUpdates);

我想在我的代码中读取numberOfUpdates.既然这是一个int,我知道它不会撕裂.但是,确保我获得最新价值的最佳方法是什么？看起来我的选择是:

int localNumberOfUpdates = Interlocked.CompareExchange(ref numberOfUpdates, 0, 0);

要么

int localNumberOfUpdates = Thread.VolatileRead(numberOfUpdates);

两者都有效(无论优化,重新排序,缓存等,都可以提供最新的价值)？一个比另一个更受欢迎吗？还有第三种选择更好吗？

我一直在读这篇关于原子操作的文章,它提到了32位整数赋值在x86上是原子的,只要该变量是自然对齐的.

为什么自然对齐确保原子性？

我正在研究VolatileRead/VolatileWrite方法的实现(使用Reflector),我对此感到困惑.

这是VolatileRead的实现:

[MethodImpl(MethodImplOptions.NoInlining)]
public static int VolatileRead(ref int address)
{
    int num = address;
    MemoryBarrier();
    return num;
}

在读取"地址"的值后,如何放置内存屏障？不应该是相反的吗？(在读取值之前放置,所以对于"address"的任何挂起写入都将在我们进行实际读取时完成.同样的事情发生在VolatileWrite,其中内存屏障在赋值之前放置.为什么？另外,为什么这些方法具有NoInlining属性？如果它们被内联会发生什么？

我正在使用这样的配置:

• .NET framework 4.5
• Windows Server 2008 R2
• HP DL360p Gen8(2*Xeon E5-2640,x64)

我的程序中有这样的字段:

protected int HedgeVolume;

我从几个线程访问此字段.我假设因为我有多处理器系统,所以这个线程可能在不同的处理器上执行.

我该怎么做才能保证在任何时候我使用这个字段的最新值是"读"？并确保当我"写"值时,它立即可用于所有其他线程？

我该怎么办？

• 只是按原样离开现场.
• 宣布它 volatile
• 使用Interlocked类来访问该字段
• 使用.NET 4.5 Volatile.Read,Volatile.Write访问该字段的方法
• 使用 lock

我只需要最简单的方法让我的程序在这个配置上工作我不需要我的程序在另一台计算机或服务器或操作系统上工作.此外,我想要最小的延迟,所以我正在寻找最快的解决方案,它将始终适用于此标准配置(多处理器intel x64,.net 4.5).

阅读Joseph Albahari的线程教程,以下内容被提及为内存障碍的生成器:

• C#的lock陈述(Monitor.Enter/ Monitor.Exit)
• Interlocked班上的所有方法
• 使用线程池的异步回调 - 包括异步委托,APM回调和任务延续
• 设置和等待信令构造
• 任何依赖于信令的东西,例如启动或等待任务

此外,Hans Passant和Brian Gideon 补充了以下内容(假设其中没有一个已经符合以前的类别之一):

• 启动或唤醒线程
• 上下文切换
• Thread.Sleep()

我想知道这个清单是否完整(如果完整清单甚至可以实际制作)

编辑补充建议:

• 易失性(读数意味着获取围栏,写作意味着释放围栏)

我正在阅读Joe Duffy关于Volatile读取和写入以及及时性的帖子,我正在尝试理解帖子中最后一个代码示例:

while (Interlocked.CompareExchange(ref m_state, 1, 0) != 0) ;
m_state = 0;
while (Interlocked.CompareExchange(ref m_state, 1, 0) != 0) ;
m_state = 0;
… 

当执行第二CMPXCHG操作,它使用一个内存屏障,以保证价值m_state确实写入的最新值？或者它只是使用已存储在处理器缓存中的某些值？(假设m_state未声明为volatile).
如果我理解正确,如果CMPXCHG不会使用内存屏障,那么整个锁获取过程将不公平,因为第一个获取锁的线程很可能是将获得所有锁的线程.以下锁.我是否理解正确,或者我错过了什么？

编辑:主要问题实际上,在尝试读取m_state的值之前,调用CompareExchange是否会导致内存屏障.因此,当尝试再次调用CompareExchange时,是否所有线程都可以看到赋值0.

我想知道的是lock xchg,mfence从一个线程访问内存位置的角度来看是否会有类似的行为,这个内存位置正在被其他线程进行变异(让我们随便说).它能保证我获得最新的价值吗？之后的内存读/写指令？

我混淆的原因是:

8.2.2"读取或写入不能通过I/O指令,锁定指令或序列化指令重新排序."

-Intel 64 Developers Manual Vol.3

这是否适用于线程？

mfence 状态:

对MFENCE指令之前发出的所有内存加载和存储到内存指令执行序列化操作.此序列化操作保证在MFENCE指令之前的任何加载或存储指令全局可见之前,在程序顺序之前的每条加载和存储指令都是全局可见的.MFENCE指令针对所有加载和存储指令,其他MFENCE指令,任何SFENCE和LFENCE指令以及任何序列化指令(例如CPUID指令)进行排序.

-Intel 64 Developers Manual Vol 3A

这听起来更有力.因为它听起来mfence几乎正在刷写写缓冲区,或者至少延伸到写缓冲区和其他内核以确保我未来的加载/存储是最新的.

当基准标记时,两个指令都需要约100个循环才能完成.所以我无论如何都看不出那么大的差异.

主要是我只是困惑.我的指令基于lock互斥体使用,但后来这些包含没有内存栅栏.然后,我看到锁免费使用内存栅栏编程,但没有锁.我知道AMD64有一个非常强大的内存模型,但过时的值可以在缓存中持续存在.如果lock行为与行为不同,mfence那么互斥量如何帮助您查看最新值？

这个问题是对此的跟进/澄清：

MOV x86 指令是否实现了 C++11 memory_order_release 原子存储？

这表明MOV汇编指令足以在 x86 上执行获取-释放语义。我们不需要LOCK，围栏xchg等。但是，我很难理解这是如何工作的。

英特尔文档第 3A 卷第 8 章指出：

https://software.intel.com/sites/default/files/managed/7c/f1/253668-sdm-vol-3a.pdf

在单处理器（核心）系统中......

• 读取不会与其他读取重新排序。
• 写入不会与较旧的读取重新排序。
• 对内存的写入不会与其他写入重新排序，但以下情况除外：

但这是针对单核的。多核部分似乎没有提到如何强制执行负载：

在多处理器系统中，以下排序原则适用：

• 单个处理器使用与单处理器系统相同的排序原则。
• 所有处理器都以相同的顺序观察单个处理器的写入。
• 来自单个处理器的写入与来自其他处理器的写入无关。
• 记忆排序服从因果关系（记忆排序尊重传递可见性）。
• 除了执行存储的处理器之外的处理器以一致的顺序看到任何两个存储
• 锁定指令具有总顺序。

那么如何才能MOV单独促进获取释放呢？

考虑一个原子读-修改-写操作，例如x.exchange(..., std::memory_order_acq_rel)。出于对其他对象的加载和存储进行排序的目的，这是否被视为：

1. 具有获取-释放语义的单个操作？

2. 或者，作为一个获取加载，然后是一个释放存储，附加保证其他加载和存储x将同时观察它们或两者都不观察？

如果它是 #2，那么尽管在加载之前或存储之后不能对同一线程中的其他操作进行重新排序，但仍然存在在两者之间重新排序的可能性。

作为一个具体的例子，考虑：

std::atomic<int> x, y;

void thread_A() {
    x.exchange(1, std::memory_order_acq_rel);
    y.store(1, std::memory_order_relaxed);
}

void thread_B() {
    // These two loads cannot be reordered
    int yy = y.load(std::memory_order_acquire);
    int xx = x.load(std::memory_order_acquire);
    std::cout << xx << ", " << yy << std::endl;
}

可以thread_B输出0, 1吗？

如果x.exchange()换成了x.store(1, std::memory_order_release);那么thread_B肯定能输出0, 1。是否应该exchange()排除额外的隐式负载？

cppreference听起来像 #1 是这种情况并且0, 1被禁止：

具有此内存顺序的读-修改-写操作既是获取操作又是释放操作。当前线程中的任何内存读取或写入都不能在此存储之前或之后重新排序。

但是我在标准中找不到任何明确的内容来支持这一点。实际上，该标准对原子读-修改-写操作几乎没有说明，除了 N4860 …

TL;DR：在生产者-消费者队列中，放置一个不必要的（从 C++ 内存模型的角度来看）内存栅栏或不必要的强内存顺序是否有必要以牺牲可能更差的吞吐量为代价来获得更好的延迟？

C++ 内存模型是在硬件上执行的，方法是使用某种内存栅栏来实现更强的内存顺序，而不是将它们放在较弱的内存顺序上。

特别是，如果生产者这样做store(memory_order_release)，而消费者使用 观察存储的值load(memory_order_acquire)，则加载和存储之间没有围栏。在 x86 上根本没有栅栏，在 ARM 上栅栏是在存储之前和加载之后进行放置操作。

没有围栏存储的值最终会被没有围栏的负载观察到（可能在几次不成功的尝试之后）

我想知道在队列的两侧放置围栏是否可以更快地观察到值？如果有围栏和没有围栏，延迟是多少？

我希望只有一个循环load(memory_order_acquire)和pause/yield限制为数千次迭代是最好的选择，因为它无处不在，但想了解原因。

由于这个问题是关于硬件行为的，我希望没有通用的答案。如果是这样，我主要想知道 x86（x64 风格），其次是 ARM。

例子：

T queue[MAX_SIZE]

std::atomic<std::size_t>   shared_producer_index;

void producer()
{
   std::size_t private_producer_index = 0;

   for(;;)
   {
       private_producer_index++;  // Handling rollover and queue full omitted

       /* fill data */;

      shared_producer_index.store(
          private_producer_index, std::memory_order_release);
      // Maybe barrier here or stronger order above?
   }
}


void consumer()
{
   std::size_t private_consumer_index = 0;

   for(;;)
   {
       std::size_t observed_producer_index = shared_producer_index.load( …