c# - 为什么在这个例子中使用 float 比使用 double 慢 2 倍？

Question

我最近一直在做一些分析，我遇到了一个让我抓狂的案例。以下是一段不安全的 C# 代码，它基本上将源样本缓冲区复制到具有不同采样率的目标缓冲区。就像现在一样，它占每帧总处理时间的 0.17%。我没有得到的是，如果我使用 float 而不是 double ，处理时间将增加到 0.38%。有人可以解释一下这里发生了什么吗？

快速版本 (~17%)

double rateIncr = ...
double readOffset = ...
double offsetIncr = ...

float v = ... // volume

// Source and target buffers.
float* src = ...
float* tgt = ...

for( var c = 0; c < chunkCount; ++c)
{
    for( var s = 0; s < chunkSampleSize; ++s )
    {
        // Source sample            
        var iReadOffset = (int)readOffset;

        // Interpolate factor
        var k = (float)readOffset - iReadOffset;

        // Linearly interpolate 2 contiguous samples and write result to target.
        *tgt++ += (src[ iReadOffset ] * (1f - k) + src[ iReadOffset + 1 ] * k) * v;

        // Increment source offset.
        readOffset += offsetIncr;
    }
    // Increment sample rate
    offsetIncr += rateIncr;
}

慢速版本 (~38%)

float rateIncr = ...
float readOffset = ...
float offsetIncr = ...

float v = ... // volume

// Source and target buffers.
float* src = ...
float* tgt = ...

for( var c = 0; c < chunkCount; ++c)
{
    for( var s = 0; s < chunkSampleSize; ++s )
    {
        var iReadOffset = (int)readOffset;

        // The cast to float is removed
        var k = readOffset - iReadOffset;

        *tgt++ += (src[ iReadOffset ] * (1f - k) + src[ iReadOffset + 1 ] * k) * v;
        readOffset += offsetIncr;
    }
    offsetIncr += rateIncr;
}

奇数版本(~22%)

float rateIncr = ...
float readOffset = ...
float offsetIncr = ...

float v = ... // volume

// Source and target buffers.
float* src = ...
float* tgt = ...

for( var c = 0; c < chunkCount; ++c)
{
    for( var s = 0; s < chunkSampleSize; ++s )
    {
        var iReadOffset = (int)readOffset;
        var k = readOffset - iReadOffset;

        // By just placing this test it goes down from 38% to 22%,
        // and the condition is NEVER met.
        if( (k != 0) && Math.Abs( k ) < 1e-38 )
        {
           Console.WriteLine( "Denormalized float?" );
        }

        *tgt++ += (src[ iReadOffset ] * (1f - k) + src[ iReadOffset + 1 ] * k) * v;
        readOffset += offsetIncr;
    }
    offsetIncr += rateIncr;
}

我现在只知道我什么都不知道

Answer 1

您是在 64 位还是 32 位处理器上运行它？我的经验是，在某些边缘情况下，如果对象的大小与寄存器的大小相匹配，CPU 可以使用这样的低级功能进行优化(即使您可能假设两个 float 可以很好地适合 64 位注册您可能仍然会失去优化优势)。如果你在 32 位系统上运行它，你可能会发现情况相反......

快速搜索和我能做的最好的引用是 C++ 游戏开发论坛的几个帖子(在我从事游戏开发的一年中，我自己注意到了这一点，但那是唯一一次我正在分析到这个级别)。 This post从 C++ 方法中获得了一些有趣的反汇编结果，这些结果可能适用于非常低的级别。

---

另一个想法:

This article来自 MSDN 的文章详细介绍了在 .NET 中使用 float 的许多内部细节，主要是为了解决 float 比较的问题。其中有一个有趣的段落总结了处理浮点值的 CLR 规范:

This spec clearly had in mind the x87 FPU. The spec is basically saying that a CLR implementation is allowed to use an internal representation (in our case, the x87 80 bit representation) as long as there is no explicit storage to a coerced location (a class or valuet type field), that forces narrowing. Also, at any point, the IL stream may have conv.r4 and conv.r8 instructions, which will force the narrowing to happen.

因此，当对它们执行操作时，您的 float 实际上可能不是 float ，而是它们可能是 x87 FPU 上的 80 位数字或编译器可能认为优化或计算精度所需的任何其他内容。如果不查看 IL，您将无法确定，但是当您使用 float 时可能会有很多代价高昂的转换，而当您使用 double 时不会命中。遗憾的是，您无法像在 C++ 中通过 fp 开关那样在 C# 中定义浮点运算所需的精度，因为这会阻止编译器在操作之前将所有内容放入更大的容器中。