AVX2 вычисление массива байтов

есть ли способ повысить производительность с помощью байтовой версии?

Да, действительно, используя правильные инструкции AVX2 вместо определенных им операторов struct Vector256<byte>

Попробуйте следующую версию:

/// <summary>AVX2 optimized version of <see cref = "Vector_Bytes" /></summary>
[Benchmark]
public unsafe void vectorBytesOpt()
{
    Vector256<byte> add = Vector256.Create( (byte)26 );
    fixed( byte* ptr = _bytes )
    {
        byte* rsiEnd = ptr + Count;
        for( byte* rsi = ptr; rsi < rsiEnd; rsi += 32 )
        {
            // Load 32 bytes
            Vector256<byte> v = Vector256.Load( rsi );
            // Multiplication by 2 is equal to adding with itself
            v = Avx2.Add( v, v );
            // Add that extra number
            v = Avx2.Add( v, add );
            // Store 32 bytes
            v.Store( rsi );
        }
    }
}

как бы вы эффективно справились с проблемой переполнения байтов?

К счастью для вас, в наборе AVX2 есть еще одна инструкция, которая добавляет байты с помощью насыщения. Вот еще одна версия, которая ограничивает ваши байты до 255 вместо переноса.

/// <summary>Another version which uses saturation</summary>
[Benchmark]
public unsafe void vectorBytesOptSat()
{
    Vector256<byte> add = Vector256.Create( (byte)26 );
    fixed( byte* ptr = _bytes )
    {
        byte* rsiEnd = ptr + Count;
        for( byte* rsi = ptr; rsi < rsiEnd; rsi += 32 )
        {
            Vector256<byte> v = Vector256.Load( rsi );
            v = Avx2.AddSaturate( v, v );
            v = Avx2.AddSaturate( v, add );
            v.Store( rsi );
        }
    }
}

Вот результаты вашего теста на моем компьютере с процессором Ryzen 7 8700G при использовании среды выполнения .NET 8.0.

| Method            | Mean        | Error     | StdDev    |
|------------------ |------------:|----------:|----------:|
| Scalar_Bytes      | 1,722.81 us | 32.646 us | 30.537 us |
| Vector_Bytes      | 3,570.63 us | 26.369 us | 24.666 us |
| vectorBytesOpt    |    43.72 us |  0.434 us |  0.406 us |
| vectorBytesOptSat |    44.18 us |  0.238 us |  0.223 us |
| Scalar_Ints       | 1,728.04 us | 16.708 us | 15.629 us |
| Vector_Ints       |   256.91 us |  7.591 us | 22.023 us |

Обновление: правильное умножение возможно, но требует гораздо больше вычислительных затрат. Вот еще одна версия, которая делает это: на моем компьютере она занимает около 63,5 мкс.

[Benchmark]
public unsafe void vectorBytesMulSat()
{
    // This number needs to be < 128
    sbyte multiplier = 2;

    // Create a pair of constant vectors for _mm256_maddubs_epi16
    ushort mulLowScalar = (ushort)( multiplier );
    ushort mulHighScalar = (ushort)( mulLowScalar << 8 );
    Vector256<sbyte> mulLow = Vector256.Create( mulLowScalar ).As<ushort, sbyte>();
    Vector256<sbyte> mulHigh = Vector256.Create( mulHighScalar ).As<ushort, sbyte>();
    // Another constant to implement saturation of these products
    Vector256<ushort> maxProduct = Vector256.Create( (ushort)0xFF );
    // Final addition
    Vector256<byte> add = Vector256.Create( (byte)26 );

    fixed( byte* ptr = _bytes )
    {
        byte* rsiEnd = ptr + Count;
        for( byte* rsi = ptr; rsi < rsiEnd; rsi += 32 )
        {
            // Load 32 bytes
            Vector256<byte> v = Vector256.Load( rsi );
            // Multiply byte * sbyte, separately for even / odd bytes
            Vector256<ushort> low = Avx2.MultiplyAddAdjacent( v, mulLow ).As<short, ushort>();
            Vector256<ushort> high = Avx2.MultiplyAddAdjacent( v, mulHigh ).As<short, ushort>();
            // Saturate these products
            low = Avx2.Min( low, maxProduct );
            high = Avx2.Min( high, maxProduct );
            // Combine back into bytes
            high = Avx2.ShiftLeftLogical( high, 8 );
            v = Avx2.Or( low, high ).As<ushort, byte>();
            // Add the final constant using saturation, and store
            v = Avx2.AddSaturate( v, add );
            v.Store( rsi );
        }
    }
}

Обновление 2: вот еще одна версия, которая также выполняет правильное умножение и немного быстрее на моем компьютере, около 58,9 мкс.

// Permutation table to fix order of bytes after _mm256_packus_epi16( even, odd )
static ReadOnlySpan<byte> permuteBytes => new byte[ 16 ]
{
    0, 8, 1, 9, 2, 10, 3, 11, 4, 12, 5, 13, 6, 14, 7, 15
};

[Benchmark]
public unsafe void vectorBytesMulSat()
{
    // This number needs to be < 128
    sbyte multiplier = 2;

    // Create a pair of constant vectors for _mm256_maddubs_epi16
    ushort mulLowScalar = (ushort)( multiplier );
    ushort mulHighScalar = (ushort)( mulLowScalar << 8 );
    Vector256<sbyte> mulLow = Vector256.Create( mulLowScalar ).As<ushort, sbyte>();
    Vector256<sbyte> mulHigh = Vector256.Create( mulHighScalar ).As<ushort, sbyte>();
    // Create a vector to permute bytes after saturation
    Vector256<byte> perm;
    fixed( byte* ptr = permuteBytes )
        perm = Avx2.BroadcastVector128ToVector256( ptr );
    // Final addition
    Vector256<byte> add = Vector256.Create( (byte)26 );

    fixed( byte* ptr = _bytes )
    {
        byte* rsiEnd = ptr + Count;
        for( byte* rsi = ptr; rsi < rsiEnd; rsi += 32 )
        {
            // Load 32 bytes
            Vector256<byte> v = Vector256.Load( rsi );
            // Multiply byte * sbyte, separately for even / odd bytes
            Vector256<short> low = Avx2.MultiplyAddAdjacent( v, mulLow );
            Vector256<short> high = Avx2.MultiplyAddAdjacent( v, mulHigh );
            // Pack and saturate these products
            v = Avx2.PackUnsignedSaturate( low, high );
            // Fix order of bytes after the packing
            v = Avx2.Shuffle( v, perm );
            // Add the final constant using saturation, and store
            v = Avx2.AddSaturate( v, add );
            v.Store( rsi );
        }
    }
}