Быстрый способ копирования памяти с переводом - ARGB в BGR

Я написал 4 разные версии, которые работают с перестановкой байтов. Я скомпилировал их с помощью gcc 4.2.1 с -O3 -mssse3, прогнал их 10 раз над 32 МБ случайных данных и нашел средние значения.

Примечание редактора: исходный встроенный asm использовал небезопасные ограничения, например изменение операндов, предназначенных только для ввода, и отказ от сообщения компилятору о побочный эффект для памяти, на которую указывают входные данные указателя в регистрах. По-видимому, это сработало для теста. Я исправил ограничения, чтобы они были безопасными для всех вызывающих абонентов. Это не должно влиять на результаты тестов, только убедитесь, что окружающий код безопасен для всех вызывающих. Современные процессоры с более высокой пропускной способностью памяти должны увидеть большее ускорение для SIMD по сравнению с 4-байтовым скаляром, но самые большие преимущества проявляются, когда данные в кеше находятся в горячем состоянии (работают с меньшими блоками или с меньшими общими размерами).

В 2020 году лучше всего использовать портативную версию _mm_loadu_si128 встроенных функций, которая будет компилироваться в эквивалентный цикл asm: https://gcc.gnu.org/wiki/DontUseInlineAsm.

Также обратите внимание, что все эти байты перезаписывают 1 (скаляр) или 4 (SIMD) байта после конца вывода, поэтому последние 3 байта следует делать отдельно, если это проблема.

--- @PeterCordes

Первая версия использует цикл C для преобразования каждого пикселя отдельно с помощью функции OSSwapInt32 (которая компилируется в инструкцию bswap с -O3).

void swap1(ARGB *orig, BGR *dest, unsigned imageSize) {
    unsigned x;
    for(x = 0; x < imageSize; x++) {
        *((uint32_t*)(((uint8_t*)dest)+x*3)) = OSSwapInt32(((uint32_t*)orig)[x]);
        // warning: strict-aliasing UB.  Use memcpy for unaligned loads/stores
    }
}

Второй метод выполняет ту же операцию, но использует встроенный цикл сборки вместо цикла C.

void swap2(ARGB *orig, BGR *dest, unsigned imageSize) {
    asm volatile ( // has to be volatile because the output is a side effect on pointed-to memory
        "0:\n\t"                   // do {
        "movl   (%1),%%eax\n\t"
        "bswapl %%eax\n\t"
        "movl   %%eax,(%0)\n\t"    // copy a dword byte-reversed
        "add    $4,%1\n\t"         // orig += 4 bytes
        "add    $3,%0\n\t"         // dest += 3 bytes
        "dec    %2\n\t"
        "jnz    0b"                // }while(--imageSize)
        : "+r" (dest), "+r" (orig), "+r" (imageSize)
        : // no pure inputs; the asm modifies and dereferences the inputs to use them as read/write outputs.
        : "flags", "eax", "memory"
    );
}

Третья версия - это модифицированная версия просто ответ позера. Я преобразовал встроенные функции в эквиваленты GCC и использовал встроенную функцию lddqu, так что входной аргумент не нужно выравнивать. (Примечание редактора: только P4 когда-либо извлекал выгоду из lddqu; movdqu можно использовать, но нет недостатков.)

typedef char v16qi __attribute__ ((vector_size (16)));
void swap3(uint8_t *orig, uint8_t *dest, size_t imagesize) {
    v16qi mask = {3,2,1,7,6,5,11,10,9,15,14,13,0xFF,0xFF,0xFF,0XFF};
    uint8_t *end = orig + imagesize * 4;
    for (; orig != end; orig += 16, dest += 12) {
        __builtin_ia32_storedqu(dest,__builtin_ia32_pshufb128(__builtin_ia32_lddqu(orig),mask));
    }
}

Наконец, четвертая версия - это встроенный ассемблерный эквивалент третьей.

