G++ 4.6 -std=gnu++0x:静态局部变量构造函数调用计时和线程安全

Question

void a() { ... }
void b() { ... }
struct X
{
    X() { b(); }
};
void f()
{
    a();
    static X x;
    ...
}

假设在 main 输入后从各种线程(可能争用(多次调用 f。(当然，对 A 和 B 的唯一调用是上面看到的(

当上面的代码在 -std=gnu++0x 模式下使用 gcc g++ 4.6 编译时：

问题 1.是否保证 a(( 至少被调用一次并在调用 b(( 之前返回？ 也就是说，在第一次调用 f(( 时，x 的构造函数是否同时调用了自动持续时间局部变量(非静态((例如，不是在全局静态初始化时(？

问题 2.是否保证 b(( 只被调用一次？ 即使两个线程在不同的内核上第一次同时执行 f？ 如果是，GCC 生成的代码通过哪种特定机制提供同步？ 编辑：此外，调用 f(( 的线程之一是否可以在 X 的构造函数返回之前获得对 x 的访问权限？

更新：我正在尝试编译一个示例并反编译以调查机制......

测试.cpp：

struct X;
void ext1(int x);
void ext2(X& x);
void a() { ext1(1); }
void b() { ext1(2); }
struct X
{
    X() { b(); }
};
void f()
{
    a();
    static X x;
    ext2(x);
}

然后：

$ g++ -std=gnu++0x -c -o test.o ./test.cpp
$ objdump -d test.o -M intel > test.dump

test.dump：

test.o:     file format elf64-x86-64

Disassembly of section .text:
0000000000000000 <_Z1av>:
   0:   55                      push   rbp
   1:   48 89 e5                mov    rbp,rsp
   4:   bf 01 00 00 00          mov    edi,0x1
   9:   e8 00 00 00 00          call   e <_Z1av+0xe>
   e:   5d                      pop    rbp
   f:   c3                      ret    
0000000000000010 <_Z1bv>:
  10:   55                      push   rbp
  11:   48 89 e5                mov    rbp,rsp
  14:   bf 02 00 00 00          mov    edi,0x2
  19:   e8 00 00 00 00          call   1e <_Z1bv+0xe>
  1e:   5d                      pop    rbp
  1f:   c3                      ret    
0000000000000020 <_Z1fv>:
  20:   55                      push   rbp
  21:   48 89 e5                mov    rbp,rsp
  24:   41 54                   push   r12
  26:   53                      push   rbx
  27:   e8 00 00 00 00          call   2c <_Z1fv+0xc>
  2c:   b8 00 00 00 00          mov    eax,0x0
  31:   0f b6 00                movzx  eax,BYTE PTR [rax]
  34:   84 c0                   test   al,al
  36:   75 2d                   jne    65 <_Z1fv+0x45>
  38:   bf 00 00 00 00          mov    edi,0x0
  3d:   e8 00 00 00 00          call   42 <_Z1fv+0x22>
  42:   85 c0                   test   eax,eax
  44:   0f 95 c0                setne  al
  47:   84 c0                   test   al,al
  49:   74 1a                   je     65 <_Z1fv+0x45>
  4b:   41 bc 00 00 00 00       mov    r12d,0x0
  51:   bf 00 00 00 00          mov    edi,0x0
  56:   e8 00 00 00 00          call   5b <_Z1fv+0x3b>
  5b:   bf 00 00 00 00          mov    edi,0x0
  60:   e8 00 00 00 00          call   65 <_Z1fv+0x45>
  65:   bf 00 00 00 00          mov    edi,0x0
  6a:   e8 00 00 00 00          call   6f <_Z1fv+0x4f>
  6f:   5b                      pop    rbx
  70:   41 5c                   pop    r12
  72:   5d                      pop    rbp
  73:   c3                      ret    
  74:   48 89 c3                mov    rbx,rax
  77:   45 84 e4                test   r12b,r12b
  7a:   75 0a                   jne    86 <_Z1fv+0x66>
  7c:   bf 00 00 00 00          mov    edi,0x0
  81:   e8 00 00 00 00          call   86 <_Z1fv+0x66>
  86:   48 89 d8                mov    rax,rbx
  89:   48 89 c7                mov    rdi,rax
  8c:   e8 00 00 00 00          call   91 <_Z1fv+0x71>
Disassembly of section .text._ZN1XC2Ev:
0000000000000000 <_ZN1XC1Ev>:
   0:   55                      push   rbp
   1:   48 89 e5                mov    rbp,rsp
   4:   48 83 ec 10             sub    rsp,0x10
   8:   48 89 7d f8             mov    QWORD PTR [rbp-0x8],rdi
   c:   e8 00 00 00 00          call   11 <_ZN1XC1Ev+0x11>
  11:   c9                      leave  
  12:   c3                      ret    

我没有看到同步机制？ 还是在链接时添加的？

更新2：好的，当我链接它时，我可以看到它...

400973: 84 c0                   test   %al,%al
400975: 75 2d                   jne    4009a4 <_Z1fv+0x45>
400977: bf 98 20 40 00          mov    $0x402098,%edi
40097c: e8 1f fe ff ff          callq  4007a0 <__cxa_guard_acquire@plt>
400981: 85 c0                   test   %eax,%eax
400983: 0f 95 c0                setne  %al
400986: 84 c0                   test   %al,%al
400988: 74 1a                   je     4009a4 <_Z1fv+0x45>
40098a: 41 bc 00 00 00 00       mov    $0x0,%r12d
400990: bf a0 20 40 00          mov    $0x4020a0,%edi
400995: e8 a6 00 00 00          callq  400a40 <_ZN1XC1Ev>
40099a: bf 98 20 40 00          mov    $0x402098,%edi
40099f: e8 0c fe ff ff          callq  4007b0 <__cxa_guard_release@plt>
4009a4: bf a0 20 40 00          mov    $0x4020a0,%edi
4009a9: e8 72 ff ff ff          callq  400920 <_Z4ext2R1X>
4009ae: 5b                      pop    %rbx
4009af: 41 5c                   pop    %r12
4009b1: 5d                      pop    %rbp

它

用__cxa_guard_acquire和__cxa_guard_release包围着它，无论他们做什么。

Answer 1

Q1。是的。根据 C++11， 6.7/4：

这样的变量在控件第一次通过其声明时初始化

所以它将在第一次调用a()后初始化。

问题 2.在 GCC 和任何支持 C++11 线程模型的编译器下：是的，局部静态变量的初始化是线程安全的。其他编译器可能不会提供这种保证。确切的机制是实现细节。我相信 GCC 使用原子标志来指示它是否已初始化，并在未设置标志时使用互斥锁来保护初始化，但我可能是错的。当然，这个线程暗示它最初是这样实现的。

更新：您的代码确实包含初始化代码。如果链接它，您可以更清楚地看到它，然后反汇编程序，以便您可以看到正在调用哪些函数。我还使用objdump -SC交错源并解散C++名称。它使用内部锁定函数__cxa_guard_acquire和__cxa_guard_release，以确保只有一个线程执行初始化代码。

  #void f()
  #{
  400724: push   rbp
  400725: mov    rbp,rsp
  400728: push   r13
  40072a: push   r12
  40072c: push   rbx
  40072d: sub    rsp,0x8
  # a();
  400731: call   400704 <a()>
  # static X x;
  # if (!guard) {
  400736: mov    eax,0x601050
  40073b: movzx  eax,BYTE PTR [rax]
  40073e: test   al,al
  400740: jne    400792 <f()+0x6e>
  #     if (__cxa_guard_acquire(&guard)) {
  400742: mov    edi,0x601050
  400747: call   4005c0 <__cxa_guard_acquire@plt>  
  40074c: test   eax,eax
  40074e: setne  al
  400751: test   al,al
  400753: je     400792 <f()+0x6e>
  #         // initialise x
  400755: mov    ebx,0x0
  40075a: mov    edi,0x601058
  40075f: call   4007b2 <X::X()>
  #         __cxa_guard_release(&guard);
  400764: mov    edi,0x601050
  400769: call   4005e0 <__cxa_guard_release@plt>
  #     } else {
  40076e: jmp    400792 <f()+0x6e>
  #         // already initialised
  400770: mov    r12d,edx
  400773: mov    r13,rax
  400776: test   bl,bl
  400778: jne    400784 <f()+0x60>
  40077a: mov    edi,0x601050
  40077f: call   4005f0 <__cxa_guard_abort@plt>
  400784: mov    rax,r13
  400787: movsxd rdx,r12d
  40078a: mov    rdi,rax
  40078d: 400610 <_Unwind_Resume@plt>
  #     }
  # }
  # ext2(x);
  400792: mov    edi,0x601058
  400797: call   4007d1 <_Z4ext2R1X>
  #}

Answer 2

据我所知，可以保证 b 只被调用一次。但是，不能保证初始化是线程安全的，这意味着另一个线程可能会使用一半/未初始化的x。 (这有点有趣，因为静态互斥体基本上是无用的。