C++多线程:是本地静态lambda线程安全的初始化吗？

Question

C++ 11标准说明了本地静态变量初始化它应该是线程安全的(http://en.cppreference.com/w/cpp/language/storage_duration#Static_local_variables).我的问题是关于将lambda初始化为静态局部变量时究竟发生了什么？

我们考虑以下代码:

#include <iostream>
#include <functional>

int doSomeWork(int input)
{
    static auto computeSum = [](int number)                                                                                                                                                                  
    {
      return 5 + number;
    };  
    return computeSum(input);
}

int main(int argc, char *argv[])
{
    int result = 0;
#pragma omp parallel
{
  int localResult = 0;
#pragma omp for
  for(size_t i=0;i<5000;i++)
  {
   localResult += doSomeWork(i);
  }
#pragma omp critical
{
   result += localResult;
}
}

std::cout << "Result is: " << result << std::endl;

return 0;
}

使用ThreadSanitizer使用GCC 5.4编译:

gcc -std=c++11 -fsanitize=thread -fopenmp -g main.cpp -o main -lstdc++

工作正常,ThreadSanitizer没有错误.现在,如果我将lambda"computeSum"初始化的行更改为:

static std::function<int(int)> computeSum = [](int number)
{
  return 5 + number;
};  

代码仍然编译,但ThreadSanitizer给了我一个警告,说有一个数据竞争:

WARNING: ThreadSanitizer: data race (pid=20887)
  Read of size 8 at 0x000000602830 by thread T3:
    #0 std::_Function_base::_M_empty() const /usr/local/gcc-5.4_nofutex/include/c++/5.4.0/functional:1834 (main+0x0000004019ec)
    #1 std::function<int (int)>::operator()(int) const /usr/local/gcc-5.4_nofutex/include/c++/5.4.0/functional:2265 (main+0x000000401aa3)
    #2 doSomeWork(int) /home/laszlo/test/main.cpp:13 (main+0x000000401242)
    #3 main._omp_fn.0 /home/laszlo/test/main.cpp:25 (main+0x000000401886)
    #4 gomp_thread_start ../../../gcc-5.4.0/libgomp/team.c:118 (libgomp.so.1+0x00000000e615)

  Previous write of size 8 at 0x000000602830 by thread T1:
    #0 std::_Function_base::_Function_base() /usr/local/gcc-5.4_nofutex/include/c++/5.4.0/functional:1825 (main+0x000000401947)
    #1 function<doSomeWork(int)::<lambda(int)>, void, void> /usr/local/gcc-5.4_nofutex/include/c++/5.4.0/functional:2248 (main+0x000000401374)
    #2 doSomeWork(int) /home/laszlo/test/main.cpp:12 (main+0x000000401211)
    #3 main._omp_fn.0 /home/laszlo/test/main.cpp:25 (main+0x000000401886)
    #4 gomp_thread_start ../../../gcc-5.4.0/libgomp/team.c:118 (libgomp.so.1+0x00000000e615)

  Location is global 'doSomeWork(int)::computeSum' of size 32 at 0x000000602820 (main+0x000000602830)

  Thread T3 (tid=20891, running) created by main thread at:
    #0 pthread_create ../../../../gcc-5.4.0/libsanitizer/tsan/tsan_interceptors.cc:895 (libtsan.so.0+0x000000026704)
    #1 gomp_team_start ../../../gcc-5.4.0/libgomp/team.c:796 (libgomp.so.1+0x00000000eb5e)
    #2 __libc_start_main <null> (libc.so.6+0x00000002082f)

  Thread T1 (tid=20889, running) created by main thread at:
    #0 pthread_create ../../../../gcc-5.4.0/libsanitizer/tsan/tsan_interceptors.cc:895 (libtsan.so.0+0x000000026704)
    #1 gomp_team_start ../../../gcc-5.4.0/libgomp/team.c:796 (libgomp.so.1+0x00000000eb5e)
    #2 __libc_start_main <null> (libc.so.6+0x00000002082f)

SUMMARY: ThreadSanitizer: data race /usr/local/gcc-5.4_nofutex/include/c++/5.4.0/functional:1834 std::_Function_base::_M_empty() const

在任何情况下,ThreadSanitizer报告数据竞争的代码需要执行5-10次,直到出现警告消息.

所以我的问题是:两者之间是否存在概念上的差异

static auto computeSum = [](int number){ reentrant code returing int };

和

static std::function<int(int)> computeSum = [](int number) {same code returning int};

是什么让第一个代码工作,第二个代码是数据竞争？

编辑#1:似乎对我的问题进行了相当多的讨论.我发现Sebastian Redl的贡献最有帮助,因此我接受了这个答案.我只是想总结一下,以便人们可以参考这个.(请告诉我,如果这不适合Stack Overflow,我真的不在这里问东西...)

为什么要报告数据竞赛？

它是在一个注释(由MikeMB)建议该问题在GCC实现TSAN有关的错误(见本和本链接).这似乎是正确的:

如果我编译包含以下内容的代码:

static std::function<int(int)> computeSum = [](int number){ ... return int;};

使用GCC 5.4,机器代码如下:

  static std::function<int(int)> computeSum = [](int number)
  {
    return 5 + number;
  };
  4011d5:       bb 08 28 60 00          mov    $0x602808,%ebx
  4011da:       48 89 df                mov    %rbx,%rdi
  4011dd:       e8 de fd ff ff          callq  400fc0 <__tsan_read1@plt>
  ....

而对于GCC 6.3,它的内容如下:

  static std::function<int(int)> computeSum = [](int number)                                                                                                                                             
  {
    return 5 + number;
  };
  4011e3:   be 02 00 00 00          mov    $0x2,%esi
  4011e8:   bf 60 28 60 00          mov    $0x602860,%edi
  4011ed:   e8 9e fd ff ff          callq  400f90 <__tsan_atomic8_load@plt>

我不是机器代码的大师,但它看起来像在GCC 5.4版本中,__tsan_read1@plt用于检查静态变量是否被初始化.相比之下,GCC 6.3生成__tsan_atomic8_load@plt.我猜第二个是正确的,第一个导致误报.

如果我在没有ThreadSanitizer的情况下编译版本,GCC 5.4会生成:

static std::function<int(int)> computeSum = [](int number)
{                                                                                                                                                                                                        
  return 5 + number;
};
400e17:     b8 88 24 60 00          mov    $0x602488,%eax
400e1c:     0f b6 00                movzbl (%rax),%eax
400e1f:     84 c0                   test   %al,%al
400e21:     75 4a                   jne    400e6d <doSomeWork(int)+0x64>
400e23:     bf 88 24 60 00          mov    $0x602488,%edi
400e28:     e8 83 fe ff ff          callq  400cb0 <__cxa_guard_acquire@plt>

和GCC 6.3:

  static std::function<int(int)> computeSum = [](int number)
  {                                                                                                                                                                                                      
    return 5 + number;
  };
  400e17:   0f b6 05 a2 16 20 00    movzbl 0x2016a2(%rip),%eax        # 6024c0 <guard variable for doSomeWork(int)::computeSum>
  400e1e:   84 c0                   test   %al,%al
  400e20:   0f 94 c0                sete   %al
  400e23:   84 c0                   test   %al,%al
  400e25:   74 4a                   je     400e71 <doSomeWork(int)+0x68>
  400e27:   bf c0 24 60 00          mov    $0x6024c0,%edi
  400e2c:   e8 7f fe ff ff          callq  400cb0 <__cxa_guard_acquire@plt>

为什么没有数据竞争,如果我使用auto而不是std::function？

你可能需要在这里纠正我,但可能是编译器"内联"了自动对象,因此不需要对静态对象是否已经初始化进行簿记.

static auto computeSum = [](int number){ ... return int;};

生产:

  static auto computeSum = [](int number)
  400e76:   55                      push   %rbp                                                                                                                                                          
  400e77:   48 89 e5                mov    %rsp,%rbp
  400e7a:   48 89 7d f8             mov    %rdi,-0x8(%rbp)
  400e7e:   89 75 f4                mov    %esi,-0xc(%rbp)
  //static std::function<int(int)> computeSum = [](int number)
  {
    return 5 + number;
  };
  400e81:   8b 45 f4                mov    -0xc(%rbp),%eax
  400e84:   83 c0 05                add    $0x5,%eax
  400e87:   5d                      pop    %rbp
  400e88:   c3                      retq

Answer 1

C++标准保证本地静态的初始化,无论多么复杂,都是线程安全的,因为初始化代码只运行一次,并且在初始化完成之前没有线程将运行初始化代码.

此外,它保证从线程安全的角度调用std :: function是一个读操作,这意味着任意数量的线程可以同时执行它,只要std :: function对象不被修改为同一时间.

通过这些保证,并且因为您的代码不包含访问共享状态的任何其他内容,它应该是线程安全的.如果它仍然触发TSan,那么某处有一个错误:

• 最有可能的是,GCC使用非常棘手的原子代码来进行静态初始化保证,而TSan无法识别它是否安全.换句话说,这是TSan中的一个错误.确保您使用的是最新版本的两种工具.(具体来说,似乎TSan在某种程度上错过了某种障碍,确保std::function其他线程实际上可以看到初始化.)
• 不太可能,GCC的初始化魔法实际上是不正确的,并且这里存在真正的竞争条件.我找不到任何错误报告,因为5.4有一个后来修复过的bug.但是你可能想尝试使用更新版本的GCC.(最新的是6.3.)
• 有些人建议构造函数std::function可能有一个错误,它以不安全的方式访问全局共享方式.但即使这是真的,也没关系,因为你的代码不应该多次调用构造函数.
• GCC中可能存在一个错误,它将包含静态的函数内联到OpenMP并行循环中.也许这会导致重复静态或破坏安全初始化代码.为此必须检查生成的组件.

顺便说一句,代码的第一个版本是不同的,因为它完全是微不足道的.在下-O3,GCC实际上会在编译时完全计算循环,有效地将主函数转换为

std::cout << "Result is: " << 12522500 << std::endl;

https://godbolt.org/g/JDRPQV

即使它没有这样做,也没有为lambda完成初始化(变量只是填充的单个字节),因此没有对任何内容的写访问,也没有数据竞争的机会.

Answer 2

到目前为止,这两个答案的推理都是错误的.

它与lambda是函数指针无关.原因是:如果函数不访问不受保护的共享数据,那么它是安全的.在的情况下,auto computeSum= ..如在的问题,这是简单的定义,则ThreadSanitizer容易证明,它并不访问任何 共享数据.但是,在大小写的std::function情况下,代码变得有点复杂,并且消毒剂要么被混淆,要么根本不会证明它仍然是相同的!只是放弃了,看到了std::function.或者它有错误 - 或者更糟糕的std::function是,有错误!

让我们做这个实验:int global = 100;在全局命名空间定义,然后++global;在第一个lambda中做.看看消毒剂现在说了什么.我相信它会给出警告/错误!这也足以证明它有没有关系拉姆达是函数指针所声称的答案.

至于你的问题:

本地静态lambda线程的初始化是否安全？

是的(从C++ 11开始).请搜索此站点以获取更详细的答案.这已经多次讨论过了.