void swap2_2(uint8_t *orig, uint8_t *dest, size_t imagesize) {
    static const int8_t mask[16] = {3,2,1,7,6,5,11,10,9,15,14,13,0xFF,0xFF,0xFF,0XFF};
    asm volatile (
        "lddqu  %3,%%xmm1\n\t"
        "0:\n\t"
        "lddqu  (%1),%%xmm0\n\t"
        "pshufb %%xmm1,%%xmm0\n\t"
        "movdqu %%xmm0,(%0)\n\t"
        "add    $16,%1\n\t"
        "add    $12,%0\n\t"
        "sub    $4,%2\n\t"
        "jnz    0b"
        : "+r" (dest), "+r" (orig), "+r" (imagesize)
        : "m" (mask)  // whole array as a memory operand.  "x" would get the compiler to load it
        : "flags", "xmm0", "xmm1", "memory"
    );
}

На моем MacBook Pro 2010 года, i5 2,4 ГГц (Westmere / Arrandale), 4 ГБ ОЗУ, это было среднее время для каждого:

Как видите, компилятор достаточно хорош в оптимизации, поэтому писать сборку не нужно. Кроме того, векторные функции были всего на 1,5 миллисекунды быстрее на 32 МБ данных, поэтому это не причинит большого вреда, если вы хотите поддерживать самые ранние компьютеры Mac от Intel, которые не поддерживали SSSE3.

Version 1: 10.8630 milliseconds
Version 2: 11.3254 milliseconds
Version 3:  9.3163 milliseconds
Version 4:  9.3584 milliseconds

Изменить: Лиори запросил информацию о стандартном отклонении. К сожалению, я не сохранил точки данных, поэтому я провел еще один тест с 25 итерациями.

Кроме того, вот необработанные данные из новых тестов на случай, если они кому-то понадобятся. Для каждой итерации случайным образом генерировался набор данных размером 32 МБ, который выполнялся четырьмя функциями. Время выполнения каждой функции в микросекундах указано ниже.

              Average    | Standard Deviation
Brute force: 18.01956 ms | 1.22980 ms (6.8%)
Version 1:   11.13120 ms | 0.81076 ms (7.3%)
Version 2:   11.27092 ms | 0.66209 ms (5.9%)
Version 3:    9.29184 ms | 0.27851 ms (3.0%)
Version 4:    9.40948 ms | 0.32702 ms (3.5%)

Очевидное, используя pshufb.

Brute force: 22173 18344 17458 17277 17508 19844 17093 17116 19758 17395 18393 17075 17499 19023 19875 17203 16996 17442 17458 17073 17043 18567 17285 17746 17845
Version 1:   10508 11042 13432 11892 12577 10587 11281 11912 12500 10601 10551 10444 11655 10421 11285 10554 10334 10452 10490 10554 10419 11458 11682 11048 10601
Version 2:   10623 12797 13173 11130 11218 11433 11621 10793 11026 10635 11042 11328 12782 10943 10693 10755 11547 11028 10972 10811 11152 11143 11240 10952 10936
Version 3:    9036  9619  9341  8970  9453  9758  9043 10114  9243  9027  9163  9176  9168  9122  9514  9049  9161  9086  9064  9604  9178  9233  9301  9717  9156
Version 4:    9339 10119  9846  9217  9526  9182  9145 10286  9051  9614  9249  9653  9799  9270  9173  9103  9132  9550  9147  9157  9199  9113  9699  9354  9314

Объединяя только ответы позера и Джитамаро, если вы предполагаете, что входы и выходы выровнены по 16 байт, и если вы обрабатываете пиксели по 4 за раз, вы можете использовать комбинацию тасовок, масок и или или для сохранения с использованием выровненных магазины. Основная идея состоит в том, чтобы сгенерировать четыре промежуточных набора данных, а затем или их вместе с масками для выбора соответствующих значений пикселей и записи 3 16-байтовых наборов данных пикселей. Обратите внимание, что я не компилировал это и не пытался запустить его вообще.

#include <assert.h>
#include <inttypes.h>
#include <tmmintrin.h>

