VC++ 是否仍然在顺序一致方面被破坏？

Question

我看了（大部分）Herb Sutter's the atmoic<> weapons video，我想用样本内的循环来测试“条件锁”。显然，虽然（如果我理解正确的话）C++11 标准说下面的示例应该正常工作并且顺序一致，但事实并非如此。

在您继续阅读之前，我的问题是：这是正确的吗？编译器坏了吗？我的代码是否损坏 - 我是否有错过的比赛条件？如何绕过这个？

我在 3 个不同版本的 Visual C++ 上进行了尝试：VC10 专业版、VC11 专业版和 VC12 Express（== Visual Studio 2013 Desktop Express）。

以下是我用于 Visual Studio 2013 的代码。对于其他版本，我使用 boost 而不是 std，但想法是一样的。

#include <iostream>
#include <thread>
#include <mutex>

int a = 0;
std::mutex m;

void other()
{
    std::lock_guard<std::mutex> l(m);
    std::this_thread::sleep_for(std::chrono::milliseconds(2));
    a = 999999;
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout << a << "\n";
}

int main(int argc, char* argv[])
{
    bool work = (argc > 1);

    if (work)
    {
        m.lock();
    }

    std::thread th(other);
    for (int i = 0; i < 100000000; ++i)
    {
        if (i % 7 == 3)
        {
            if (work)
            {
                ++a;
            }
        }
    }

    if (work)
    {
        std::cout << a << "\n";
        m.unlock();
    }

    th.join();
}

总结一下代码的思路：全局变量a被全局互斥锁m保护。假设没有命令行参数 (argc==1)，运行 other() 的线程是唯一应该访问全局变量 a 的线程。

程序的正确输出是打印999999。

但是，由于编译器循环优化（使用寄存器进行循环内增量并在循环结束时将值复制回a），即使不应该由程序集修改a到。

这发生在所有 3 个 VC 版本中，尽管在 VC12 的这个代码示例中，我不得不对 sleep() 进行一些调用以使其中断。

这是一些汇编代码（本次运行中a的地址是0x00f65498）：

循环初始化 - 来自 a 的值被复制到 edi

    27:     for (int i = 0; i < 100000000; ++i)
00F61543  xor         esi,esi  
00F61545  mov         edi,dword ptr ds:[0F65498h]  
00F6154B  jmp         main+0C0h (0F61550h)  
00F6154D  lea         ecx,[ecx]  
    28:     {
    29:         if (i % 7 == 3)

在条件内递增，并在循环后无条件复制回a的位置

    30:         {
    31:             if (work)
00F61572  mov         al,byte ptr [esp+1Bh]  
00F61576  jne         main+0EDh (0F6157Dh)  
00F61578  test        al,al  
00F6157A  je          main+0EDh (0F6157Dh)  
    32:             {
    33:                 ++a;
00F6157C  inc         edi  
    27:     for (int i = 0; i < 100000000; ++i)
00F6157D  inc         esi  
00F6157E  cmp         esi,5F5E100h  
00F61584  jl          main+0C0h (0F61550h)  
    32:             {
    33:                 ++a;
00F61586  mov         dword ptr ds:[0F65498h],edi  
    34:             }

程序的输出是0。

Answer 1

“volatile”关键字会阻止这种优化。这正是它的用途：每次使用 'a' 都将完全按照所示进行读取或写入，并且不会以不同的顺序移动到其他 volatile 变量。

互斥锁的实现应该包括特定于编译器的指令，以在该点引起“栅栏”，告诉优化器不要跨该边界重新排序指令。由于实现不是来自编译器供应商，也许这被遗漏了？我从来没有检查过。

由于 'a' 是全局的，我通常认为编译器会更加小心。但是，VS10 不知道线程，所以它不会考虑其他线程会使用它。由于优化器掌握了整个循环执行，它知道从循环内调用的函数不会触及“a”，这就足够了。

我不确定新标准对 volatile 以外的全局变量的线程可见性有何规定。也就是说，是否有一条规则会阻止这种优化（即使该函数可以一直被抓住，所以它知道其他函数不使用全局，它是否必须假设其他线程可以）？

我建议尝试使用编译器提供的 std::mutex 的较新编译器，并检查 C++ 标准和当前草案对此有何评论。我认为以上内容应该可以帮助您了解要查找的内容。

——约翰

Answer 2

快一个月过去了，微软仍然没有回复bug in MSDN Connect。

总结上述 cmets（以及一些进一步的测试），显然它也发生在 VS2013 专业版中，但该错误仅在为 Win32 构建时发生，而不是在 x64 上发生。 x64 中生成的汇编代码没有这个问题。 所以看起来这是优化器中的一个错误，并且这段代码中没有竞争条件。

显然这个错误也发生在 GCC 4.8.1 中，但不在 GCC 4.9 中。 （感谢Voo、nosid 和Chris Dodd 的所有测试）。

建议将a 标记为volatile。这确实防止了这个错误，但只是因为它阻止了优化器执行循环寄存器优化。

我找到了另一个解决方案：添加另一个局部变量b，如果需要（并且处于锁定状态），请执行以下操作：

1. 将a 复制到b
2. 在循环中增加b
3. 如果需要，请复制回a

优化器将局部变量替换为寄存器，因此代码仍处于优化状态，但与a 之间的复制仅在需要时完成，并且处于锁定状态。

这是新的main() 代码，箭头标记了更改的行。

int main(int argc, char* argv[])
{
    bool work = (argc == 1);

    int b = 0;          // <----

    if (work)
    {
        m.lock();
        b = a;          // <----
    }

    std::thread th(other);
    for (int i = 0; i < 100000000; ++i)
    {
        if (i % 7 == 3)
        {
            if (work)
            {
                ++b;    // <----
            }
        }
    }

    if (work)
    {
        a = b;          // <----
        std::cout << a << "\n";
        m.unlock();
    }

    th.join();
}

这就是汇编代码的样子（&a == 0x000744b0、b 替换为 edi）：

    21:     int b = 0;
00071473  xor         edi,edi  
    22: 
    23:     if (work)
00071475  test        bl,bl  
00071477  je          main+5Bh (07149Bh)  
    24:     {
    25:         m.lock();

         ........

00071492  add         esp,4  
    26:         b = a;
00071495  mov         edi,dword ptr ds:[744B0h]  
    27:     }
    28: 

         ........

    33:         {
    34:             if (work)
00071504  test        bl,bl  
00071506  je          main+0C9h (071509h)  
    35:             {
    36:                 ++b;
00071508  inc         edi  
    30:     for (int i = 0; i < 100000000; ++i)
00071509  inc         esi  
0007150A  cmp         esi,5F5E100h  
00071510  jl          main+0A0h (0714E0h)  
    37:             }
    38:         }
    39:     }
    40: 
    41:     if (work)
00071512  test        bl,bl  
00071514  je          main+10Ch (07154Ch)  
    42:     {
    43:         a = b;
    44:        std::cout << a << "\n";
00071516  mov         ecx,dword ptr ds:[73084h]  
0007151C  push        edi  
0007151D  mov         dword ptr ds:[744B0h],edi  
00071523  call        dword ptr ds:[73070h]  
00071529  mov         ecx,eax  
0007152B  call        std::operator<<<std::char_traits<char> > (071A80h)  

     ........

这样可以保持优化并解决（或解决）问题。