3

我正在尝试提高我的功能的性能。Profiler 指向内部循环的代码。我可以提高该代码的性能，也许使用 SSE 内在函数？

void ConvertImageFrom_R16_FLOAT_To_R32_FLOAT(char* buffer, void* convertedData, DWORD width, DWORD height, UINT rowPitch)
{
    struct SINGLE_FLOAT
    {
        union {
            struct {
                unsigned __int32 R_m : 23;
                unsigned __int32 R_e : 8;
                unsigned __int32 R_s : 1;
            };
            struct {
                float r;
            };
        };
    };
    C_ASSERT(sizeof(SINGLE_FLOAT) == 4); // 4 bytes
    struct HALF_FLOAT
    {
        unsigned __int16 R_m : 10;
        unsigned __int16 R_e : 5;
        unsigned __int16 R_s : 1;
    };
    C_ASSERT(sizeof(HALF_FLOAT) == 2);
    SINGLE_FLOAT* d = (SINGLE_FLOAT*)convertedData;
    for(DWORD j = 0; j< height; j++)
    {
        HALF_FLOAT* s = (HALF_FLOAT*)((char*)buffer + rowPitch * j);
        for(DWORD i = 0; i< width; i++)
        {
            d->R_s = s->R_s;
            d->R_e = s->R_e - 15 + 127;
            d->R_m = s->R_m << (23-10);
            d++;
            s++;
        }
    }
}

更新：

拆卸

; Listing generated by Microsoft (R) Optimizing Compiler Version 16.00.40219.01 

    TITLE   Utils.cpp
    .686P
    .XMM
    include listing.inc
    .model  flat

INCLUDELIB LIBCMT
INCLUDELIB OLDNAMES

PUBLIC  ?ConvertImageFrom_R16_FLOAT_To_R32_FLOAT@@YAXPADPAXKKI@Z ; ConvertImageFrom_R16_FLOAT_To_R32_FLOAT
; Function compile flags: /Ogtp
;   COMDAT ?ConvertImageFrom_R16_FLOAT_To_R32_FLOAT@@YAXPADPAXKKI@Z
_TEXT   SEGMENT
_buffer$ = 8                        ; size = 4
tv83 = 12                       ; size = 4
_convertedData$ = 12                    ; size = 4
_width$ = 16                        ; size = 4
_height$ = 20                       ; size = 4
_rowPitch$ = 24                     ; size = 4
?ConvertImageFrom_R16_FLOAT_To_R32_FLOAT@@YAXPADPAXKKI@Z PROC ; ConvertImageFrom_R16_FLOAT_To_R32_FLOAT, COMDAT

; 323  : {

    push    ebp
    mov ebp, esp

; 343  :    for(DWORD j = 0; j< height; j++)

    mov eax, DWORD PTR _height$[ebp]
    push    esi
    mov esi, DWORD PTR _convertedData$[ebp]
    test    eax, eax
    je  SHORT $LN4@ConvertIma

; 324  :    union SINGLE_FLOAT {
; 325  :        struct {
; 326  :            unsigned __int32 R_m : 23;
; 327  :            unsigned __int32 R_e : 8;
; 328  :            unsigned __int32 R_s : 1;
; 329  :        };
; 330  :        struct {
; 331  :            float r;
; 332  :        };
; 333  :    };
; 334  :    C_ASSERT(sizeof(SINGLE_FLOAT) == 4);
; 335  :    struct HALF_FLOAT
; 336  :    {
; 337  :        unsigned __int16 R_m : 10;
; 338  :        unsigned __int16 R_e : 5;
; 339  :        unsigned __int16 R_s : 1;
; 340  :    };
; 341  :    C_ASSERT(sizeof(HALF_FLOAT) == 2);
; 342  :    SINGLE_FLOAT* d = (SINGLE_FLOAT*)convertedData;

    push    ebx
    mov ebx, DWORD PTR _buffer$[ebp]
    push    edi
    mov DWORD PTR tv83[ebp], eax
$LL13@ConvertIma:

; 344  :    {
; 345  :        HALF_FLOAT* s = (HALF_FLOAT*)((char*)buffer + rowPitch * j);
; 346  :        for(DWORD i = 0; i< width; i++)

    mov edi, DWORD PTR _width$[ebp]
    mov edx, ebx
    test    edi, edi
    je  SHORT $LN5@ConvertIma
    npad    1
$LL3@ConvertIma:

; 347  :        {
; 348  :            d->R_s = s->R_s;

    movzx   ecx, WORD PTR [edx]
    movzx   eax, WORD PTR [edx]
    shl ecx, 16                 ; 00000010H
    xor ecx, DWORD PTR [esi]
    shl eax, 16                 ; 00000010H
    and ecx, 2147483647             ; 7fffffffH
    xor ecx, eax
    mov DWORD PTR [esi], ecx

; 349  :            d->R_e = s->R_e - 15 + 127;

    movzx   eax, WORD PTR [edx]
    shr eax, 10                 ; 0000000aH
    and eax, 31                 ; 0000001fH
    add eax, 112                ; 00000070H
    shl eax, 23                 ; 00000017H
    xor eax, ecx
    and eax, 2139095040             ; 7f800000H
    xor eax, ecx
    mov DWORD PTR [esi], eax

; 350  :            d->R_m = s->R_m << (23-10);

    movzx   ecx, WORD PTR [edx]
    and ecx, 1023               ; 000003ffH
    shl ecx, 13                 ; 0000000dH
    and eax, -8388608               ; ff800000H
    or  ecx, eax
    mov DWORD PTR [esi], ecx

; 351  :            d++;

    add esi, 4

; 352  :            s++;

    add edx, 2
    dec edi
    jne SHORT $LL3@ConvertIma
$LN5@ConvertIma:

; 343  :    for(DWORD j = 0; j< height; j++)

    add ebx, DWORD PTR _rowPitch$[ebp]
    dec DWORD PTR tv83[ebp]
    jne SHORT $LL13@ConvertIma
    pop edi
    pop ebx
$LN4@ConvertIma:
    pop esi

; 353  :        }
; 354  :    }
; 355  : }

    pop ebp
    ret 0
