Are load ops deallocated from the RS when they dispatch, complete or some other time?

by

The following experiments suggest that the uops are deallocated at some point before the load completes. While this is not a complete answer to your question, it might provide some interesting insights.

On Skylake, there is a 33-entry reservation station for loads (see https://stackoverflow.com/a/58575898/10461973). This should also be the case for the Coffee Lake i7-8700K, which is used for the following experiments.

We assume that R14 contains a valid memory address.

clflush [R14]
clflush [R14+512]
mfence

# start measuring cycles

mov RAX, [R14]
mov RAX, [R14]
...
mov RAX, [R14]

mov RBX, [R14+512]

# stop measuring cycles

mov RAX, [R14] is unrolled 35 times. A load from memory takes at least about 280 cycles on this system. If the load uops stayed in the 33-entry reservation station until completion, the last load could only start after more than 280 cycles and would need another ~280cycles. However, the total measured time for this experiment is only about 340 cycles. This indicates that the load uops leave the RS at some time before completion.

In contrast, the following experiments shows a case where most uops are forced to stay in the reservation until the first load completes:

mov RAX, R14
mov [RAX], RAX
clflush [R14]
clflush [R14+512]
mfence

# start measuring cycles

mov RAX, [RAX]
mov RAX, [RAX]
...
mov RAX, [RAX]

mov RBX, [R14+512]

# stop measuring cycles

The first 35 loads now have dependencies on each other. The measured time for this experiment is about 600 cycles.

The experiments were performed with all but one core disabled, and with the CPU governor set to performance (cpupower frequency-set --governor performance).

Here are the nanoBench commands I used:

./nanoBench.sh -unroll 1 -basic -asm_init "clflush [R14]; clflush [R14+512]; mfence" -asm "mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RAX, [R14]; mov RBX, [R14+512]"

./nanoBench.sh -unroll 1 -basic -asm_init "mov RAX, R14; mov [RAX], RAX; clflush [R14]; clflush [R14+512]; mfence" -asm "mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RAX, [RAX]; mov RBX, [R14+512]"

More Related Contents:

  1. Are two store buffer entries needed for split line/page stores on recent Intel?
  2. Which cache mapping technique is used in intel core i7 processor?
  3. What exactly happens when a skylake CPU mispredicts a branch?
  4. If I don’t use fences, how long could it take a core to see another core’s writes?
  5. Is LFENCE serializing on AMD processors?
  6. Why is x86 little endian?
  7. Where is the Write-Combining Buffer located? x86
  8. What are the costs of failed store-to-load forwarding on x86?
  9. Can the simple decoders in recent Intel microarchitectures handle all 1-µop instructions?
  10. how are barriers/fences and acquire, release semantics implemented microarchitecturally?
  11. How do the store buffer and Line Fill Buffer interact with each other?
  12. Why did Intel change the static branch prediction mechanism over these years?
  13. What is the maximum possible IPC can be achieved by Intel Nehalem Microarchitecture?
  14. Why is the loop instruction slow? Couldn’t Intel have implemented it efficiently?
  15. Micro fusion and addressing modes
  16. How exactly do partial registers on Haswell/Skylake perform? Writing AL seems to have a false dependency on RAX, and AH is inconsistent
  17. Are loads and stores the only instructions that gets reordered?
  18. Adding a redundant assignment speeds up code when compiled without optimization
  19. How are x86 uops scheduled, exactly?
  20. What is a Partial Flag Stall?
  21. Deoptimizing a program for the pipeline in Intel Sandybridge-family CPUs
  22. 32-byte aligned routine does not fit the uops cache
  23. Size of store buffers on Intel hardware? What exactly is a store buffer?
  24. x86 registers: MBR/MDR and instruction registers
  25. How has CPU architecture evolution affected virtual function call performance?
  26. Why does Intel hide internal RISC core in their processors?
  27. What kind of address instruction does the x86 cpu have?
  28. How modern X86 processors actually compute multiplications?
  29. What is the difference between Trap and Interrupt?
  30. What specifically marks an x86 cache line as dirty – any write, or is an explicit change required?

Leave a Comment