// needs:
// orig is 16-byte aligned
// imagesize is a multiple of 4
// dest has 4 trailing scratch bytes
void convert(uint8_t *orig, size_t imagesize, uint8_t *dest) {
    assert((uintptr_t)orig % 16 == 0);
    assert(imagesize % 4 == 0);
    __m128i mask = _mm_set_epi8(-128, -128, -128, -128, 13, 14, 15, 9, 10, 11, 5, 6, 7, 1, 2, 3);
    uint8_t *end = orig + imagesize * 4;
    for (; orig != end; orig += 16, dest += 12) {
        _mm_storeu_si128((__m128i *)dest, _mm_shuffle_epi8(_mm_load_si128((__m128i *)orig), mask));
    }
}

EDIT2: Подробнее о базовой структуре кода:

С SSE2 вы получаете лучшую производительность за счет чтения и записи 16 байт с выравниванием по 16 байт. Поскольку ваш 3-байтовый пиксель может быть выровнен только по 16 байтам на каждые 16 пикселей, мы группируем по 16 пикселей за раз, используя комбинацию перетасовок и масок и или 16 входных пикселей за раз.

Входы от LSB до MSB выглядят следующим образом, без учета конкретных компонентов:

и результаты выглядят так:

s[0]: 0000 0000 0000 0000
s[1]: 1111 1111 1111 1111
s[2]: 2222 2222 2222 2222
s[3]: 3333 3333 3333 3333

Итак, чтобы сгенерировать эти выходные данные, вам нужно сделать следующее (фактические преобразования я уточню позже):

d[0]: 000 000 000 000 111 1
d[1]:  11 111 111 222 222 22
d[2]:   2 222 333 333 333 333

Итак, как должно выглядеть combine_<x>? Если мы предположим, что d просто s уплотнено вместе, мы можем объединить два s с маской и или:

d[0]= combine_0(f_0_low(s[0]), f_0_high(s[1]))
d[1]= combine_1(f_1_low(s[1]), f_1_high(s[2]))
d[2]= combine_2(f_1_low(s[2]), f_1_high(s[3]))

где (1 означает выбор левого пикселя, 0 означает выбор правого пикселя): маска (0) = 111 111 111 111 000 0 маска (1) = 11 111 111 000 000 00 маска (2) = 1 111 000 000 000 000

combine_x(left, right)= (left & mask(x)) | (right & ~mask(x))

Но настоящие преобразования (f_<x>_low, f_<x>_high) на самом деле не так просты. Поскольку мы меняем местами и удаляем байты из исходного пикселя, фактическое преобразование (для краткости в качестве первого пункта назначения):

Если вы переведете приведенное выше в байтовые смещения от источника к месту назначения, вы получите: d [0] = & s [0] +3 & s [0] +2 & s [0] +1
& s [0] +7 & s [ 0] +6 & s [0] +5 & s [0] +11 & s [0] +10 & s [0] +9 & s [0] +15 & s [0] +14 & s [0] +13
& s [1] +3 & s [1] +2 & s [1] +1
& s [1] +7

d[0]= 
    s[0][0].Blue s[0][0].Green s[0][0].Red 
    s[0][1].Blue s[0][1].Green s[0][1].Red 
    s[0][2].Blue s[0][2].Green s[0][2].Red 
    s[0][3].Blue s[0][3].Green s[0][3].Red
    s[1][0].Blue s[1][0].Green s[1][0].Red
    s[1][1].Blue

(Если вы посмотрите на все смещения s [0], они соответствуют только маске перетасовки позера в обратном порядке.)

Теперь мы можем сгенерировать маску перемешивания, чтобы сопоставить каждый исходный байт с целевым байтом (X означает, что нам все равно, что это за значение):

Мы можем дополнительно оптимизировать это, просмотрев маски, которые мы используем для каждого исходного пикселя. Если вы посмотрите на маски перемешивания, которые мы используем для s [1]:

