AVX2处理byte数组性能不佳？求优化及溢出截断方案

我刚接触SIMD，正在做CPU端图像处理加速的学习实验（清楚GPU更适合这项工作，只是用来练习）。目标是对8位灰度图（即byte[]数组）执行简单的乘加操作，但实现的标量版本比SIMD版本速度快不少。我猜测这是因为byte并非AVX指令的原生类型，AVX对32位值（如float、int）的处理效率更高——后续实现的int版本SIMD性能确实更好，但提升幅度有限。

另外，图像通常以byte形式存储（比如8位灰度图或32位8888 RGBA图），转成int类型的开销会抵消性能收益，且我的场景要求输出必须是byte类型。因此有两个问题：

1. 有没有办法提升byte版本SIMD的性能？
2. 如何高效处理byte溢出问题？即把值截断到255，而非循环溢出？

基准测试结果 #

测试代码 #

public class Tests
{
    const int Count = 2048 * 2048;
    private byte[] _bytes = new byte[Count];
    private int[] _ints = new int[Count];

    [GlobalSetup]
    public void Setup()
    {
        _bytes = new byte[Count];

        for (int i = 0; i < Count; i++)
        {
            _bytes[i] = (byte)i;
        }

        _ints = new int[Count];

        for (int i = 0; i < Count; i++)
        {
            _ints[i] = i;
        }
    }

    [Benchmark]
    public void Scalar_Bytes()
    {
        for (int i = 0; i < Count; i++)
        {
            _bytes[i] = (byte)((_bytes[i] * 2) + 26);
        }
    }

    [Benchmark]
    public unsafe void Vector_Bytes()
    {
        int offset = Vector256<byte>.Count;
        fixed (byte* ptr = _bytes)
        {
            var add = Vector256.Create<byte>(26);
            for (int i = 0; i < Count; i += offset)
            {
                var v = Vector256.Load<byte>(ptr + i);
                v *= 2;
                v += add;

                Vector256.Store(v, ptr + i);
            }
        }
    }

    [Benchmark]
    public void Scalar_Ints()
    {
        for (int i = 0; i < Count; i++)
        {
            _ints[i] = ((_ints[i] * 2) + 26);
        }
    }

    [Benchmark]
    public unsafe void Vector_Ints()
    {
        int offset = Vector256<int>.Count;
        fixed (int* ptr = _ints)
        {
            var add = Vector256.Create<int>(26);
            for (int i = 0; i < Count; i += offset)
            {
                var v = Vector256.Load<int>(ptr + i);
                v *= 2;
                v += add;

                Vector256.Store(v, ptr + i);
            }
        }
    }
}

internal class Program
{
    static void Main(string[] args)
    {
        BenchmarkRunner.Run<Tests>();
    }
}

问题解答 #

1. 提升byte版本SIMD性能的方法 #

你的猜测没错：AVX对byte的算术操作（如vpaddb、vpmullb）并非单周期指令，吞吐量远低于16位/32位的操作。优化方向是将byte扩展到更宽的无符号整数类型（如ushort）执行SIMD运算，再截断回byte，同时优化内存访问和循环：

• 用Vector256<ushort>处理：每个AVX256寄存器可容纳16个ushort，虽然比byte的32个少，但ushort的乘加是单周期指令，整体吞吐量更高。
• 确保内存对齐：Vector256的对齐加载/存储（LoadAligned/StoreAligned）比非对齐操作快，可通过System.Buffers.ArrayPool分配对齐数组，或在unsafe代码中手动对齐指针。
• 循环展开：一次处理2个甚至4个Vector256，减少循环分支的开销。

以下是优化后的byte版本示例：

[Benchmark]
public unsafe void Optimized_Vector_Bytes()
{
    const ushort maxByte = 255;
    int ushortCount = Vector256<ushort>.Count;
    int byteStep = ushortCount * sizeof(ushort);
    fixed (byte* ptr = _bytes)
    {
        var addVec = Vector256.Create((ushort)26);
        var maxVec = Vector256.Create(maxByte);
        int fullLoops = Count / byteStep;
        byte* endPtr = ptr + fullLoops * byteStep;

        // 处理对齐的大块数据
        for (byte* p = ptr; p < endPtr; p += byteStep)
        {
            // 加载byte并扩展为ushort
            var v = Vector256.LoadUnsafe<ushort>(p);
            // 乘加：v = v*2 +26
            v = v << 1;
            v += addVec;
            // 截断到0-255
            v = Vector256.Min(v, maxVec);
            // 存储回byte（自动截断低8位）
            Vector256.StoreUnsafe(v, p);
        }

        // 处理剩余不足一个Vector256的元素
        for (int i = fullLoops * byteStep; i < Count; i++)
        {
            _bytes[i] = (byte)Math.Min((_bytes[i] * 2) + 26, maxByte);
        }
    }
}

2. 高效处理byte溢出截断到255 #

SIMD场景下，最优方案是在扩展后的宽类型上执行饱和截断：

• 先将byte扩展为ushort/int，执行乘加运算（此时不会溢出宽类型的范围）。
• 创建一个全为255的Vector256<ushort>（或int）向量，用Vector256.Min将运算结果与该向量取最小值，自动截断超过255的值。
• 最后将结果存储回byte时，宽类型的低8位就是我们需要的0-255的byte值。

标量场景下直接用Math.Min((val *2)+26, 255)即可，编译器会生成高效的指令。

内容的提问来源于stack exchange，提问作者creativergk