?ConvertImageFrom_R16_FLOAT_To_R32_FLOAT@@YAXPADPAXKKI@Z ENDP ; ConvertImageFrom_R16_FLOAT_To_R32_FLOAT
_TEXT   ENDS
4

10 回答 10

3

x86 F16C 指令集扩展增加了对单精度浮点向量与半精度浮点向量之间的转换的硬件支持。

格式与您描述的 IEEE 754 半精度二进制 16 相同。我没有检查字节顺序是否与您的结构相同，但如果需要（使用pshufb）很容易修复。

从 Intel IvyBridge 和 AMD Piledriver 开始支持 F16C。（并且有它自己的 CPUID 功能位，您的代码应该检查它，否则回退到 SIMD 整数移位和洗牌）。

VCVTPS2PH的内在函数是：

__m128i _mm_cvtps_ph ( __m128 m1, const int imm);
__m128i _mm256_cvtps_ph(__m256 m1, const int imm);

立即字节是舍入控制。编译器可以将其用作直接转换并存储到内存的方式（与大多数可以选择使用内存操作数的指令不同，其中源操作数可以是内存而不是寄存器。）

VCVTPH2PS则相反，就像大多数其他 SSE 指令一样（可以在寄存器之间使用或作为负载使用）。

__m128 _mm_cvtph_ps ( __m128i m1);
__m256 _mm256_cvtph_ps ( __m128i m1)

F16C 非常高效，您可能需要考虑将图像保留为半精度格式，并在每次需要从中获取数据向量时进行动态转换。这对您的缓存占用空间非常有用。

于 2016-10-23T04:20:24.510 回答
2

当然，访问内存中的位域可能非常棘手，具体取决于架构。

如果您将浮点数和 32 位整数合并，并使用局部变量简单地执行所有分解和组合，您可能会获得更好的性能。这样，生成的代码可以仅使用处理器寄存器来执行整个操作。

于 2011-04-01T15:42:14.627 回答
2

这里有一些想法：

将常量放入const register变量中。

有些处理器不喜欢从内存中获取常量；这很尴尬，可能需要很多指令周期。

循环展开

重复循环中的语句，并增加增量。
处理器更喜欢连续指令；跳跃和树枝激怒了他们。

数据预取（或加载缓存）

在循环中使用更多变量，并将它们声明为volatile编译器不会优化它们： 

SINGLE_FLOAT* d = (SINGLE_FLOAT*)convertedData;
SINGLE_FLOAT* d1 = d + 1;
SINGLE_FLOAT* d2 = d + 2;
SINGLE_FLOAT* d3 = d + 3;
for(DWORD j = 0; j< height; j++)
{
    HALF_FLOAT* s = (HALF_FLOAT*)((char*)buffer + rowPitch * j);
    HALF_FLOAT* s1 = (HALF_FLOAT*)((char*)buffer + rowPitch * (j + 1));
    HALF_FLOAT* s2 = (HALF_FLOAT*)((char*)buffer + rowPitch * (j + 2));
    HALF_FLOAT* s3 = (HALF_FLOAT*)((char*)buffer + rowPitch * (j + 3));
    for(DWORD i = 0; i< width; i += 4)
    {
        d->R_s = s->R_s;
        d->R_e = s->R_e - 15 + 127;
        d->R_m = s->R_m << (23-10);
        d1->R_s = s1->R_s;
        d1->R_e = s1->R_e - 15 + 127;
        d1->R_m = s1->R_m << (23-10);
        d2->R_s = s2->R_s;
        d2->R_e = s2->R_e - 15 + 127;
        d2->R_m = s2->R_m << (23-10);
        d3->R_s = s3->R_s;
        d3->R_e = s3->R_e - 15 + 127;
        d3->R_m = s3->R_m << (23-10);
        d += 4;
        d1 += 4;
        d2 += 4;
        d3 += 4;
        s += 4;
        s1 += 4;
        s2 += 4;
        s3 += 4;
    }
}
于 2011-04-01T17:28:35.697 回答
1

