performance ISPC vs LLVM Clang

[iperov]

I compared the performance ISPC vs LLVM Clang (portable version from zig via pip install ziglang)

export void test(uniform float vout[], uniform float vin[], uniform int count, uniform float q, uniform float x, uniform float y) {
    foreach (index = 0 ... count) {
        float v = vin[index];
        vout[index] = v >= q ? x : y;
    }
}

vs

extern "C" __declspec(dllexport) void c_test(float* vout, float* vin, int count, float q, float x, float y) 
{    
    for (int i=0; i<count; ++i)
    {
        float v = vin[i];
        vout[i] = v >= q ? x : y;
    }
}

ISPC shows only 10% boost.

main loop asm

ISPC:

.text:0000000000000040                 mov     r11d, r10d
.text:0000000000000043                 and     r11d, 0FFFFFFE0h
.text:0000000000000047                 vcmpps  ymm6, ymm2, ymmword ptr [rdx+r11], 2
.text:000000000000004E                 vblendvps ymm6, ymm5, ymm4, ymm6
.text:0000000000000054                 vmovups ymmword ptr [rcx+r11], ymm6
.text:000000000000005A                 add     rax, 8
.text:000000000000005E                 add     r10, 20h
.text:0000000000000062                 cmp     rax, r9
.text:0000000000000065                 jb      short loc_40

Clang:

.text:000000018001CC40                 vcmpps  ymm6, ymm2, ymmword ptr [rdx+r10], 2
.text:000000018001CC47                 vcmpps  ymm7, ymm2, ymmword ptr [rdx+r10+20h], 2
.text:000000018001CC4F                 vcmpps  ymm8, ymm2, ymmword ptr [rdx+r10+40h], 2
.text:000000018001CC57                 vcmpps  ymm9, ymm2, ymmword ptr [rdx+r10+60h], 2
.text:000000018001CC5F                 vblendvps ymm6, ymm5, ymm4, ymm6
.text:000000018001CC65                 vblendvps ymm7, ymm5, ymm4, ymm7
.text:000000018001CC6B                 vblendvps ymm8, ymm5, ymm4, ymm8
.text:000000018001CC71                 vblendvps ymm9, ymm5, ymm4, ymm9
.text:000000018001CC77                 vmovups ymmword ptr [rcx+r10], ymm6
.text:000000018001CC7D                 vmovups ymmword ptr [rcx+r10+20h], ymm7
.text:000000018001CC84                 vmovups ymmword ptr [rcx+r10+40h], ymm8
.text:000000018001CC8B                 vmovups ymmword ptr [rcx+r10+60h], ymm9
.text:000000018001CC92                 sub     r10, 0FFFFFFFFFFFFFF80h
.text:000000018001CC96                 cmp     r8, r10
.text:000000018001CC99                 jnz     short loc_18001CC40

as we can see clang vectorizes the func very well.

So should I migrate to ISPC which gives only a small performance gain, with programs needing to be rewritten in a different form, and with the chance that the library will be discontinued in the future and will not continue to receive updates for new processors?

[samayala22]

This is a trivial example and any good compiler will be able to auto-vectorize this.

ISPC shines when you need to write big kernels that are potentially calling other sub functions. It guarantees that the code will be vectorized thanks to its SPMD syntax, while any other compiler will fail miserably.

Also, ISPC is available on all major platforms, which means that the generated code will be consistent and the performance truly portable.

ISPC is the best way to write vectorized code for CPUs and nothing comes close.

[iperov]

can you show non trivial example?

[samayala22]

Sorry didn't see that you replied.

Example: vectorized find index of maximum value

ispc version: godbolt
c++ version: goldbolt (untested code)

ispc is 8-10x faster for floats. Assembly is very close to the optimal implementation (https://github.com/komrad36/FastArrayOps).

Really anything big or with conditional branches will break traditional C/C++ compiler autovectorizers.