解码位图时的高CPU

Question

背景

我正在使用LodePNG将位图DIB转换为内存中的PNG。 LodePNG提供以下功能：

bool decode_bitmap(std::vector<unsigned char>& image, unsigned& w, unsigned& h, const std::vector<unsigned char>& bmp)
{
    if (bmp.size() <= 54/*minimum BMP header size*/)
    {
        return false;
    }

    // read width and height from BMP header
    w = bmp[18] + bmp[19] * 256;
    h = bmp[22] + bmp[23] * 256;

    // get the channel from the BMP header (we are parsing a 24-bit image header)
    if (bmp[28] != 24)
    {
        return false;
    }

    unsigned num_channels = bmp[28] / 8, scan_line_bytes = w * num_channels;
    if (scan_line_bytes % 4 != 0)
    {
        scan_line_bytes = (scan_line_bytes / 4) * 4 + 4;
    }

    unsigned data_size = scan_line_bytes * h, pixel_offset = bmp[10] + 256 * bmp[11];
    if (bmp.size() < data_size + pixel_offset)
    {
        // BMP file too small to contain all pixels
        return false;
    }

    image.resize(w * h * 4);
    for (unsigned y = 0; y < h; y++)
    {
        for (unsigned x = 0; x < w; x++)
        {
            // pixel start byte position in the BMP
            unsigned bmpos = pixel_offset + (h - y - 1) * scan_line_bytes + num_channels * x;
            // pixel start byte position in the new raw image
            unsigned newpos = 4 * y * w + 4 * x;
            // 24-bit image doesnt contain alpha-channel, so we can add it manually (PNG requirement)
            image[newpos + 0] = bmp[bmpos + 2]; //R
            image[newpos + 1] = bmp[bmpos + 1]; //G
            image[newpos + 2] = bmp[bmpos + 0]; //B
            image[newpos + 3] = 255;            //A
        }
    }
    return true;
}

题

我遇到的问题是此函数使用太多的CPU（30-40％），无法在我的应用程序的发行版中使用。 有什么办法可以加快此功能的速度，特别是for循环部分，从而不会消耗太多的CPU？

随意提出其他选择-感谢所有帮助！

Answer 1

我想到了一些显而易见的事情。 让我们从您的原始代码开始： https : //godbolt.org/z/vVjfFF

寻找最内层的循环：

.LBB0_17:                               #   Parent Loop BB0_12 Depth=1
        add     ecx, r10d
        imul    ecx, r15d
        imul    edi, r9d
        lea     ebx, [rsi + rcx]
        add     ebx, 2
        mov     rbp, qword ptr [r12]
        movzx   ebx, byte ptr [rbp + rbx]
        lea     ebp, [rdx + rdi - 3]
        mov     r8, qword ptr [r14]
        mov     byte ptr [r8 + rbp], bl
        lea     ebp, [rsi + rcx + 1]
        mov     rbx, qword ptr [r12]
        movzx   ebx, byte ptr [rbx + rbp]
        lea     ebp, [rdx + rdi - 2]
        mov     rax, qword ptr [r14]
        mov     byte ptr [rax + rbp], bl
        lea     eax, [rsi + rcx]
        mov     rcx, qword ptr [r12]
        movzx   eax, byte ptr [rcx + rax]
        lea     ecx, [rdx + rdi - 1]
        mov     rbp, qword ptr [r14]
        mov     byte ptr [rbp + rcx], al
        lea     eax, [rdx + rdi]
        mov     rcx, qword ptr [r14]
        mov     byte ptr [rcx + rax], -1
        inc     r11d
        mov     edi, dword ptr [r13]
        mov     rax, qword ptr [rsp + 32] # 8-byte Reload
        mov     ecx, dword ptr [rax]
        add     edx, 4
        add     esi, 3
        cmp     r11d, edi
        jb      .LBB0_17

我们可以看到，有非常多的 MOV的是在那里-也许太多太多！ 一个明显的问题是，您正在通过引用std :: vector来访问数组数据，这通常不是一个好主意。 让我们获取地址的本地副本，然后改用这些地址： https : //godbolt.org/z/kDT8ZZ

    const unsigned char* const pbmp = bmp.data();
    unsigned char* const pimage = image.data();
    for (unsigned y = 0; y < h; y++)
    {
        for (unsigned x = 0; x < w; x++)
        {
            // pixel start byte position in the BMP
            unsigned bmpos = pixel_offset + (h - y - 1) * scan_line_bytes + num_channels * x;
            // pixel start byte position in the new raw image
            unsigned newpos = 4 * y * w + 4 * x;
            // 24-bit image doesnt contain alpha-channel, so we can add it manually (PNG requirement)
            pimage[newpos + 0] = pbmp[bmpos + 2]; //R
            pimage[newpos + 1] = pbmp[bmpos + 1]; //G
            pimage[newpos + 2] = pbmp[bmpos + 0]; //B
            pimage[newpos + 3] = 255;            //A
        }
    }

现在，指针存在于函数范围内，因此编译器可以在此处进行一些较小的代码改进：

