如何避免使用取模运算或分支操作实现循环缓冲区写入？

在进行FIR卷积时，我使用了一个双倍长度的循环缓冲区（circular buffer），每次向其中写入4个样本。为了将样本写入缓冲区的后半部分，必须使用取模运算符，但取模运算的速度极慢。

当前的缓冲区写入代码如下：

for (var sample = 0; sample <= length - CVector; sample += CVector)
{
    var s0 = ZOffset + 0;
    var s1 = ZOffset + 1;
    var s2 = ZOffset + 2;
    var s3 = ZOffset + 3;

    Z[s0] = Z[(s0 + ZOffsetSet) % ZLength] = source[sample + 3];
    Z[s1] = Z[(s1 + ZOffsetSet) % ZLength] = source[sample + 2];
    Z[s2] = Z[(s2 + ZOffsetSet) % ZLength] = source[sample + 1];
    Z[s3] = Z[(s3 + ZOffsetSet) % ZLength] = source[sample + 0];
    ...
}

每次迭代后Z缓冲区的内容如下：

4,  3,  2,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  4,  3,  2,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
  4,  3,  2,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  8,  7,  6,  5,  4,  3,  2,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  8,  7,  6,  5
  4,  3,  2,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 12, 11, 10,  9,  8,  7,  6,  5
  4,  3,  2,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5
  4,  3,  2,  1,  0,  0,  0,  0,  0,  0, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,  0,  0,  0,  0,  0,  0, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5
  4,  3,  2,  1,  0,  0, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,  0,  0, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5
  4,  3, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5
 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,  9,  8,  7, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,  9,  8,  7, 32, 31

（输入信号为1, 2, 3, 4 ... 29, 30, 31, 32）

取模运算符调整索引的规则如下：

26 -> 26
27 -> 27
28 -> 28
29 -> 29
...
50 -> 50
51 -> 51
52 -> 0
53 -> 1

显然，我可以使用if (index >= Z.Length) index -= Z.Length;来替代，但这会引入分支操作。

解决方案 #

1. 利用双倍长度缓冲区的特性（最适配你的场景） #

你已经采用了双倍长度的循环缓冲区，这本身就是优化索引的核心优势：不需要任何取模或分支操作，直接让索引自然增长即可。

因为缓冲区长度是实际循环周期的2倍，当索引超过ZLength时，对应的后半段缓冲区正好是前半段的镜像，完全匹配你当前代码中Z[s0] = Z[(s0 + ZOffsetSet) % ZLength]的重复赋值逻辑。

修改后的代码可以直接去掉取模运算：

for (var sample = 0; sample <= length - CVector; sample += CVector)
{
    var s0 = ZOffset + 0;
    var s1 = ZOffset + 1;
    var s2 = ZOffset + 2;
    var s3 = ZOffset + 3;

    // 直接使用s0 + ZOffsetSet，无需取模
    Z[s0] = Z[s0 + ZOffsetSet] = source[sample + 3];
    Z[s1] = Z[s1 + ZOffsetSet] = source[sample + 2];
    Z[s2] = Z[s2 + ZOffsetSet] = source[sample + 1];
    Z[s3] = Z[s3 + ZOffsetSet] = source[sample + 0];
    ...
}

这种方式完全规避了取模和分支，是最适合你现有实现的优化方案。

2. 无分支条件减法（通用循环缓冲区场景） #

如果必须处理模运算逻辑，还可以用无分支的算术操作替代取模或if判断，利用整数符号位特性实现条件减法：

// 计算是否需要减去ZLength的掩码
int mask = (index >= ZLength) ? -1 : 0;
index -= ZLength & mask;

或者更简洁的写法：

index -= ZLength * Convert.ToInt32(index >= ZLength);

多数现代编译器会自动将这类简单分支优化为无分支指令，但手动编写可以确保逻辑一致性。

3. 位运算优化（缓冲区长度为2的幂时） #

如果ZLength是2的整数次幂（比如32、64等），可以用位运算彻底替代取模：

index &= ZLength - 1;

位运算的速度远快于取模，且完全没有分支开销，但仅适用于长度为2的幂的场景。

内容的提问来源于Stack Exchange，提问作者aybe