f_0_low=  3 2 1  7 6 5  11 10 9  15 14 13  X X X  X
f_0_high= X X X  X X X   X  X X   X  X  X  3 2 1  7

f_1_low=    6 5  11 10 9  15 14 13  X X X   X X X  X  X
f_1_high=   X X   X  X X   X  X  X  3 2 1   7 6 5  11 10

f_2_low=      9  15 14 13  X  X  X  X X X   X  X  X  X  X  X
f_2_high=     X   X  X  X  3  2  1  7 6 5   11 10 9  15 14 13

Поскольку две маски перемешивания не перекрываются, мы можем объединить их и просто замаскировать нерелевантные пиксели в comb_, что мы уже сделали! Следующий код выполняет все эти оптимизации (плюс он предполагает, что адреса источника и назначения выровнены по 16 байт). Кроме того, маски записываются в коде в порядке MSB-> LSB, на случай, если вы запутаетесь с порядком.

f_0_high=  X  X  X  X  X  X  X  X  X  X  X  X  3  2  1  7
f_1_low=   6  5 11 10  9 15 14 13  X  X  X  X  X  X  X  X

РЕДАКТИРОВАТЬ: изменил хранилище на _mm_stream_si128, поскольку вы, вероятно, делаете много записей, и мы не хотим обязательно очищать кеш. Кроме того, он должен быть выровнен в любом случае, чтобы получить бесплатную производительность!

Я немного опаздываю на вечеринку, кажется, что сообщество уже решило использовать pshufb-answer от Позера, но репутация 2000 года настолько велика, что я должен попробовать.

#include <assert.h>
#include <inttypes.h>
#include <tmmintrin.h>