.LBB0_17:                               #   Parent Loop BB0_12 Depth=1
        add     edx, r10d
        imul    edx, r13d
        imul    ebp, r9d
        lea     edi, [rcx + rdx]
        add     edi, 2
        movzx   edi, byte ptr [r11 + rdi]
        lea     r8d, [rbx + rbp - 3]
        mov     byte ptr [r12 + r8], dil
        lea     edi, [rcx + rdx + 1]
        movzx   eax, byte ptr [r11 + rdi]
        lea     edi, [rbx + rbp - 2]
        mov     byte ptr [r12 + rdi], al
        lea     eax, [rcx + rdx]
        movzx   eax, byte ptr [r11 + rax]
        lea     edx, [rbx + rbp - 1]
        mov     byte ptr [r12 + rdx], al
        lea     eax, [rbx + rbp]
        mov     byte ptr [r12 + rax], -1
        inc     esi
        mov     ebp, dword ptr [r15]
        mov     edx, dword ptr [r14]
        add     ebx, 4
        add     ecx, 3
        cmp     esi, ebp
        jb      .LBB0_17

看看我们的新循环，在最里面的循环中似乎有很多基于y和h的无意义指针加法。 因此，让我们稍微修改一下循环以将多余的内容移出循环。

    const unsigned char* const pbmp = bmp.data() + pixel_offset;
    unsigned char* const pimage = image.data();
    for (unsigned y = 0; y < h; y++)
    {
        const unsigned char* const pbmp_line = pbmp + (h - y - 1) * scan_line_bytes;
        unsigned char* const pimage_line = pimage + y * w;
        for (unsigned x = 0; x < w; x++)
        {
            // pixel start byte position in the BMP
            unsigned bmpos = num_channels * x;
            // pixel start byte position in the new raw image
            unsigned newpos = 4 * x;
            // 24-bit image doesnt contain alpha-channel, so we can add it manually (PNG requirement)
            pimage_line[newpos + 0] = pbmp_line[bmpos + 2]; //R
            pimage_line[newpos + 1] = pbmp_line[bmpos + 1]; //G
            pimage_line[newpos + 2] = pbmp_line[bmpos + 0]; //B
            pimage_line[newpos + 3] = 255;            //A
        }
    }

快速检查一下asm，我们有： https : //godbolt.org/z/zRNjzX

.LBB0_17:                               # =>This Inner Loop Header: Depth=1
        lea     edi, [rbp - 3]
        lea     edx, [rcx + 2]
        movzx   edx, byte ptr [r11 + rdx]
        mov     byte ptr [rbx + rdi], dl
        lea     edx, [rcx + 1]
        movzx   edx, byte ptr [r11 + rdx]
        lea     edi, [rbp - 2]
        mov     byte ptr [rbx + rdi], dl
        mov     edx, ecx
        movzx   edx, byte ptr [r11 + rdx]
        lea     edi, [rbp - 1]
        mov     byte ptr [rbx + rdi], dl
        mov     edx, ebp
        mov     byte ptr [rbx + rdx], -1
        inc     rsi
        mov     edi, dword ptr [r15]
        add     ebp, 4
        add     ecx, 3
        cmp     rsi, rdi
        jb      .LBB0_17

这里仍然有很多动作同时写入单个字节，因此我们可以尝试通过将字节合并为32bit值并写入一次来减少这些字节： https : //godbolt.org/z/zRNjzX

    const unsigned char* const pbmp = bmp.data() + pixel_offset;
    unsigned int* const pimage = (unsigned int*)image.data();
    for (unsigned y = 0; y < h; y++)
    {
        const unsigned char* const pbmp_line = pbmp + (h - y - 1) * scan_line_bytes;
        unsigned int* const pimage_line = pimage + y * w;
        for (unsigned x = 0; x < w; x++)
        {
            // pixel start byte position in the BMP
            unsigned bmpos = num_channels * x;
            // pixel start byte position in the new raw image
            unsigned newpos = 4 * x;

            unsigned output = (pbmp_line[bmpos + 0] << 8) | 
                              (pbmp_line[bmpos + 1] << 16) | 
                              (pbmp_line[bmpos + 2] << 24) | 
                              0xFF;
            pimage_line[newpos] = output;
        }
    }

现在，我们将内部循环减少为3次加载，即1次写入。 我的直觉是，这可能会稍微改善性能。

.LBB0_17:                               # =>This Inner Loop Header: Depth=1
        mov     ebp, ecx
        movzx   ebp, byte ptr [r8 + rbp]
        shl     ebp, 8
        lea     edi, [rcx + 1]
        movzx   edi, byte ptr [r8 + rdi]
        shl     edi, 16
        or      edi, ebp
        lea     ebp, [rcx + 2]
        movzx   ebp, byte ptr [r8 + rbp]
        shl     ebp, 24
        lea     edi, [rdi + rbp]
        add     edi, 255
        mov     esi, edx
        and     esi, -4
        mov     dword ptr [r11 + 4*rsi], edi
        inc     rbx
        mov     ebp, dword ptr [r15]
        add     rdx, 4
        add     ecx, 3
        cmp     rbx, rbp
        jb      .LBB0_17

可悲的是，当基于8位值对代码进行矢量化时，编译器往往有些垃圾，因此尽管可以通过SSE / AVX2 ops处理此代码，但您可能不得不借助一些手写的内在函数来改进代码，以超出此范围。