在 C# 中模拟撕裂双精度

Question

我在 32 位机器上运行，我可以使用以下代码 sn-p 来确认长值可能会撕裂。

        static void TestTearingLong()
        {
            System.Threading.Thread A = new System.Threading.Thread(ThreadA);
            A.Start();

            System.Threading.Thread B = new System.Threading.Thread(ThreadB);
            B.Start();
        }

        static ulong s_x;

        static void ThreadA()
        {
            int i = 0;
            while (true)
            {
                s_x = (i & 1) == 0 ? 0x0L : 0xaaaabbbbccccddddL;
                i++;
            }
        }

        static void ThreadB()
        {
            while (true)
            {
                ulong x = s_x;
                Debug.Assert(x == 0x0L || x == 0xaaaabbbbccccddddL);
            }
        }

但是当我尝试使用双打类似的东西时，我无法得到任何撕裂。有谁知道为什么？据我从规范中可以看出，只有对浮点数的赋值是原子的。分配给替身应该有撕裂的风险。

    static double s_x;

    static void TestTearingDouble()
    {
        System.Threading.Thread A = new System.Threading.Thread(ThreadA);
        A.Start();

        System.Threading.Thread B = new System.Threading.Thread(ThreadB);
        B.Start();
    }

    static void ThreadA()
    {
        long i = 0;

        while (true)
        {
            s_x = ((i & 1) == 0) ? 0.0 : double.MaxValue;
            i++;

            if (i % 10000000 == 0)
            {
                Console.Out.WriteLine("i = " + i);
            }
        }
    }

    static void ThreadB()
    {
        while (true)
        {
            double x = s_x;

            System.Diagnostics.Debug.Assert(x == 0.0 || x == double.MaxValue);
        }
    }

Answer 1

听起来很奇怪，这取决于您的 CPU。虽然 不保证双打不会撕裂，但它们不会在许多当前的处理器上。如果您想在这种情况下撕裂，请尝试 AMD Sempron。

编辑：几年前通过艰难的方式了解到这一点。

Answer 2

static double s_x;

当你使用双精度时，演示效果要困难得多。 CPU 使用专用指令来加载和存储双精度，分别为 FLD 和 FSTP。使用 long 会容易得多，因为没有一条指令可以在 32 位模式下加载/存储 64 位整数。要观察它，您需要使变量的地址未对齐，使其跨越 cpu 缓存行边界。

您使用的声明永远不会发生这种情况，JIT 编译器确保双精度正确对齐，存储在 8 的倍数的地址中。您可以将它存储在类的字段中，GC 分配器仅对齐在 32 位模式下为 4。但那是个废话。

最好的方法是通过使用指针故意错误对齐双精度。把 unsafe 放在 Program 类前面，让它看起来像这样：

    static double* s_x;

    static void Main(string[] args) {
        var mem = Marshal.AllocCoTaskMem(100);
        s_x = (double*)((long)(mem) + 28);
        TestTearingDouble();
    }
ThreadA:
            *s_x = ((i & 1) == 0) ? 0.0 : double.MaxValue;
ThreadB:
            double x = *s_x;

这仍然不能保证良好的错位（呵呵），因为没有办法准确控制 AllocCoTaskMem() 将分配相对于 cpu 缓存行的开头对齐的位置。它取决于您的 cpu 核心中的缓存关联性（我的是 Core i5）。你必须修改偏移量，我通过实验得到了 28 的值。该值应该能被 4 整除，但不能被 8 整除，才能真正模拟 GC 堆行为。继续向该值添加 8，直到您获得双倍以跨越缓存行并触发断言。

为了减少人为因素，您必须编写一个程序，将双精度值存储在类的字段中，并让垃圾收集器在内存中移动它，使其不对齐。很难想出一个示例程序来确保发生这种情况。

还要注意您的程序如何演示一个称为虚假共享的问题。注释掉线程 B 的 Start() 方法调用，并注意线程 A 运行的速度有多快。您将看到 cpu 的成本在 cpu 内核之间保持高速缓存线一致。由于线程访问相同的变量，因此此处旨在共享。当线程访问存储在同一缓存行中的不同变量时，就会发生真正的错误共享。这就是为什么对齐很重要的原因，只有当它的一部分在一个缓存行中而一部分在另一个缓存行中时，您才能观察到双精度的撕裂。

Answer 3

通过一些挖掘，我发现了一些关于 x86 架构上的浮点操作的有趣读物：

根据Wikipedia，x86浮点单元将浮点值存储在80位寄存器中：

[...] 随后的 x86 处理器随后集成了此 x87 功能 在芯片上，它使 x87 指令成为事实上不可或缺的一部分 x86 指令集。每个 x87 寄存器，称为 ST(0) 到 ST(7)，80 位宽，以 IEEE 浮点数存储数字 标准双扩展精度格式。

这个其他 SO 问题也相关：Some floating point precision and numeric limits question

这可以解释为什么虽然双精度是 64 位，但它们是原子操作的。

Answer 4

可以在此处找到该主题和代码示例的价值。

http://msdn.microsoft.com/en-us/magazine/cc817398.aspx