// needs:
// orig is 16-byte aligned
// imagesize is a multiple of 4
// dest has 4 trailing scratch bytes
void convert(uint8_t *orig, size_t imagesize, uint8_t *dest) {
    assert((uintptr_t)orig % 16 == 0);
    assert(imagesize % 16 == 0);

    __m128i shuf0 = _mm_set_epi8(
        -128, -128, -128, -128, // top 4 bytes are not used
        13, 14, 15, 9, 10, 11, 5, 6, 7, 1, 2, 3); // bottom 12 go to the first pixel

    __m128i shuf1 = _mm_set_epi8(
        7, 1, 2, 3, // top 4 bytes go to the first pixel
    -128, -128, -128, -128, // unused
        13, 14, 15, 9, 10, 11, 5, 6); // bottom 8 go to second pixel

    __m128i shuf2 = _mm_set_epi8(
        10, 11, 5, 6, 7, 1, 2, 3, // top 8 go to second pixel
    -128, -128, -128, -128, // unused
        13, 14, 15, 9); // bottom 4 go to third pixel

    __m128i shuf3 = _mm_set_epi8(
        13, 14, 15, 9, 10, 11, 5, 6, 7, 1, 2, 3, // top 12 go to third pixel
        -128, -128, -128, -128); // unused

    __m128i mask0 = _mm_set_epi32(0, -1, -1, -1);
    __m128i mask1 = _mm_set_epi32(0,  0, -1, -1);
    __m128i mask2 = _mm_set_epi32(0,  0,  0, -1);

    uint8_t *end = orig + imagesize * 4;
    for (; orig != end; orig += 64, dest += 48) {
        __m128i a= _mm_shuffle_epi8(_mm_load_si128((__m128i *)orig), shuf0);
        __m128i b= _mm_shuffle_epi8(_mm_load_si128((__m128i *)orig + 1), shuf1);
        __m128i c= _mm_shuffle_epi8(_mm_load_si128((__m128i *)orig + 2), shuf2);
        __m128i d= _mm_shuffle_epi8(_mm_load_si128((__m128i *)orig + 3), shuf3);

        _mm_stream_si128((__m128i *)dest, _mm_or_si128(_mm_and_si128(a, mask0), _mm_andnot_si128(b, mask0));
        _mm_stream_si128((__m128i *)dest + 1, _mm_or_si128(_mm_and_si128(b, mask1), _mm_andnot_si128(c, mask1));
        _mm_stream_si128((__m128i *)dest + 2, _mm_or_si128(_mm_and_si128(c, mask2), _mm_andnot_si128(d, mask2));
    }
}

Вот моя версия без встроенных функций, специфичных для платформы, или специфичного для машины asm, я включил некоторый кроссплатформенный код синхронизации, показывающий 4-кратное ускорение, если вы выполняете и то, и другое, как я, И активировать оптимизацию компилятора (оптимизация регистров, развертывание цикла):

#include "stdlib.h"
#include "stdio.h"
#include "time.h"

#define UInt8 unsigned char

#define IMAGESIZE (1920*1080) 
int main() {
    time_t  t0, t1;
    int frames;
    int frame; 
    typedef struct{ UInt8 Alpha; UInt8 Red; UInt8 Green; UInt8 Blue; } ARGB;
    typedef struct{ UInt8 Blue; UInt8 Green; UInt8 Red; } BGR;

    ARGB* orig = malloc(IMAGESIZE*sizeof(ARGB));
    if(!orig) {printf("nomem1");}
    BGR* dest = malloc(IMAGESIZE*sizeof(BGR));
    if(!dest) {printf("nomem2");}

    printf("to start original hit a key\n");
    getch();
    t0 = time(0);
    frames = 1200;
    for(frame = 0; frame<frames; frame++) {
        int x; for(x = 0; x < IMAGESIZE; x++) {
            dest[x].Red = orig[x].Red;
            dest[x].Green = orig[x].Green;
            dest[x].Blue = orig[x].Blue;
            x++;
        }
    }
    t1 = time(0);
    printf("finished original of %u frames in %u seconds\n", frames, t1-t0);

    // on my core 2 subnotebook the original took 16 sec 
    // (8 sec with compiler optimization -O3) so at 60 FPS 
    // (instead of the 1200) this would be faster than realtime 
    // (if you disregard any other rendering you have to do). 
    // However if you either want to do other/more processing 
    // OR want faster than realtime processing for e.g. a video-conversion 
    // program then this would have to be a lot faster still.

    printf("to start alternative hit a key\n");
    getch();
    t0 = time(0);
    frames = 1200;
    unsigned int* reader;
    unsigned int* end = reader+IMAGESIZE;
    unsigned int cur; // your question guarantees 32 bit cpu
    unsigned int next;
    unsigned int temp;
    unsigned int* writer;
    for(frame = 0; frame<frames; frame++) {
        reader = (void*)orig;
        writer = (void*)dest;
        next = *reader;
        reader++;
        while(reader<end) {
            cur = next;
            next = *reader;         
            // in the following the numbers are of course the bitmasks for 
            // 0-7 bits, 8-15 bits and 16-23 bits out of the 32
            temp = (cur&255)<<24 | (cur&65280)<<16|(cur&16711680)<<8|(next&255); 
            *writer = temp;
            reader++;
            writer++;
            cur = next;
            next = *reader;
            temp = (cur&65280)<<24|(cur&16711680)<<16|(next&255)<<8|(next&65280);
            *writer = temp;
            reader++;
            writer++;
            cur = next;
            next = *reader;
            temp = (cur&16711680)<<24|(next&255)<<16|(next&65280)<<8|(next&16711680);
            *writer = temp;
            reader++;
            writer++;
        }
    }
    t1 = time(0);
    printf("finished alternative of %u frames in %u seconds\n", frames, t1-t0);

    // on my core 2 subnotebook this alternative took 10 sec 
    // (4 sec with compiler optimization -O3)

}

F:\>gcc b.c -o b.exe

F:\>b
to start original hit a key
finished original of 1200 frames in 16 seconds
to start alternative hit a key
finished alternative of 1200 frames in 10 seconds

F:\>gcc b.c -O3 -o b.exe

F:\>b
to start original hit a key
finished original of 1200 frames in 8 seconds
to start alternative hit a key
finished alternative of 1200 frames in 4 seconds