A peculiar throughput limitation on Intel’s Xeon Phi x200 (Knights Landing)
In December 2017, my colleague Damon McDougall (now at AMD) asked for help in porting the fused multiply-add example code from a Colfax report (https://colfaxresearch.com/skl-avx512/) to the Xeon Phi x200 (Knights Landing) processors here at TACC. There was no deep goal — just a desire to see the maximum GFLOPS in action. The exercise seemed simple enough — just fix one item in the Colfax code and we should be finished. Instead, we found puzzle after puzzle. After almost four weeks, we have a solid characterization of the behavior — no tested code exceeds an execution rate of 12 vector pipe instructions every 7 cycles (6/7 of the nominal peak) when executed on a single core — but we are unable to propose a testable quantitative model for the source of the throughput limitation.
Dr. Damon McDougall gave a short presentation on this study at the IXPUG 2018 Fall Conference (pdf) — I originally wrote these notes to help organize my thoughts as we were preparing the IXPUG presentation, and later decided that the extra details contained here are interesting enough for me to post it.
The Xeon Phi x200 (Knights Landing) processor is Intel’s second-generation many-core product. The Xeon Phi 7250 processors at TACC have 68 cores per processor, and each core has two 512-bit SIMD vector pipelines. For 64-bit floating-point data, the 512-bit Fused Multiply-Add (FMA) instructions performs 16 floating-point operations (8 adds and 8 multiplies). Each of the two vector units can issue one FMA instruction per cycle, assuming that there are enough independent accumulators to tolerate the 6-cycle dependent-operation latency. The minimum number of independent accumulators required is: 2 VPUs times 6 cycles = 12 independent accumulators.
The Xeon Phi x200 has six execution units (two VPUs, two ALUs, and two Memory units), but is limited to two instructions per cycle by the decode, allocation, and retirement sections of the processor pipeline. (Most of the details of the Xeon Phi x200 series presented here are from the Intel-authored paper http://publications.computer.org/micro/2016/07/09/knights-landing-second-generation-intel-xeon-phi-product/.)
In our initial evaluation of the Xeon Phi x200, we did not fully appreciate the two-instruction-per-cycle limitation. Since “peak performance” for the processor is two (512-bit SIMD) FMA instructions per cycle, any instructions that are not FMA instructions subtract directly from the available peak performance. On “mainstream” Xeon processors, there is plenty of instruction decode/allocation/retirement bandwidth to overlap extra instructions with the SIMD FMA instructions, so we don’t usually even think about them. Pointer arithmetic, loop index increments, loop trip count comparisons, and conditional branches are all essentially “free” on mainstream Xeon processors, but have to be considered very carefully on the Xeon Phi x200.
A “best case” scenario: DGEMM
The double-precision matrix multiplication routine “DGEMM” is typically the computational kernel that achieves the highest fraction of peak performance on high performance computing systems. Hardware performance counter results for a simple benchmark code calling Intel’s optimized DGEMM implementation for this processor (from the Intel MKL library) show that about 20% of the dynamic instruction count consists of instructions that are not packed SIMD operations (i.e., not FMAs). These “non-FMA” instructions include the pointer manipulation and loop control required by any loop-based code, plus explicit loads from memory and a smaller number of stores back to memory. (These are in addition to the loads that can be “piggy-backed” onto FMA instructions using the single memory input operand available for most computational operations in the Intel instruction set). DGEMM implementations also typically require software prefetches to be interspersed with the computation to minimize memory stalls when moving from one “block” of the computation to the next.
Published DGEMM benchmark results for the Xeon Phi 7250 processor (https://software.intel.com/en-us/mkl/features/benchmarks) show maximum values of about 2100 GFLOPS when using all 68 cores (a very approximate estimate from a bar chart). Tests on one TACC development node gave slightly higher results — 2148 GFLOPS to 2254 GFLOPS (average = 2235 GFLOPS), for a set of 180 trials of a DGEMM test with M=N=K=8000 and using all 68 cores. These runs reported a stable average frequency of 1.495 GHz, so the average of 2235 GFLOPS therefore corresponds to 68.7% of the peak performance of (68 cores * 32 FP ops/cycle/core * 1.495 GHz =) 3253 GFLOPS (note1). This is an uninspiring fraction of peak performance that would normally suggest significant inefficiencies in either the hardware or software. In this case, however, the average of 2235 GFLOPS is more appropriately interpreted as 85.9% of the “adjusted peak performance” of 2602 GFLOPS (80% of the raw peak value — as limited by the instruction mix of the DGEMM kernel). At 85.9% of the “adjusted peak performance”, there is no longer a significant upside to performance tuning.
Notes on DGEMM:
- For recent processors with power-limited frequencies, compute-intensive kernels will experience an average frequency that is a function of the characteristics of the specific processor die and of the effectiveness of the cooling system at the time of the run. Other nodes will show lower average frequencies due to power/cooling limitations, so the numerical values must be adjusted accordingly — the percentage of peak obtained should be unchanged.
- It is possible to get higher values by disabling the L2 Hardware Prefetchers — up to about 2329 GFLOPS (89% of “adjusted peak”) — but that is a longer story for another day….
- The DGEMM efficiency values are not significantly limited by the use of all cores. Single-core testing with the same DGEMM routine showed maximum values of just under 72% of the nominal peak (about 90% of “adjusted peak”).
Please Note: The throughput limitation we observed (12 vector instructions per 7 cycles = 85.7% of nominal peak) is significantly higher than the instruction-issue-limited vector throughput of the best DGEMM measurement we have ever observed (~73% of peak, or approximately 10 vector instructions every 7 cycles). We are unaware of any real computational kernels whose optimal implementation will contain significantly fewer than 15% non-vector-pipe instructions, so the throughput limitation we observe is unlikely to be a significant performance limiter on any real scientific codes. This note is therefore not intended as a criticism of the Xeon Phi x200 implementation — it is intended to document our exploration of the characteristics of this performance limitation.
In order to approach the peak performance of the processor, we started with a slightly modified version of the code from the Colfax report above. This code is entirely synthetic — it performs repeated FMA operations on a set of registers with no memory references in the inner loop. The only non-FMA instructions are those required for loop control, and the number of FMA operations in the loop can be easily adjusted to change the fraction of “overhead” instructions. The throughput limitation can be observed on a single core, so the following tests and analysis will be limited to this case.
Using the minimum number of accumulator registers needed to tolerate the pipeline latency (12), the assembly code for the inner loop is:
..B1.8: addl $1, %eax vfmadd213pd %zmm16, %zmm17, %zmm29 vfmadd213pd %zmm16, %zmm17, %zmm28 vfmadd213pd %zmm16, %zmm17, %zmm27 vfmadd213pd %zmm16, %zmm17, %zmm26 vfmadd213pd %zmm16, %zmm17, %zmm25 vfmadd213pd %zmm16, %zmm17, %zmm24 vfmadd213pd %zmm16, %zmm17, %zmm23 vfmadd213pd %zmm16, %zmm17, %zmm22 vfmadd213pd %zmm16, %zmm17, %zmm21 vfmadd213pd %zmm16, %zmm17, %zmm20 vfmadd213pd %zmm16, %zmm17, %zmm19 vfmadd213pd %zmm16, %zmm17, %zmm18 cmpl $1000000000, %eax jb ..B1.8
This loop contains 12 independent 512-bit FMA instructions and is executed 1 billion times. Timers and hardware performance counters are measured immediately outside the loop, where their overhead is negligible. Vector registers zmm18-zmm29 are the accumulators, while vector registers zmm16 and zmm17 are loop-invariant.
The loop has 15 instructions, so must require a minimum of 7.5 cycles to issue. The three loop control instructions take 2 cycles (instead of 1.5) when measured in isolation. When combined with other instructions, the loop control instructions require 1.5 cycles when combined with an odd number of additional instructions or 2.0 cycles in combination with an even number of additional instructions — i.e., in the absence of other stalls, the conditional branch causes the loop cycle count to round up to an integer value. Equivalent sequences of two instructions that avoid the explicit compare instruction (e.g., pre-loading %eax with 1 billion and subtracting 1 each iteration) have either 1.0-cycle or 1.5-cycle overhead depending on the number of additional instructions (again rounding up to the nearest even cycle count). The 12 FMA instructions are expected to require 6 cycles to issue, for a total of 8 cycles per loop iteration, or 8 billion cycles in total. Experiments showed a highly repeatable 8.05 billion cycle execution time, with the 0.6% extra cycles almost exactly accounted for by the overhead of OS scheduler interrupts (1000 per second on this CentOS 7.4 kernel). Note that 12 FMAs in 8 cycles is only 75% of peak, but the discrepancy here can be entirely attributed to loop overhead.
Further unrolling of the loop decreases the number of “overhead” instructions, and we expected to see an asymptotic approach to peak as the loop length was increased. We were disappointed.
The first set of experiments compared the cycle and instruction counts for the loop above with the results from unrolling loop two and four times. The table below shows the expected and measured instruction counts and cycle counts.
KNL 12-accumulator FMA throughput
|FMA instructions per unrolled loop iteration
|Non-FMA instructions per unrolled loop iteration
|Total Instructions per unrolled loop iteration
|Expected instructions (B)
|Measured Instructions (B)
|Expected Cycles (B)
|Measured Cycles (B)
|Unexpected Cycles (B)
|Expected %Peak GFLOPS
|Measured %Peak GFLOPS
|% Performance shortfall
Notes on methodology:
- The unrolling was controlled by a “#pragma unroll_and_jam()” directive in the source code. In each case the assembly code was carefully examined to ensure that the loop structure matched expectations — 12,24,48 FMAs with the appropriate ordering (for dependencies) and the same 3 loop control instructions (but with the iteration count reduced proportionately for the unrolled cases).
- The node was allocated privately, non-essential daemons were disabled, and the test thread was bound to a single logical processor.
- Instruction counts were obtained inline using the RDPMC instruction to read Fixed-Function Counter 0 (INST_RETIRED.ANY), while cycle counts were obtained using the RDPMC instruction to read Fixed-Function Counter 1 (CPU_CLK_UNHALTED.THREAD).
- Execution time was greater than 4 seconds in all cases, so the overhead of reading the counters was at least 7 orders of magnitude smaller than the execution time.
- Each test was run at least three times, and the trial with the lowest cycle count was used for the analysis in the table.
Comments on results:
- The 12-FMA loop required 0.7% more cycles than expected.
- Later experiments show that this overhead is essentially identical to the the fraction of cycles spent servicing the 1-millisecond OS scheduler interrupt.
- The 24-FMA loop required 1.2% more cycles than expected.
- About half of these extra cycles can be explained by the OS overhead, leaving an unexplained overhead in the 0.5%-0.6% range (not large enough to worry about).
- The 48-FMA loop required 8.3% more cycles than expected.
- Cycle count variations across trials varied by no more than 1 part in 4000, making this overhead at least 300 times the run-to-run variability.
- The two unrolled cases gave performance results that appear to be bounded above by 6/7 (85.71%) of peak.
Initial (Incorrect) Hypothesis
My immediate response to the results was that this was a simple matter of running out of rename registers. Modern processors (almost) all have more physical registers than they have register names. The hardware automatically renames registers to avoid false dependencies, but with deep execution pipelines (particularly for floating-point operations), it is possible to run out of rename registers before reaching full performance.
This is easily illustrated using Little’s Law from queuing theory, which can be expressed as:
Throughput = Concurrency / Occupancy
For this scenario, “Throughput” has units of register allocations per cycle, “Concurrency” is the number of registers in use in support of all of the active instructions, and “Occupancy” is the average number of cycles that a register is busy during the execution of an instruction.
An illustrative example:
The IBM POWER4 has 72 floating-point rename registers and two floating-point arithmetic units capable of executing fused multiply-add (FMA) instructions (a = b+c*d). Each FMA instruction requires four registers, and these registers are all held for some number of cycles (discussed below), so full performance (both FMA units starting new operations every cycle) would require eight registers to be allocated each cycle (and for these registers to remain occupied for the duration of the corresponding instruction). We can estimate the duration by reviewing the execution pipeline diagram (Figure 2-3) in The POWER4 Processor Introduction and Tuning Guide. The exact details of when registers are allocated and freed is not published, but if we assume that registers are allocated in the “MP” stage (“Mapping”) and held until the “CP” (“Completion”, aka “retirement”) stage, then the registers will be held for a total of 12 cycles. The corresponding pipeline stages from Figure 2-3 are: MP, ISS, RF, F1, F2, F3, F4, F5, F6, WB, Xfer, CP.
Restating this in terms of Little’s Law, the peak performance of 2 FMAs per cycle corresponds to a “Throughput” of 8 registers allocated per cycle. With an “Occupancy” of 12 cycles for each of those registers, the required “Concurrency” is 8*12 = 96 registers. But, as noted above, the POWER4 only has 72 floating-point rename registers. If we assume a maximum “Concurrency” of 72 registers, the “Throughput” can be computed as 72/12 = 6 registers per cycle, or 75% of the target throughput of 8 registers allocated per cycle. It is perhaps not a coincidence that the maximum performance I ever saw on DGEMM on a POWER4 system (while working for IBM in the POWER4 design team) was just under 70% of 2 FMAs/cycle, or just over 92% of the occupancy-limited throughput of 1.5 FMAs/cycle.
For comparison, the IBM POWER5 processor (similar to POWER4, but with 120 floating-point rename registers) delivered up to 94% of 2 FMAs/cycle on DGEMM, suggesting that a DGEMM efficiency in the 90%-95% of peak range is appropriate for DGEMM on this architecture family.
Applying this model to Xeon Phi x200 is slightly more difficult for a number of reasons, but back-of-the-envelope estimates suggested that it was plausible.
The usual way of demonstrating that rename register occupancy is limiting performance is to change the instructions to reduce the number of registers used per instruction, or the number of cycles that the instructions hold the register, or both. If this reduces the required concurrency to less than the number of available rename registers, full performance should be obtained.
Several quick tests with instructions using fewer registers (e.g., simple addition instead of FMA) or with fewer registers and shorter pipeline latency (e.g, bitwise XOR) showed no change in throughput — the processor still delivered a maximum throughput of 12 vector instructions every 7 cycles.
Our curiosity was piqued by these results, and more experiments followed. These piqued us even more, eventually leading to a suite of several hundred experiments in which we varied everything that we could figure out how to vary.
We will spare the reader the chronological details, and instead provide a brief overview of the scope of the testing that followed.
Additional experiments (each performed with multiple degrees of unrolling) that showed no change in the limitation of 12 vector instructions per 7 cycles included:
- Increasing the dependency latency from 6 cycles to 8 cycles (i.e., using 16 independent vector accumulators) and extending the unrolling to up to 128 FMAs per inner loop iteration.
- Increasing the dependency latency to 10 cycles (20 independent vector accumulators), with unrolling to test 20, 40, 60, 80 FMAs per inner loop iteration.
- Increasing the dependency latency to 12 cycles (24 independent vector accumulators).
- Replacing the 512-bit VFMADD213PD instructions with the scalar version VFMADD213SD. (This is the AVX-512 EVEX-encoded instruction, not the VEX-encoded version.)
- Replacing the 512-bit VFMADD213PD instructions with the AVX2 (VEX-encoded) 256-bit versions.
- Increasing the number of loop-invariant registers used from 2 to 4 to 8 (and ensuring that consecutive instructions used different pairs of loop-invariant registers).
- Decreasing the number of loop-invariant registers per FMA from 2 to 1, drawing the other input from the output of an FMA instruction at least 12 instructions (6 cycles) away.
- Replacing the VFMADD213PD instructions with shorter-latency instructions (VPADDQ and VPXORQ were tested independently).
- Replacing the VFMADD213PD instructions with an instruction that has both shorter latency and fewer operands: VPABSQ (which has only 1 input and 1 output register).
- Replacing every other VFMADD213PD instruction with a shorter-latency instruction (VPXORQ).
- Replacing the three-instruction loop control (add, compare, branch) with two-instruction loop control (subtract, branch). The three-instruction version counts up from zero, then compares to the iteration count to set the condition code for the terminal conditional branch. The two-instruction version counts down from the target iteration count to zero, allowing us to use the condition code from the subtract (i.e., not zero) as the branch condition, so no compare instruction is required. The instruction counts changed as expected, but the cycle counts did not.
- Forcing 16-Byte alignment for the branch target at the beginning of the inner loop. (The compiler did this automatically in some cases but not in others — we saw no difference in cycle counts when we forced it to occur).
- Many (not all) of the executable files were disassembled with “objump -d” to ensure that the encoding of the instructions did not exceed the limit of 3 prefixes or 8 Bytes per instruction. We saw no cases where either of these rules were violated in the inner loops.
Additional experiments showed that the throughput limitation only applies to instructions that execute in the vector pipes:
- Replacing the Vector instructions with integer ALU instructions (ADDL) –> performance approached two instructions per cycle asymptotically, as expected.
- Replacing the Vector instructions with Load instructions from L1-resident data (to vector registers) –> performance approached two instructions per cycle asymptotically, as expected.
Some vector instructions can execute in only one of the two vector pipelines. This is mentioned in the IEEE Micro paper linked above, but is discussed in more detail in Chapter 17 of the document “Intel 64 and IA-32 Architectures Optimization Reference Manual”, (Intel document 248966, revision 037, July 2017). In addition, Agner Fog’s “Instruction Tables” document (http://www.agner.org/optimize/instruction_tables.pdf) shows which of the two vector units is used for a large subset of the instructions that can only execute in one of the VPUs. This allows another set of experiments that show:
- Each vector pipeline can sustain its full rate of 1 instruction per cycle when used in isolation.
- VPU0 was tested with VPERMD, VPBROADCASTQ, and VPLZCNT.
- VPU1 was tested with KORTESTW.
- Alternating a VPU0 instruction (VPLZCNTQ) with a VPU1 instruction (KORTESTW) showed the same 12 instruction per 7 cycle throughput limitation as the original FMA case.
- Alternating a VPU0 instruction with an FMA (that can be executed in either VPU) showed the same 12 instruction per 7 cycle throughput limitation as the original FMA case.
- This was tested with VPERMD and VPLZCNT as the VPU0 instructions.
- One specific combination of VPU0 and FMA instructions gave a reduced throughput of 1 vector instruction per cycle: VPBROADCASTQ alternating with FMA.
- VPBROADCASTQ requires a read from a GPR (in the integer side of the core), then broadcasts the result across all the lanes of a vector register.
- This operation is documented (in the Intel Optimization Reference Manual) as having a latency of 2 cycles and a maximum throughput of 1 per cycle (as we saw with VPBROADCASTQ running in isolation).
- The GPR to VPU move is a sufficiently uncommon access pattern that it is not particularly surprising to find a case for which it inhibits parallelism across the VPUs, though it is unclear why this is the only case we found that allows the use of both vector pipelines but is still limited to 1 instruction per cycle.
Additional Performance Counter Measurements and Second-Order Effects:
After the first few dozens of experiments, the test codes were augmented with more hardware performance counters. The full set of counters measured before and after the loop includes:
- Time Stamp Counter (TSC)
- Fixed-Function Counter 0 (Instructions Retired)
- Fixed-Function Counter 1 (Core Cycles Not Halted)
- Fixed-Function Counter 2 (Reference Cycles Not Halted)
- Programmable PMC0
- Programmable PMC1
The TSC was collected with the RDTSC instruction, while the other five counters were collected using the RDPMC instruction. The total overhead for measuring these six counters is about 250 cycles, compared to a minimum of 4 billion cycles for the monitored loop.
Several programmable performance counter events were collected as “sanity checks”, with negligible counts (as expected):
Another programmable performance counter event was collected to verify that the correct number of VPU instructions were being executed:
- Typical result:
- Nominal expected 16,000,000,000
- Measured in user-space: 16,000,000,016
- This event does not count the 16 loads before the inner loop, but does count the 16 stores after the end of the inner loop.
- Measured in kernel-space: varied from 19,626 to 21,893.
- Not sure why the kernel is doing packed SIMD instructions, but these are spread across more than 6 seconds of execution time (>6000 scheduler interrupts).
- These kernel instruction counts are 6 orders of magnitude smaller than the counts for tested code, so they will be ignored here.
- Typical result:
The performance counter events with the most interesting results were:
- NO_ALLOC_CYCLES.RAT_STALL — counts the number of core cycles in which no micro-ops were allocated and the “RAT Stall” (reservation station full) signal is asserted.
- NO_ALLOC_CYCLES.ROB_FULL — counts the number of core cycles in which no micro-ops were allocated and the Reorder Buffer (ROB) was full.
- RS_FULL_STALL.ALL — counts the number of core cycles in which the allocation pipeline is stalled and any of the Reservation Stations is full
- This should be the same as NO_ALLOC_CYCLES.RAT_STALL, and in all but one case the numbers were nearly identical.
- The RS_FULL_STALL.ALL event includes a Umask of 0x1F — five bits set.
- This is consistent with the IEEE Micro paper (linked above) that shows 2 VPU reservation stations, 2 integer reservation stations, and one memory unit reservation station.
- The only other Umask defined in the Intel documentation is RS_FULL_STALL.MEC (“Memory Execution Cluster”) with a value of 0x01.
- Directed testing with VPU0 and VPU1 instructions shows that a Umask of 0x08 corresponds to the reservation station for VPU0 and a Umask of 0x10 corresponds to the reservation station for VPU1.
For the all-FMA test cases that were expected to sustain more than 12 VPU instructions per 7 cycles, the NO_ALLOC_CYCLES.RAT_STALL and RS_FULL_STALL.ALL events were a near-perfect match for the number of extra cycles taken by the loop execution. The values were slightly larger than computation of “extra cycles”, but were always consistent with the assumption of 1.5 cycles “overhead” for the three loop control instructions (matching the instruction issue limit), rather than the 2.0 cycles that I assumed as a baseline. This is consistent with a NO_ALLOC_CYCLES.RAT_STALL count that overlaps with cycles that are simultaneously experiencing a branch-related pipeline bubble. One or the other should be counted as a stall, but not both. For these cases, the NO_ALLOC_CYCLES.ROB_FULL counts were negligible.
Interestingly, the individual counts for RS_FULL_STALL for the two vector pipelines were sometimes of similar magnitude and sometimes uneven, but were extremely stable for repeated runs of a particular binary. The relative counts for the stalls in the two vector pipelines can be modified by changing the code alignment and/or instruction ordering. In limited tests, it was possible to make either VPU report more stalls than the other, but in every case, the “effective” stall count (VPU0 stalled OR VPU1 stalled) was the amount needed to reduce the throughput to 12 VPU instructions every 7 cycles.
When interleaving vector instructions of different latencies, the total number of stall cycles remained the same (i.e., enough to limit performance to 12 VPU instructions per 7 cycles), but these were split between RAT_STALLs and ROB_STALLs in different ways for different loop lengths. Typical results showed a pattern like:
- 16 VPU instructions per loop iteration: approximately zero stalls, as expected
- 32 VPU instructions per loop iteration: approximately 6.7% RAT_STALLs and negligible ROB_STALLs
- 64 VPU instructions per loop iteration: ~1% RAT_STALLs (vs ~10% in the all-FMA case) and about 9.9% ROB_STALLs (vs ~0% in the all-FMA case).
- Execution time increased by about 0.6% relative to the all-FMA case.
- 128 VPU instructions per loop iteration: negligible RAT_STALLS (vs ~12% in the all-FMA case) and almost 20% ROB_STALLS (vs 0% in the all-FMA case).
- Execution time increased by 9%, to a value that is ~2.3% slower than the 16-VPU-instruction case.
The conversion of RAT_STALLs to ROB_STALLs when interleaving instructions of different latencies does not seem surprising. RAT_STALLs occur when instructions are backed up before execution, while ROB_STALLs occur when instructions back up before retirement. Alternating instructions of different latencies seems guaranteed to push the shorter-latency instructions from the RAT to the ROB until the ROB backs up. The net slowdown at 128 VPU instructions per loop iteration is not a performance concern, since asymptotic performance is available with anywhere between 24 and (almost) 64 VPU instructions in the inner loop. These results are included because they might provide some insight into the nature of the mechanisms that limits throughput of vector instructions.
RAT_STALLs count the number of cycles in which the Allocate/Rename unit does not dispatch any micro-ops because a target Reservation Station is full. While this does not directly equate to execution stalls (i.e., no instructions dispatched from the Vector Reservation Station to the corresponding Vector Execution Pipe), the only way the Reservation Station can become full (given an instruction stream with enough independent instructions) is the occurrence of cycles in which instructions are received (from the Allocate/Rename unit), but in which no instruction can be dispatched. If this occurs repeatedly, the 20-entry Reservation Station will become full, and the RAT_STALL signal will be asserted to prevent the Allocate/Rename unit from sending more micro-ops.
An example code that generates RAT Stalls is a modification of the test code using too few independent accumulators to fully tolerate the pipeline latency. For example, using 10 accumulators, the code can only tolerate 5 cycles of the 6 cycle latency of the FMA operations. This inhibits the execution of the FMAs, which fill up the Reservation Station and back up to stall the Allocate/Rename. Tests with 10..80 FMAs per inner loop iteration show RAT_STALL counts that match the dependency stall cycles that are not overlapped with loop control stall cycles.
We know from the single-VPU tests that the 20-entry Reservation Station for each Vector pipeline is big enough for that pipeline’s operation — no stall cycles were observed. Therefore the stalls that prevent execution dispatch must be in the shared resources further down the pipeline. From the IEEE Micro paper, the first execution step is to read the input values from the “rename buffer and the register file”, after which the operations proceed down their assigned vector pipeline. The vector pipelines should be fully independent until the final execution step in which they write their output values to the rename buffer. After this, the micro-ops will wait in the Reorder Buffer until they can be retired in program order. If the bottleneck was in the retirement step, then I would expect the stalls to be attributed to the ROB, not the RAT. Since the stalls in the most common cases are overwhelming RAT stalls, I conclude that the congestion is not *directly* related to instruction retirement.
As mentioned above, the predominance of RAT stalls suggests that limitations at Retirement cannot be directly responsible for the throughput limitation, but there may be an indirect mechanism at work. The IEEE Micro paper’s section on the Allocation Unit says:
“The rename buffer stores the results of the in-flight micro-ops until they retire, at which point the results are transferred to the architectural register file.”
This comment is consistent with Figure 3 of the paper and with the comment that vector instructions read their input arguments from the “rename buffer and the register file”, implying that the rename buffer and register file are separate register arrays. In many processor implementations there is a single “physical register” array, with the architectural registers being the subset of the physical registers that are pointed to by a mapping vector. The mapping vector is updated every time instructions retire, but the contents of the registers do not need to be copied from one place to another. The description of the Knights Landing implementation suggests that at retirement, results are read from the “rename buffer” and written to the “register file”. This increases the number of ports required, since this must happen every cycle in parallel with the first step of each of the vector execution pipelines. It seems entirely plausible that such a design could include a systematic conflict (a “structural hazard”) between the accesses needed by the execution pipes and the accesses needed by the retirement unit. If this conflict is resolved in favor of the retirement unit, then execution would be stalled, the Reservation Stations would fill up, and the observed behavior could be generated. If such a conflict exists, it is clearly independent of the number of input arguments (since instructions with 1, 2, and 3 input arguments have the same behavior), leaving the single output argument as the only common feature. If such a conflict exists, it must almost certainly also be systematic — occurring independent of alignment, timing, or functional unit details — otherwise it seems likely that we would have seen at least one case in the hundreds of tests here that violates the 12/7 throughput limit.
Tests using a variant of the test code with much smaller loops (varying between 160 and 24,000 FMAs per measurement interval, repeated 100,000 times) also strongly support the 12/7 throughput limit. In every case the minimum cycle count over the 100,000 iterations was consistent with 12 VPU instructions every 7 cycles (plus measurement overhead).
The Intel Xeon Phi x200 (Knights Landing) appears to have a systematic throughput limit of 12 Vector Pipe instructions per 7 cycles — 6/7 of the nominal peak performance. This throughput limitation is not displayed by the integer functional units or the memory units. Due to the two-instruction-per-cycle limitations of allocate/rename/retire, this performance limit in the vector units is not expected to have an impact on “real” codes. A wide variety of tests were performed to attempt to develop quantitative models that might account for this limitation, but none matched the specifics of the observed timing and performance counts.
After Damon McDougall’s presentation at the IXPUG 2018 Fall Conference, we talked to a number of Intel engineers who were familiar with this issue. Unfortunately, we did not get a clear indication of whether their comments were covered by non-disclosure agreements, so if they gave us an explanation, I can’t repeat it….