What are the costs of failed store-to-load forwarding on x86?

by

It is not really a full answer, but still evidence that the penalty is visible.

MSVC 2022 benchmark, compiler with /std:c++latest.

#include <chrono>
#include <iostream>

struct alignas(16) S
{
    char* a;
    int* b;
};

extern "C" void init_fused_copy_unfused(int n, S & s2, S & s1);
extern "C" void init_fused_copy_fused(int n, S & s2, S & s1);
extern "C" void init_unfused_copy_unfused(int n, S & s2, S & s1);
extern "C" void init_unfused_copy_fused(int n, S & s2, S & s1);

int main()
{
    using namespace std::chrono;

    S s1, s2;
    constexpr int N = 1'000'000'000;
    auto t1 = system_clock::now();
    init_fused_copy_fused(N, s2, s1);
    auto t2 = system_clock::now();
    init_fused_copy_unfused(N, s2, s1);
    auto t3 = system_clock::now();
    init_unfused_copy_fused(N, s2, s1);
    auto t4 = system_clock::now();
    init_unfused_copy_unfused(N, s2, s1);
    auto t5 = system_clock::now();

    std::cout
     << "init fused copy fused     " << duration_cast<duration<double>>(t2 - t1) << "\n"
     << "init fused copy unfused   " << duration_cast<duration<double>>(t3 - t2) << "\n"
     << "init unfused copy fused   " << duration_cast<duration<double>>(t4 - t3) << "\n"
     << "init unfused copy unfused " << duration_cast<duration<double>>(t5 - t4) << "\n";
}

.code

c     db 0
i     dd 0

s     dq byte ptr [c], dword ptr [i]

ALIGN 16
init_fused_copy_fused PROC
    movups      xmm0,xmmword ptr [s]
    movups      xmmword ptr [r8],xmm0

    movups      xmm1,xmmword ptr [r8]
    movups      xmmword ptr [rdx], xmm1

    dec ecx
    jnz init_fused_copy_fused
    ret
init_fused_copy_fused ENDP


ALIGN 16
init_unfused_copy_fused PROC

    lea         rax, byte ptr [c]
    mov         qword ptr[r8], rax
    lea         rax, dword ptr [i]
    mov         qword ptr[r8 + 8], rax

    movups      xmm1,xmmword ptr [r8]
    movups      xmmword ptr [rdx], xmm1

    dec ecx
    jnz init_unfused_copy_fused
    ret
init_unfused_copy_fused ENDP

ALIGN 16
init_fused_copy_unfused PROC
    movups      xmm0,xmmword ptr [s]
    movups      xmmword ptr [r8],xmm0

    mov         rax, qword ptr[r8]
    mov         qword ptr[rdx], rax
    mov         rax, qword ptr[r8 + 8]
    mov         qword ptr[rdx +8], rax

    dec ecx
    jnz init_fused_copy_unfused
    ret
init_fused_copy_unfused ENDP


ALIGN 16
init_unfused_copy_unfused PROC

    lea         rax, byte ptr [c]
    mov         qword ptr[r8], rax
    lea         rax, dword ptr [i]
    mov         qword ptr[r8 + 8], rax

    mov         rax, qword ptr[r8]
    mov         qword ptr[rdx], rax
    mov         rax, qword ptr[r8 + 8]
    mov         qword ptr[rdx +8], rax

    dec ecx
    jnz init_unfused_copy_unfused
    ret
init_unfused_copy_unfused ENDP

END

init fused copy fused     0.664739s
init fused copy unfused   0.935631s
init unfused copy fused   4.34326s
init unfused copy unfused 1.02741s

CPU: Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz 2.21 GHz

I interpret the results as follows:

  • With fused init, the forwarding never fails. The difference between fused and unfused copy is within the benchmark error
  • With unfused init, the fused copy caused forwarding failure, causing a significant performance difference

More Related Contents:

  1. Which cache mapping technique is used in intel core i7 processor?
  2. Is LFENCE serializing on AMD processors?
  3. Where is the Write-Combining Buffer located? x86
  4. Are two store buffer entries needed for split line/page stores on recent Intel?
  5. How exactly do partial registers on Haswell/Skylake perform? Writing AL seems to have a false dependency on RAX, and AH is inconsistent
  6. What exactly happens when a skylake CPU mispredicts a branch?
  7. If I don’t use fences, how long could it take a core to see another core’s writes?
  8. Why is x86 little endian?
  9. Can the simple decoders in recent Intel microarchitectures handle all 1-µop instructions?
  10. Are load ops deallocated from the RS when they dispatch, complete or some other time?
  11. Why did Intel change the static branch prediction mechanism over these years?
  12. What is the maximum possible IPC can be achieved by Intel Nehalem Microarchitecture?
  13. Why is the loop instruction slow? Couldn’t Intel have implemented it efficiently?
  14. Micro fusion and addressing modes
  15. Can x86’s MOV really be “free”? Why can’t I reproduce this at all?
  16. Are loads and stores the only instructions that gets reordered?
  17. Is performance reduced when executing loops whose uop count is not a multiple of processor width?
  18. Why is Skylake so much better than Broadwell-E for single-threaded memory throughput?
  19. Globally Invisible load instructions
  20. How are x86 uops scheduled, exactly?
  21. Branch alignment for loops involving micro-coded instructions on Intel SnB-family CPUs
  22. 32-byte aligned routine does not fit the uops cache
  23. Which Intel microarchitecture introduced the ADC reg,0 single-uop special case?
  24. Assembly – How to score a CPU instruction by latency and throughput
  25. Difference between x86, x32, and x64 architectures?
  26. How has CPU architecture evolution affected virtual function call performance?
  27. Why does Intel hide internal RISC core in their processors?
  28. Cycles/cost for L1 Cache hit vs. Register on x86?
  29. What is the difference between Trap and Interrupt?
  30. How do the store buffer and Line Fill Buffer interact with each other?

Leave a Comment