AVX2 потребляет байты и производит uints?

Я бы сделал это так.

Основная идея — загрузка 8 входных байтов за раз с использованием инструкции широковещательной загрузки. Затем выборочно переместите и обнулите байты, чтобы расширить эти 8 байтов до 16 коротких чисел, причем числа масштабируются на 0x100 и дублируются. Затем используйте умножение 16-битных целых чисел в двух векторах, наконец объедините их в 32-байтовый вектор и сохраните.

/// <summary>Create a pair of multipliers for _mm256_mulhi_epu16 instruction</summary>
static Vector256<ushort> makeMultipliers( byte low, byte high )
{
    // Compute multipliers with uint division
    uint a = low;
    uint b = high;
    a = ( a * 0x8000u + 254u ) / 255u;
    b = ( b * 0x8000u + 254u ) / 255u;
    // Create the pattern as uint scalar
    uint s = a | ( b << 16 );
    // Broadcast the uint, and bit cast the vector to short lanes
    return Vector256.Create( s ).AsUInt16();
}

// Permutation table which transform 4 bytes into 0A0A0B0B0C0C0D0D sequence of 16 bytes
static ReadOnlySpan<byte> permBytes => new byte[ 32 ]
{
    // First 16 byte slice uses bytes [ 0 .. 3 ]
    0xFF, 0, 0xFF, 0,  0xFF, 1, 0xFF, 1,  0xFF, 2, 0xFF, 2,  0xFF, 3, 0xFF, 3,
    // The second slice uses bytes [ 4 .. 7 ]
    0xFF, 4, 0xFF, 4,  0xFF, 5, 0xFF, 5,  0xFF, 6, 0xFF, 6,  0xFF, 7, 0xFF, 7,
};

[Benchmark]
public unsafe void GrayscaleToColor_Simd()
{
    Vector256<ushort> mul0 = makeMultipliers( _colorA, _colorG );
    Vector256<ushort> mul1 = makeMultipliers( _colorB, _colorR );

    Vector256<byte> perm;
    fixed( byte* ptr = permBytes )
        perm = Avx2.LoadVector256( ptr );
    Vector256<byte> blendMask = Vector256.Create( (ushort)0xFF00 ).AsByte();

    fixed( byte* bytePtr = _bytesGray )
    fixed( uint* pixelPtr = _pixelsRGBA )
    {
        byte* bytePtrEnd = bytePtr + ImageLength;
        byte* rsi = bytePtr;
        uint* rdi = pixelPtr;
        while( rsi < bytePtrEnd )
        {
            // Broadcast 8 bytes from memory
            Vector256<byte> grey32 = Avx2.BroadcastScalarToVector256( (ulong*)rsi ).AsByte();
            rsi += 8;
            // Duplicate bytes, scaling ushort numbers by the factor of 0x100
            Vector256<ushort> grey16 = Avx2.Shuffle( grey32, perm ).AsUInt16();

            // Multiply 16-bit numbers, keeping the higher 16 bits of the products
            Vector256<ushort> low = Avx2.MultiplyHigh( grey16, mul0 );
            Vector256<ushort> high = Avx2.MultiplyHigh( grey16, mul1 );
            // Shift bits into correct location,
            // which is low byte for even lanes, high byte for odd ones
            low = Avx2.ShiftRightLogical( low, 7 );
            high = Avx2.ShiftLeftLogical( high, 1 );

            // Combine into a single vector, and store
            Avx2.BlendVariable( low.AsByte(), high.AsByte(), blendMask )
                .AsUInt32().Store( rdi );
            rdi += 8;
        }
    }
}

Кстати, у вас в формуле есть интересный числовой вопрос. Когда вы это сделаете (byte)((value * _colorR) >> 8);, вы никогда не получите на выходе 255. Даже если оба входных байта равны 255, в результате вы получите только 254.

Вот почему я использовал там другую математику. Округление в моей версии далеко не идеальное, потому что оптимальное потребовало бы в два раза больше умножений в цикле: сначала для применения входного масштабирования, еще одного для деления на 255. Тем не менее, по крайней мере, входное масштабирование 0xFF, похоже, приводит к исходному результату. цвет.

Обновление: Идея алгоритма следующая. Полное выражение, которое нам нужно вычислить для этих чисел, — это grey * c / 255, которое можно рассматривать как grey * mul, где mul — дробное число ≤ 1,0. Вместо математических вычислений с плавающей запятой моя реализация вычисляет это выражение с помощью нескольких дешевых целочисленных математических инструкций.

Инструкция _mm256_mulhi_epu16 вычисляет следующее выражение для каждой пары чисел ushort: ( a * b ) >> 16

Обратите внимание, что инструкция не может масштабировать входные числа на 100%, потому что для этого потребуется, чтобы b было 0x10000, однако это число не помещается в ushort, для него требуется как минимум 17 бит. Следующий лучший вариант — масштабирование до 50 %, потому что для масштабирования 50 % потребуется b = 0x8000, который прекрасно вписывается в ushort дорожки, а затем использование битов [7 .. 14] выходных ushort полос.

Функция makeMultipliers вычисляет два из этих коэффициентов масштабирования и создает вектор из [ c0, c1 ] коротких чисел, реплицируемых по всему вектору. Мы вызываем его дважды, потому что нам нужно 4 из них, по одному на каждый канал выходного изображения.

В целом моя версия выполняет следующие математические операции с этими байтами:

static byte computeColor( byte grey, byte component )
{
    // Computed by makeMultipliers outside of the loop
    uint c32 = component;
    c32 = ( c32 * 0x8000u + 254u ) / 255u;
    ushort c16 = (ushort)c32;

    // Computed by moving bytes by 1 with Avx2.Shuffle, which inserts zero bytes
    ushort grey16 = (ushort)( (ushort)grey << 8 );

    // Computed by Avx2.MultiplyHigh
    ushort res = (ushort)( ( (uint)c16 * grey16 ) >> 16 );

    // Computed by bitwise shifts and byte extracts
    return (byte)( res >> 7 );
}