这些循环彼此独立，因此您可以通过使用 SIMD 或 OpenMP 轻松地并行化此代码，一个简单的版本会将图像的上半部分和下半部分分成两个线程，同时运行。

于 2011-04-01T15:30:02.490 回答
1

SSE Intrinsics 似乎是一个绝妙的主意。在你走这条路之前，你应该

  • 看编译器生成的汇编代码，（有没有优化的潜力？）

  • 搜索您的编译器文档如何自动生成 SSE 代码，

  • 在您的软件库的文档（或 16 位浮点类型的来源）中搜索用于批量转换此类型的函数。（转换为 64 位浮点也可能会有所帮助。）您很可能不是第一个遇到此问题的人！

如果这一切都失败了，那就去尝试一些 SSE 内在函数吧。为了得到一些想法，这里有一些 SSE 代码，用于将 32 位浮点转换为 16 位浮点。（你想要相反的）

除了 SSE，您还应该考虑多线程并将任务卸载到 GPU。

于 2011-04-01T15:51:10.157 回答
1

您正在将数据作为二维数组处理。如果您考虑它在内存中的布局方式，则可以将其作为一维数组处理，并且可以通过使用一个循环而不是嵌套循环来节省一点开销。

我还将编译为汇编代码并确保编译器优化工作并且它不会重新计算 (15 + 127) 数百次。

于 2011-04-01T15:55:41.353 回答
1

您应该能够将其减少到使用即将推出的CVT16 指令集的芯片上的单个指令。根据那篇维基百科文章：

The CVT16 instructions allow conversion of floating point vectors between single precision and half precision.

于 2011-04-01T15:59:29.667 回答
0

我怀疑这个操作在内存访问上已经成为瓶颈，并且提高它的效率（例如，使用 SSE）不会让它执行得更快。然而，这只是一个怀疑。

其他要尝试的事情，假设 x86/x64，可能是：

  • 不要d++and s++，而是在每次迭代中使用d[i]and 。s[i]（然后当然是在每条扫描线之后碰撞d。）由于元素d是4个字节，而元素是s2个，所以这个操作可以折叠到地址计算中。（不幸的是，我不能保证这一定会使执行更有效率。）
  • 删除位域操作并手动执行操作。（提取时，先移位，然后掩码，以最大化掩码适合小的立即值的可能性。）
  • 展开循环，尽管使用像这个一样容易预测的循环，它可能没有太大区别。
  • width沿着每条线从下到零计数。width这阻止了编译器每次都必须获取。可能对 x86 更重要，因为它的寄存器很少。（如果 CPU 喜欢我的 "d[i]和s[i]" 建议，您可以将宽度标记为有符号的，width-1改为从开始计数，然后向后走。）

尝试这些都比转换为 SSE 更快，并有望使其受内存限制，如果还没有的话，此时您可以放弃。

最后，如果输出在写入组合内存中（例如，它是纹理或顶点缓冲区或通过 AGP 或 PCI Express 访问的东西，或者现在 PC 拥有的任何东西），那么这很可能会导致性能下降，具体取决于什么编译器为内部循环生成的代码。因此，如果是这种情况，您可能会获得更好的结果，将每个扫描线转换为本地缓冲区，然后使用memcpy将其复制到其最终目的地。

于 2011-04-01T18:49:26.623 回答
0

我不知道 SSE 内在函数，但看到你的内部循环的反汇编会很有趣。一种老式的方法（可能没有多大帮助，但很容易尝试）是通过执行两个内部循环来减少迭代次数：一个执行 N（比如 32）次重复处理（循环计数宽度/ N）然后一个完成余数（宽度％N的循环计数）......在第一个循环之外计算那些div和模以避免重新计算它们。抱歉，如果这听起来很明显！

于 2011-04-01T15:41:56.977 回答
0

该功能只是做一些小事情。通过优化来节省很多时间是很困难的，但正如有人已经说过的那样，并行化是有希望的。

检查您获得了多少缓存未命中。如果数据正在分页进出，您可以通过在排序中应用更多智能以最小化缓存交换来加快速度。

还要考虑宏观优化。数据计算中是否有任何可以避免的冗余（例如缓存旧结果而不是在需要时重新计算它们）？你真的需要转换整个数据集还是只转换你需要的位？我不知道您的应用程序，所以我只是在这里疯狂地猜测，但这种优化可能还有空间。

于 2011-04-01T16:07:31.730 回答