From 16a726257e1f3eda866c35af11d10a34b93dee57 Mon Sep 17 00:00:00 2001 From: scottstraughan <42965777+scottstraughan@users.noreply.github.com> Date: Tue, 2 Sep 2025 10:40:51 +0100 Subject: [PATCH] Small tweaks to fix missing thumbnail. --- _collections/_authors/nicolas-miller.markdown | 7 + .../_portal_posts/2025-08-20-gromacs.md | 995 ++++++++++++++++++ .../2025-08-20-gromacs/thumbnail.webp | Bin 0 -> 120358 bytes 3 files changed, 1002 insertions(+) create mode 100644 _collections/_authors/nicolas-miller.markdown create mode 100644 _collections/_portal_posts/2025-08-20-gromacs.md create mode 100644 assets/images/portal/article-images/2025-08-20-gromacs/thumbnail.webp diff --git a/_collections/_authors/nicolas-miller.markdown b/_collections/_authors/nicolas-miller.markdown new file mode 100644 index 0000000..586737e --- /dev/null +++ b/_collections/_authors/nicolas-miller.markdown @@ -0,0 +1,7 @@ +--- +user_id: 5011213131 +disabled: 0 +title: "Nicolas Miller" +position: Senior Software Engineer +avatar: /assets/images/portal/authors/missing.png +--- diff --git a/_collections/_portal_posts/2025-08-20-gromacs.md b/_collections/_portal_posts/2025-08-20-gromacs.md new file mode 100644 index 0000000..883e6f5 --- /dev/null +++ b/_collections/_portal_posts/2025-08-20-gromacs.md @@ -0,0 +1,995 @@ +--- +category: blogs +date: '2025-08-20T02:00:00.0' +hidden: false +layout: portal/portal-article-view +thumbnail: /assets/images/portal/article-images/2025-08-20-gromacs/thumbnail.webp +title: 'Tracking down a register allocator bug' +user_id: 5011213131 +--- + +This article describes the investigation of a bug found when running +[GROMACS](https://www.gromacs.org/) testing using SYCL with the [DPC++ +compiler](https://github.com/intel/llvm/) while targeting AMD GPUs. + +This was initially reported in the `intel/llvm` GitHub repository issue-tracker +[intel/llvm#6209](https://github.com/intel/llvm/issues/6209/) and was using a +[specific +version](https://gitlab.com/gromacs/gromacs/-/tree/aa-hwe-release-2022-dpcpp-hip) +of GROMACS with SYCL support. + +This bug will take us from the GROMACS source code all the way down to the +register allocation in the compiler backend. + +## Description of the issue + +When running one of the GROMACS tests built with DPC++ targeting AMD, the test +crashes with the following output: + +```console +Memory access fault by GPU node-4 (Agent handle: 0x215c1f0) on address 0x7ff5f0d6d000. Reason: Page not present or supervisor privilege. +Aborted (core dumped) +``` + +This error indicates that the kernel is accessing invalid memory, for example +this can happen in simple out-of-bounds accesses. + +It is reported that this issue appears on MI50 ([gfx906 +ISA](https://developer.amd.com/wp-content/resources/Vega_7nm_Shader_ISA.pdf)), +and MI200 ([gfx90a +ISA](https://developer.amd.com/wp-content/resources/CDNA2_Shader_ISA_4February2022.pdf)), +but that it doesn't fail on MI100 ([gfx908 +ISA](https://developer.amd.com/wp-content/resources/CDNA1_Shader_ISA_14December2020.pdf)). + +The specific test is being run as follows: + +```console +SYCL_DEVICE_FILTER=hip:gpu ./bin/mdrun-pull-test +``` + +## Finding the kernel + +The GROMACS application contains a lot of kernels so the first step is to figure +out exactly which kernel is causing the issue. + +One easy way to do that is to use the ROCm debug environment variable +`AMD_LOG_LEVEL=4`. We can then find the last `ShaderName` debug output before +the crash: + +``` +:3:rocvirtual.cpp :2738: 6536108370963 us: 24086: [tid:0x7f5e78ab4740] ShaderName : _ZTS11NbnxmKernelILb1ELb1ELN5Nbnxm8ElecTypeE1ELNS0_7VdwTypeE1EE +``` + +Which gives us the name of the last kernel to run on the GPU, which is almost +certainly the kernel that caused the access fault. This debug output gives us +the kernel name in its mangled form, but using the `c++filt` tool we can easily +turn it into a more readable format, and so we get: + +``` +c++filt _ZTS11NbnxmKernelILb1ELb1ELN5Nbnxm8ElecTypeE1ELNS0_7VdwTypeE1EE +typeinfo name for NbnxmKernel +``` + +Alternatively we can use the ROCm debugger `rocgdb`, simply running the program +under `rocgdb` after the segfault the debugger will show which kernel it +happened in and also allow us to disassemble the kernel. Using the debugger can +unfortunately only go so far because debug information is not supported in DPC++ +for AMD targets. + +With the debugger we get the following: + +``` +Thread 3 "mdrun-pull-test" received signal SIGBUS, Bus error.↩ +[Switching to thread 3, lane 0 (AMDGPU Lane 4:13:1:1/0 (0,0,0)[0,0,0])]↩ +0x00007fffe5297078 in typeinfo name for NbnxmKernel () from file:///path/to/gromacs/build/lib/libgromacs.so.7 #offset=75955456&size=17664↩ +``` + +Using the `gdb` command `disas` we can then do our first proper analysis step +and look at the assembly dump showing on which instruction the memory access +fault is happening. + +``` +Dump of assembler code for function _ZTS11NbnxmKernelILb1ELb1ELN5Nbnxm8ElecTypeE1ELNS0_7VdwTypeE1EE: +[...] + 0x00007fffe5297064 <+1124>:| global_load_dwordx2 v[14:15], v[5:6], off offset:16 + 0x00007fffe529706c <+1132>:| s_waitcnt lgkmcnt(0) + 0x00007fffe5297070 <+1136>:| v_mov_b32_e32 v10, s41 + 0x00007fffe5297074 <+1140>:| s_mov_b32 s64, s80 +=> 0x00007fffe5297078 <+1144>:| s_waitcnt vmcnt(0) +[...] +``` + +The arrow indicates that the error is happening on the `s_waitcnt vmcnt(0)`. +This instruction waits for all the memory operations using vector registers to +be completed. Therefore the likely culprit in this case is actually the +`global_load_dwordx2` instruction above. + +At this point we know that the issue happens in the `NbnxmKernel` and from the +disassembly it seems likely to be caused by a load instruction, this is +consistent with the memory access fault issue we're seeing, the address used for +this load instruction must be incorrect in some way. + +## Comparing the assembly + +We know that the application works on `gfx908` but not on `gfx906` so a first +step can be to compare the assembly generated by both and see if any significant +differences can be identified. + +To obtain the assembly we can use the environment variable `SYCL_DUMP_IMAGES=1`, +this is a DPC++ environment variable which will dump all the available kernels +images when running an application. GROMACS is a fairly large application so we +end up with 309 `.bin` images. + +We can then use `grep` to search for the mangled kernel name we got out of +the debugger: + +``` +% grep _ZTS11NbnxmKernelILb1ELb1ELN5Nbnxm8ElecTypeE1ELNS0_7VdwTypeE1EE *.bin +Binary file sycl_amdgcn142.bin matches +``` + +The `.bin` files are HIP fat binaries, we can then extract the actual device +object file from them with: + +``` +clang-offload-bundler --unbundle --type=o --targets=hipv4-amdgcn-amd-amdhsa--gfx906 --input=sycl_amdgcn142.bin --output=sycl_amdgcn142.bin.o +``` + +And then disassemble the device objects with: + +``` +llvm-objdump -d sycl_amdgcn142.bin.o &> sycl_amdgcn142.s +``` + +Doing that for both architectures we end up with the assembly for both and we +can then use a diff tool to compare them. + +Unfortunately at this point the differences between the two are very significant +and it's very difficult to track down exactly where the offending instruction is +in the `gfx908` assembly, so more work will be required to make use of this and +we'll come back to it later. + +## Tracking down the issue in the source + +Knowing the kernel name we can find the source for it in GROMACS: + +``` +src/gromacs/nbnxm/sycl/nbnxm_sycl_kernel_body.h +``` + +* https://gitlab.com/gromacs/gromacs/-/blob/aa-hwe-release-2022-dpcpp-hip/src/gromacs/nbnxm/sycl/nbnxm_sycl_kernel_body.h#L663 + +Unfortunately for us this kernel is quite large and complicated, roughly 400 +lines of code with loops and many conditionals. And our debugging options are +very limited, indeed as mentioned above source level debugging is not available, +and neither is `printf`! Both of these are available in the regular AMD +toolchain but not yet enabled in DPC++ for AMD at the time of this +investigation. + +So as a way to get source level information on where this bug is happening we +used the horrible snippet of code below: + +```cpp +volatile int* crash = nullptr; +*crash++; +``` + +You see adding this in the body of a kernel will cause it to crash with a memory +access fault error nearly identical to the one caused by our bug, but since the +error message prints the address of the memory access fault it will always show +`0` if this piece of code caused it. And so this will show us if `*crash++` was +run before or after the offending line of code, which means that by moving +`*crash++` around in our kernel code and looking at the resulting error we can +eventually track down which line of code is causing the issue. + +After a lot of trial and error the [offending +line](https://gitlab.com/gromacs/gromacs/-/blob/aa-hwe-release-2022-dpcpp-hip/src/gromacs/nbnxm/sycl/nbnxm_sycl_kernel_body.h#L793/) +in the kernel source was identified to be: + +``` +unsigned imask = a_plistCJ4[j4].imei[imeiIdx].imask; +``` + +This matches what we were expecting since this line loads from both `a_plistCJ4` +and then from `imei`, so it must be that either one of these loads triggers the +error. + +In addition, we also observed that the error never happens on the first +iteration of the loop this line is in, this information will become important +later on. + +At this stage the obvious next step is to check whether `j4` or `imeiIdx` are +out of bounds for what they're indexing. A cursory look through the code didn't +spot anything obvious that would suggest these indices may be wrong. But by that +point even though we still didn't have access to a proper `printf` we figured +out that it was possible to use lower level `printf` primitives provided by the +HIP toolchain from within the kernel, so we were able to try printing these +indices: + +``` +long msg = __ockl_fprintf_stdout_begin(); +msg = __ockl_fprintf_append_string_n(msg, "debug: %lu, %lu\n", 16, 0); +msg = __ockl_fprintf_append_args(msg, 2, j4, imeiIdx, 0, 0, 0, 0, 1); +``` + +Now surprisingly after adding this bit of code before the offending line the +program started working correctly! This is usually indicative that whatever we +did to the code caused the compiler take a different path and avoided triggering +the issue. + +Digging a little further around that idea, we found out that printing just +`imeiIdx` fixed the issue, and furthermore marking `imeiIdx` as `volatile` also +fixed the problem, and finally since we also know that the first iteration is +always correct, we also ended up figuring out that disabling loop unrolling with +`-fno-unroll-loops` also fixes the issue. + +So we now have a lot more information about what's going on and multiple ways of +avoiding the issue, so we're almost ready to dive back in the assembly to see +what we can figure out. But before we do, one of the helpful thing we can do is +to surround the offending line with barriers: + +``` +itemIdx.barrier(fence_space::local_space); +unsigned imask = a_plistCJ4[j4].imei[imeiIdx].imask; +itemIdx.barrier(fence_space::local_space); +``` + +Barriers are helpful because they're lowered to recognizable `s_barrier` +instructions and they limit how the compiler can re-organize the assembly around +them which makes it a lot easier to identify in the assembly where this line of +source code is. And luckily for us adding them doesn't fix the issue we're +seeing, so we can use them as a handy marker. + +## Diving back into the assembly + +Now we can look again at comparing assembly between all the different cases +we've identified, and see if we can spot what's incorrect: + +Assembly for `gfx906` with the extra barriers and no other modification, the +offending instruction is the `global_load_dword` at the bottom. The generated +assembly looks different than what we originally got in `rocgdb` but it still +triggers the error: + +``` +s_cbranch_scc1 2000 // 0000000020AC: BF8507D0 <_ZTS11NbnxmKernelILb1ELb1ELN5Nbnxm8ElecTypeE1ELNS0_7VdwTypeE1EE+0x23f0> +s_ashr_i32 s43, s42, 31 // 0000000020B0: 902B9F2A +s_lshl_b64 s[48:49], s[42:43], 5 // 0000000020B4: 8EB0852A +s_add_u32 s16, s40, s48 // 0000000020B8: 80103028 +v_lshlrev_b64 v[7:8], 3, v[8:9] // 0000000020BC: D28F0007 00021083 +s_addc_u32 s17, s41, s49 // 0000000020C4: 82113129 +s_waitcnt lgkmcnt(0) // 0000000020C8: BF8CC07F +v_mov_b32_e32 v6, s17 // 0000000020CC: 7E0C0211 +v_add_co_u32_e64 v5, s[16:17], s16, v7 // 0000000020D0: D1191005 00020E10 +v_addc_co_u32_e64 v6, s[16:17], v6, v8, s[16:17] // 0000000020D8: D11C1006 00421106 +s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) // 0000000020E0: BF8C0000 +s_barrier // 0000000020E4: BF8A0000 +global_load_dword v52, v[5:6], off offset:16 // 0000000020E8: DC508010 347F0005 +s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) // 0000000020F0: BF8C0000 +s_barrier +``` + +Assembly for `gfx906` with `imeiIdx` marked as `volatile` (test passing): + +``` +s_cbranch_scc1 2012 // 000000002114: BF8507DC <_ZTS11NbnxmKernelILb1ELb1ELN5Nbnxm8ElecTypeE1ELNS0_7VdwTypeE1EE+0x2488> +s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) +s_barrier // 00000000211C: BF8A0000 +buffer_load_dword v8, off, s[0:3], s33 offset:16 // 000000002120: E0500010 21000800 +s_nop 0 // 000000002128: BF800000 +buffer_load_dword v9, off, s[0:3], s33 offset:20 // 00000000212C: E0500014 21000900 +s_ashr_i32 s47, s46, 31 // 000000002134: 902F9F2E +s_lshl_b64 s[52:53], s[46:47], 5 // 000000002138: 8EB4852E +s_add_u32 s20, s44, s52 // 00000000213C: 8014342C +s_addc_u32 s21, s45, s53 // 000000002140: 8215352D +s_add_u32 s24, s20, 16 // 000000002144: 80189014 +s_addc_u32 s25, s21, 0 // 000000002148: 82198015 +v_mov_b32_e32 v7, s25 // 00000000214C: 7E0E0219 +s_mov_b32 s58, s81 // 000000002150: BEBA0051 +s_waitcnt vmcnt(0) // 000000002154: BF8C0F70 +flat_load_dword v11, v[8:9] glc // 000000002158: DC510000 0B000008 +s_waitcnt vmcnt(0) lgkmcnt(0) // 000000002160: BF8C0070 +v_lshlrev_b64 v[5:6], 3, v[11:12] // 000000002164: D28F0005 00021683 +v_add_co_u32_e64 v5, s[20:21], s24, v5 // 00000000216C: D1191405 00020A18 +v_addc_co_u32_e64 v6, s[20:21], v7, v6, s[20:21] // 000000002174: D11C1406 00520D07 +global_load_dword v51, v[5:6], off // 00000000217C: DC508000 337F0005 +s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) // 000000002184: BF8C0000 +s_barrier // 000000002188: BF8A0000 +``` + +With `volatile` the code is changed a fair bit, in particular a lot of the +address calculation code is moved inside the two barriers. But looking at the +assembly closely we can see that it is doing the same operations and the +`global_load_dword` at the bottom of that assembly snippet corresponds to the +offending `global_load_dword` in the previous snippet. + +The interesting part about the assembly with `volatile` is that it can help us +figure out what corresponds to `imeiIdx` in the assembly, here we can see the +instruction: + +``` +flat_load_dword v11, v[8:9] glc // 000000002158: DC510000 0B000008 +``` + +Just before the last stages of address computation before the +`global_load_dword` and that instruction is not in the snippet without +`volatile`. In addition looking at the ISA document for `gfx906` you can see +that `glc` stands for `Globally Coherent` and marks that this instruction +bypasses the L1 cache. So it is quite likely that `imeiIdx`, our `volatile` +variable is being loaded by this instruction, and so that in this assembly +snippet it would correspond to the vector register `v11`. + +We can then see how `v11` is used: + +``` +v_lshlrev_b64 v[5:6], 3, v[11:12] // 000000002164: D28F0005 00021683 +v_add_co_u32_e64 v5, s[20:21], s24, v5 // 00000000216C: D1191405 00020A18 +v_addc_co_u32_e64 v6, s[20:21], v7, v6, s[20:21] // 000000002174: D11C1406 00520D07 +global_load_dword v51, v[5:6], off // 00000000217C: DC508000 337F0005 +``` + +It is shifted by 3 into `v[5:6]`, as a register pair `v[11:12]`, then `v5` and +`v6` are used in the addition instructions, which outputs are then used as the +address for `global_load_dword`. + +We can then go back to the assembly of the case with errors and look for this +address computation pattern, to find which register corresponds to `imeiIdx`, +and we can easily find: + +``` +[...] +v_lshlrev_b64 v[7:8], 3, v[8:9] // 0000000020BC: D28F0007 00021083 +[...] +v_add_co_u32_e64 v5, s[16:17], s16, v7 // 0000000020D0: D1191005 00020E10 +v_addc_co_u32_e64 v6, s[16:17], v6, v8, s[16:17] // 0000000020D8: D11C1006 00421106 +s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) // 0000000020E0: BF8C0000 +s_barrier // 0000000020E4: BF8A0000 +global_load_dword v52, v[5:6], off offset:16 // 0000000020E8: DC508010 347F0005 +s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) // 0000000020F0: BF8C0000 +s_barrier +``` + +The shift by 3, followed by the two add instructions and then the load, +therefore in the broken assembly `imeiIdx` is stored in `v8`. + +So now that we know `v8` is supposed to be `imeiIdx` we can scroll up in the +assembly without `volatile` and find out how it's calculated, knowing that `v0` +and `v1` contain thread indices: + +``` +// v3 = v1 +v_mov_b32_e32 v3, v1 // 000000001C90: 7E060301 +[...] +// v15 = (v3 << 3) + v0 +// v15 = idy * 8 + idx // index flipped +v_lshl_add_u32 v15, v3, 3, v0 // 000000001D30: D1FD000F 04010703 +[...] +// v8 = v15 >> 5 +// v8 = v15 / 32 +v_lshrrev_b32_e32 v8, 5, v15 // 000000001F3C: 20101E85 +``` + +And noting that in the source `imeiIdx` is calculated by: + +``` +const unsigned tidxi = itemIdx.get_local_id(2);↩ +const unsigned tidxj = itemIdx.get_local_id(1);↩ +const unsigned tidx = tidxj * c_clSize + tidxi; +const unsigned imeiIdx = tidx / prunedClusterPairSize;↩ +``` + +With `c_clSize = 8` and `prunedClusterPairSize = 32`. + +So we can see that the calculation of `imeiIdx` before the loop is correct, this +is consistent with what we were seeing that the first iteration of the loop was +always correct. But we can look further into the loop after the load instruction +to see what happens to `v8`. + +And very quickly we can see that after the incorrect instruction `v8` is almost +immediately re-used and its value erased, and it doesn't seem to be spilled to +memory and re-loaded later or to have its value re-calculated: + +``` +v_ashrrev_i32_e32 v8, 31, v7 // 00000000210C: 22100E9F +``` + +At this point the suspicion is clear, `v8` which is supposed to contain +`imeiIdx` is overridden when it shouldn't be. However it's hard to say for sure +as the loop is thousands of instructions long. But we can try to confirm this by +comparing further with other cases that we know are working. + +Now comparing the same assembly for `gfx908` that we also know to be working, we +observe the following: + +``` +v_accvgpr_read_b32 v2, a8 // 000000002084: D3D84002 18000107 +v_add_co_u32_e64 v5, s[16:17], s16, v1 // 00000000208C: D1191005 00020210 +v_addc_co_u32_e64 v6, s[16:17], v6, v2, s[16:17] // 000000002094: D11C1006 00420506 +s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) // 00000000209C: BF8C0000 +s_barrier // 0000000020A0: BF8A0000 +global_load_dword v52, v[5:6], off offset:16 // 0000000020A4: DC508010 347F0005 +s_waitcnt vmcnt(0) expcnt(0) lgkmcnt(0) // 0000000020AC: BF8C0000 +s_barrier +``` + +In the `gfx908` snippet we see that the shift by 3 that we were observing +previously is not near the load but instead there is a `v_accvgpr_read_b32` +instruction. Looking further up in the assembly we can see that `imeiIdx` is +calculated outside of the loop as previously, but then its value is stored in a +register `a8`, and then loaded before the `global_load_dword`. And `a8` is not +written to anywhere else in the program so the value of `imeiIdx` will be +correct for the entire loop. + +Looking at the ISA documents we can see that `a8` is an ACC vector register, +these registers are part of the matrix multiplication unit, but it seems here +that it is used for spilling the value of `imeiIdx`, it is important to note +that `gfx906` doesn't have this matrix multiplication unit or ACC register and +that `gfx90a` MI200, which we know also fails, does have these registers, but +looking through the LLVM code base we could figure out that on `gfx90a` these +can be used as general purpose vector registers and so they are not used for +spilling like they are on `gfx908`. + +Furthermore we can also look at the assembly for `gfx906` but when loop +unrolling is disabled. In that scenario it looks just like the regular `gfx906` +however, the register matching `imeiIdx` is not re-used in the body of the loop. + +So we have a fairly strong idea of why it is failing, that is to say `v8` is +being incorrectly re-used, but we don't now why or how to fix it yet. + +## Diving further into the compiler + +Now we need to analyze what the compiler is doing and try to understand why `v8` +is re-used, but to do that we first need to narrow down a bit the compilation of +the kernels so we can look at what the compiler is doing without too much noise +from unrelated kernels. + +So first we build with verbose output to try and identify the compilation +commands for the `Nbnxm` kernel: + +``` +make VERBOSE=1 mdrun-pull-test -j$(nproc) +``` + +From that we see that the `Nbnxm` kernel is actually built in four different +configurations: + +``` +[ 28%] Building CXX object src/gromacs/CMakeFiles/libgromacs.dir/nbnxm/sycl/nbnxm_sycl_kernel_body_f_prune.cpp.o +[ 28%] Building CXX object src/gromacs/CMakeFiles/libgromacs.dir/nbnxm/sycl/nbnxm_sycl_kernel_body_f_noprune.cpp.o +[ 28%] Building CXX object src/gromacs/CMakeFiles/libgromacs.dir/nbnxm/sycl/nbnxm_sycl_kernel_body_fv_noprune.cpp.o +[ 28%] Building CXX object src/gromacs/CMakeFiles/libgromacs.dir/nbnxm/sycl/nbnxm_sycl_kernel_body_fv_prune.cpp.o +``` + +Going into that build directory we can use `grep` again to figure out which of +these contain our offending kernel: + +``` +% grep _ZTS11NbnxmKernelILb1ELb1ELN5Nbnxm8ElecTypeE1ELNS0_7VdwTypeE1EE * +Binary file nbnxm_sycl_kernel_body_fv_prune.cpp.o matches +``` + +Which means it's the `fv_prune` configuration that is causing issues. This `.o` +file here doesn't actually contain assembly, but LLVM IR bitcode, with DPC++ for +AMD the actual assembly is generated during the linking stage by `lld`. + +We can extract the bitcode with the `clang-offload-bundler`: + +``` +clang-offload-bundler --unbundle --type=o --targets=sycl-amdgcn-amd-amdhsa-gfx906 --input=nbnxm_sycl_kernel_body_fv_prune.cpp.o --output=fv_prune.bc +``` + +Now in theory we could then simply build this bitcode file with `llc` and get +similar assembly and use that to investigate the compiler, however trying that +produces assembly that is fairly different, so to manually reproduce what the +compiler is doing in the regular build we need to look further. + +As stated previously on AMD the assembly is generated during the link step by +`lld`, looking at the output of the verbose make command, we can identify the +linking stage: + +``` +/path/to/llvm/build/bin/clang++ -fPIC -O3 -DNDEBUG -shared -Wl,-soname,libgromacs.so.7 -o ../../lib/libgromacs.so.7.0.0 @CMakeFiles/libgromacs.dir/objects1.rsp -Wl,-rpath,/path/to/gromacs/build2/lib: -ffast-math -fsycl -fsycl-device-code-split=per_kernel -fsycl-targets=amdgcn-amd-amdhsa -Xsycl-target-backend --offload -arch=gfx906 -lrt ../external/build-fftw/fftwBuild-prefix/lib/libfftw3f.a -lpthread -ffast-math -fsycl -fsycl-device-code-split=per_kernel -fsycl-targets=amdgcn-amd-amdhsa -Xsycl-target-backend --offload-arch=gfx906 -lm ../../lib/libmuparser.so.2.3.2 -lm +``` + +The input files, including the `nbnxm_sycl_kernel_body_fv_prune.cpp.o` file +we're interested in are listed in the `objects1.rsp` file. We can then run this +command with `-###`, this will make the clang driver list all the underlying +commands that would be executed during this specific operation. + +The output of this is quite large as GROMACS is a large application so we'll +just show the interesting lines, but looking at it you can find a command +similar to the one we've used above to extract the bitcode: + +``` +"/path/to/llvm/build/bin/clang-offload-bundler" "-type=o" "-targets=host-x86_64-unknown-linux-gnu,sycl-amdgcn-amd-amdhsa-gfx906" "-input=CMakeFiles/libgromacs.dir/nbnxm/sycl/nbnxm_sycl_kernel_body_fv_prune.cpp.o" "-output=/tmp/nbnxm_sycl_kernel_body_fv_prune-b557cf.o" "-output=/tmp/nbnxm_sycl_kernel_body_fv_prune-ec4a19/nbnxm_sycl_kernel_body_fv_prune-gfx906.o" "-unbundle" "-allow-missing-bundles" +``` + +Then you can track the bitcode file being used in a very long `llvm-link` +command: + +``` +"/path/to/llvm/build/bin/llvm-link" [...] "/tmp/nbnxm_sycl_kernel_body_fv_prune-ec4a19/nbnxm_sycl_kernel_body_fv_prune-gfx906.o" [...] "-o" "/tmp/alignedallocator-a0f82a/alignedallocator-gfx906.bc" "--suppress-warnings" +``` + +This command links all the bitcode files from all the kernels in GROMACS +together into one very large bitcode file `alignedallocator-gfx906.bc`, this is +because with `SYCL_EXPORT` some symbols may be defined in different translation +units. + +Then `sycl-post-link` is used and splits this large bitcode file per kernel +instead of originally per translation unit: + +``` +"/path/to/llvm/build/bin/sycl-post-link" "-split=kernel" "-symbols" "-emit-exported-symbols" "-lower-esimd" "-O3" "-spec-const=default" "-o" "/tmp/alignedallocator-c32144/alignedallocator-gfx906.bc" "/tmp/alignedallocator-a0f82a/alignedallocator-gfx906.bc" +``` + +Since this is splitting one large bitcode files into a number of other bitcode +files the following commands working on the bitcode files will be wrapped in +`llvm-foreach`. And this is where we reach the command we're actually interested +in: + +``` +"/path/to/llvm/build/bin/llvm-foreach" "--out-ext=out" "--in-file-list=/tmp/alignedallocator-7746ed/alignedallocator-gfx906.o" "--in-replace=/tmp/alignedallocator-7746ed/alignedallocator-gfx906.o" "--out-file-list=/tmp/alignedallocator-d6ebb0/alignedallocator-gfx906.out" "--out-replace=/tmp/alignedallocator-d6ebb0/alignedallocator-gfx906.out" "--" "/path/to/llvm/build/bin/lld" "-flavor" "gnu" "--no-undefined" "-shared" "-plugin-opt=-amdgpu-internalize-symbols" "-plugin-opt=mcpu=gfx906" "-plugin-opt=O3" "-o" "/tmp/alignedallocator-d6ebb0/alignedallocator-gfx906.out" "/tmp/alignedallocator-7746ed/alignedallocator-gfx906.o" +``` + +This calls `lld` over all of the bitcode files, and this is the step that +actually ends up generating the assembly and object file. So we can try to +extract just the `lld` command and use that on our bitcode file we extracted +manually earlier: + +``` +"/path/to/llvm/build/bin/lld" "-flavor" "gnu" "--no-undefined" "-shared" "-plugin-opt=-amdgpu-internalize-symbols" "-plugin-opt=mcpu=gfx906" "-plugin-opt=O3" "-o" "fv_prune.out" "fv_prune.bc" +``` + +And then we can disassemble `fv_prune.out` with `llvm-objdump` and as opposed to +`llc` this file is actually very similar to our problematic assembly and shows +the pattern we are looking for of `v8` being overridden. + +Now that we have narrowed down building the `Nbnxm` kernel to a fairly simple +command we can move on to using one of the most powerful LLVM debugging tool: +`-print-after-all`, with this flag the LLVM compiler will print the IR and +Machine IR after every single pass or stage of the compiler. This is extremely +helpful to debug however it does produce huge amounts of output which is why we +couldn't use it on the commands building the entirety of GROMACS and had to +narrow it down first. + +``` +"/path/to/llvm/build/bin/lld" "-flavor" "gnu" "--no-undefined" "-shared" "-plugin-opt=-amdgpu-internalize-symbols" "-plugin-opt=mcpu=gfx906" "-plugin-opt=O3" "-o" "fv_prune.out" "fv_prune.bc" -mllvm -print-after-all -mllvm -filter-print-funcs=_ZTS11NbnxmKernelILb1ELb1ELN5Nbnxm8ElecTypeE1ELNS0_7VdwTypeE1EE &> print-after-all.txt +``` + +And `-filter-print-funcs` narrows down the output further to only the function +we're interested in. + +Now we can look through the output of this command and look for our problematic +instructions, so again the pattern of a load between two barriers, and starting +from the bottom of the file we end up finding the following Machine IR: + +``` +renamable $sgpr57 = S_ASHR_I32 renamable $sgpr56, 31, implicit-def dead $scc +renamable $sgpr58_sgpr59 = S_LSHL_B64 renamable $sgpr56_sgpr57, 5, implicit-def dead $scc +renamable $sgpr16 = S_ADD_U32 renamable $sgpr42, renamable $sgpr58, implicit-def $scc +renamable $vgpr7_vgpr8 = V_LSHLREV_B64_e64 3, $vgpr8_vgpr9, implicit $exec +renamable $sgpr17 = S_ADDC_U32 renamable $sgpr43, renamable $sgpr59, implicit-def dead $scc, implicit killed $scc +S_WAITCNT 49279 +$vgpr6 = V_MOV_B32_e32 killed $sgpr17, implicit $exec, implicit $exec +renamable $vgpr5, renamable $sgpr16_sgpr17 = V_ADD_CO_U32_e64 killed $sgpr16, killed $vgpr7, 0, implicit $exec +renamable $vgpr6, dead renamable $sgpr16_sgpr17 = V_ADDC_U32_e64 killed $vgpr6, killed $vgpr8, killed $sgpr16_sgpr17, 0, implicit $exec +S_WAITCNT 0 +S_BARRIER +renamable $vgpr50 = GLOBAL_LOAD_DWORD renamable $vgpr5_vgpr6, 16, 0, implicit $exec :: (load (s32) from %ir.1262, !tbaa !84, addrspace 1) +S_WAITCNT 0 +S_BARRIER +``` + +This is clearly our problematic code, we can see the two barriers, the load, the +shift by 3 and the additions, and we can see `vgpr8` being used, the important +instructions are the following: + +``` +[...] +renamable $vgpr7_vgpr8 = V_LSHLREV_B64_e64 3, $vgpr8_vgpr9, implicit $exec +[...] +renamable $vgpr6, dead renamable $sgpr16_sgpr17 = V_ADDC_U32_e64 killed $vgpr6, killed $vgpr8, killed $sgpr16_sgpr17, 0, implicit $exec +``` + +What is very interesting here is that in the `V_ADDC` instruction the `$vgpr8` +operand is marked `killed` which tells the compiler that the register is not +used after this instruction and can be re-used. This is why `v8` is being +re-used in the body of the loop. In addition even the shift by 3 is overriding +`v8` so it definitely won't be correct in the next iteration. + +So we scroll back up our `print-after-all.txt` file up until we find the first +pass that introduced these seemingly incorrect instructions, and we track it +down to: + +``` +# *** IR Dump After Virtual Register Rewriter (virtregrewriter) ***: +``` + +This is the first pass that introduces this killed `$vgpr8`, but this pass is +also the first pass where the Machine IR has machine registers, it runs right +after the register allocator to do the actual replacement between the virtual +registers and the newly allocated physical registers. + +Scrolling up further to look at the code after the greedy register allocator, we +can see that the code at that point looks like: + +``` +# *** IR Dump After Greedy Register Allocator (greedy) ***: +[...] +19776B| S_WAITCNT 0 +19792B| S_BARRIER +19824B| renamable $sgpr57 = S_ASHR_I32 renamable $sgpr56, 31, implicit-def dead $scc +19872B| renamable $sgpr58_sgpr59 = S_LSHL_B64 renamable $sgpr56_sgpr57, 5, implicit-def dead $scc +19888B| renamable $sgpr16 = S_ADD_U32 renamable $sgpr42, renamable $sgpr58, implicit-def $scc +19904B| renamable $sgpr17 = S_ADDC_U32 renamable $sgpr43, renamable $sgpr59, implicit-def dead $scc, implicit $scc +19936B| %3340:vgpr_32 = COPY killed renamable $sgpr17 +19944B| %3963:vreg_64 = V_LSHLREV_B64_e64 3, %3078:vreg_64, implicit $exec +19952B| %3962:vreg_64 = COPY %3963:vreg_64 +19960B| undef %893.sub0:vreg_64, renamable $sgpr16_sgpr17 = V_ADD_CO_U32_e64 killed $sgpr16, %3962.sub0:vreg_64, 0, implicit $exec +19976B| %893.sub1:vreg_64, dead renamable $sgpr16_sgpr17 = V_ADDC_U32_e64 %3340:vgpr_32, %3962.sub1:vreg_64, killed $sgpr16_sgpr17, 0, implicit $exec +20064B| %3772:vgpr_32 = GLOBAL_LOAD_DWORD %893:vreg_64, 16, 0, implicit $exec :: (load (s32) from %ir.1262, !tbaa !84, addrspace 1) +20080B| S_WAITCNT 0 +20096B| S_BARRIER +``` + +We can see the shift by 3, with virtual register `%3078`, that goes into +`%3963`, which is then copied to `%3962`, and then used as operand for the +addition, but as you can see at this point it is not yet marked killed. + +And looking at the pass before the register allocation we see the following +code: + +``` +4376B| %889:vreg_64 = V_LSHLREV_B64_e64 3, %3078:vreg_64, implicit $exec↩ +[...] +19776B| S_WAITCNT 0 +19792B| S_BARRIER +19824B| %887.sub1:sreg_64 = S_ASHR_I32 %887.sub0:sreg_64, 31, implicit-def dead $scc +19872B| %891:sreg_64 = S_LSHL_B64 %887:sreg_64, 5, implicit-def dead $scc +19888B| %3326:sreg_32 = S_ADD_U32 %692.sub2:sgpr_128, %891.sub0:sreg_64, implicit-def $scc +19904B| %3327:sreg_32 = S_ADDC_U32 %692.sub3:sgpr_128, %891.sub1:sreg_64, implicit-def dead $scc, implicit $scc +19936B| %3340:vgpr_32 = COPY %3327:sreg_32 +19944B| undef %893.sub0:vreg_64, %3334:sreg_64_xexec = V_ADD_CO_U32_e64 %3326:sreg_32, %889.sub0:vreg_64, 0, implicit $exec +19952B| %893.sub1:vreg_64, dead %3335:sreg_64_xexec = V_ADDC_U32_e64 %3340:vgpr_32, %889.sub1:vreg_64, %3334:sreg_64_xexec, 0, implicit $exec +20064B| %3772:vgpr_32 = GLOBAL_LOAD_DWORD %893:vreg_64, 16, 0, implicit $exec :: (load (s32) from %ir.1262, !tbaa !84, addrspace 1) +20080B| S_WAITCNT 0 +20096B| S_BARRIER +``` + +Looking at this code it's important to note that the shift by 3 is actually not +inside of the loop, it's before the loop starts and its value is simply used +inside of the loop for the additions. This code should work absolutely fine, but +it seems that the greedy register allocator moves this shift inside of the loop, +and then the virtual register rewriter marks the `v8` operand as killed. + +Now at this point in our investigation, we need to start debugging the actual +code of these passes to understand why they are doing these transformations and +try to figure out what is going wrong. One good way to start with that is to use +`-debug-only=regalloc`, this will print debugging output for the register +allocation. However it doesn't support the `-filter-print-funcs=` flag like +`-print-after-all` which leads to huge output so we need to reduce our bitcode +file a little further. + +To do that we can use `opt` to remove from the bitcode all the kernels we're not +interested in: + +``` +/path/to/llvm/build/bin/opt --internalize-public-api-list=_ZTS11NbnxmKernelILb1ELb1ELN5Nbnxm8ElecTypeE1ELNS0_7VdwTypeE1EE --internalize --globaldce fv_prune.bc -o fv_prune_trimmed.bc +``` + +This command will mark `internal` all the functions that are not listed in the +`--internalize-public-api-list` flag, and then run a `globaldce` pass which will +eliminate all the internal symbols. This trims down our bitcode file quite +significantly. + +Then we can also run the compilation up until right before the greedy register +allocator, this way we can just run the passes we're trying to debug: + +``` +"/path/to/llvm/build/bin/lld" "-flavor" "gnu" "--no-undefined" "-shared" "-plugin-opt=-amdgpu-internalize-symbols" "-plugin-opt=mcpu=gfx906" "-plugin-opt=O3" "-o" "pre_greedy.mir" "fv_prune_trimmed.bc" -mllvm -stop-before=greedy +``` + +`lld` is not really setup to use this `stop-before` parameter and so it will +crash but not before giving us the output we want in `pre_greedy.mir`, this will +now contain the Machine IR before the greedy register allocator, the one with +the shift by 3 outside of the loop. + +We can then use `llc` to run only the specific pass and get debug output from +register allocation: + +``` +/path/to/llvm/build/bin/llc -start-before=greedy -stop-after=virtregrewriter -mcpu=gfx906 -debug-only=regalloc pre_greedy.mir -o post_regalloc.mir &> regalloc.txt +``` + +This command will run just the passes between `greedy` and `virtregrewriter`, +and print debug output for the register allocation `-debug-only=regalloc`. The +names for the passes can be seen in the `-print-after-all` dumps in parenthesis +next to the longer name of the passes. Note that this `regalloc` name can be +found in the source of the passes mentioned above, for example in: + +``` +/path/to/llvm/llvm/lib/CodeGen/RegAllocGreedy.cpp +``` + +Under: + +``` +#define DEBUG_TYPE "regalloc"↩ +``` + +This in turns control the `LLVM_DEBUG` directives in that file and places them +under the `regalloc` keyword. + +So now that we have the debug output from the register allocation we can look +through that, and to find what we're looking for we can simply look for the +virtual registers that we spotted above so `%3078`, and we find the following +debug output: + +``` +Removing 1 back-copies. +Removing 16328r|%3961:vreg_64 = COPY %890:vreg_64 + blit [3440r,3488B:0): [3440r;3488B)=0(%3961)(recalc) + blit [16192B,38336B:0): [16192B;16312r)=0(%3961)(recalc) [16312r;16336r)=1(%3962)(recalc) [16336r;38336B)=0(%3961)(recalc) + rewr %bb.6| 3440r:0|%3961:vreg_64 = V_LSHLREV_B64_e64 3, %3078:vreg_64, implicit $exec + rewr %bb.90| 16320B:1| undef %894.sub0:vreg_64, %3334:sreg_64_xexec = V_ADD_CO_U32_e64 %3326:sreg_32, %3962.sub0:vreg_64, 0, implicit $exec + rewr %bb.90| 16336B:1| %894.sub1:vreg_64, dead %3335:sreg_64_xexec = V_ADDC_U32_e64 %3340:vgpr_32, %3962.sub1:vreg_64, %3334:sreg_64_xexec, 0, implicit $exec + rewr %bb.90| 16312B:0| %3962:vreg_64 = COPY %3961:vreg_64 +queuing new interval: %3961 [3440r,3488B:0)[16192B,38336B:0) 0@3440r L000000000000000C [3440r,3488B:1)[16192B,38336B:1) 0@x 1@3440r L0000000000000003 [3440r,3488B:1)[1 6192B,38336B:1) 0@x 1@3440r weight:3.681593e-04 +Enqueuing %3961 +queuing new interval: %3962 [16312r,16336r:0) 0@16312r L000000000000000C [16312r,16336r:0) 0@16312r L0000000000000003 [16312r,16320r:0) 0@16312r weight:5.705815e-02↩ +Enqueuing %3962 + +selectOrSplit VReg_64:%3961 [3440r,3488B:0)[16192B,38336B:0) 0@3440r L000000000000000C [3440r,3488B:1)[16192B,38336B:1) 0@x 1@3440r L0000000000000003 [3440r,3488B:1)[1 6192B,38336B:1) 0@x 1@3440r weight:3.681593e-04 w=3.681593e-04 +RS_Spill Cascade 0 +should evict: %677 [96r,13936r:0)[16144B,38336B:0) 0@96r weight:6.930721e-05 w= 6.930721e-05 +should evict: %677 [96r,13936r:0)[16144B,38336B:0) 0@96r weight:6.930721e-05 w= 6.930721e-05 +Inline spilling VReg_64:%3961 [3440r,3488B:0)[16192B,38336B:0) 0@3440r L000000000000000C [3440r,3488B:1)[16192B,38336B:1) 0@x 1@3440r L0000000000000003 [3440r,3488B:1) [16192B,38336B:1) 0@x 1@3440r weight:3.681593e-04 +From original %890 +| remat: 16308r| %3963:vreg_64 = V_LSHLREV_B64_e64 3, %3078:vreg_64, implicit $exec +| 16312e| %3962:vreg_64 = COPY killed %3963:vreg_64 + +All defs dead: dead %3961:vreg_64 = V_LSHLREV_B64_e64 3, %3078:vreg_64, implicit $exec +Remat created 1 dead defs. +Deleting dead def 3440r|dead %3961:vreg_64 = V_LSHLREV_B64_e64 3, %3078:vreg_64, implicit $exec +unassigning %3078 from $vgpr8_vgpr9: VGPR8_LO16 VGPR8_HI16 VGPR9_LO16 VGPR9_HI16 +Enqueuing %3078 +Shrink: %3078 [2224r,2240r:0)[2240r,3488B:1)[16192B,38336B:1) 0@2224r 1@2240r L0000000000000003 [2224r,3440r:0) 0@2224r L000000000000000C [2240r,3488B:0)[16192B,38336B :0) 0@2240r weight:1.520717e-01 +``` + +Now this is quite a lot so first let's roll back to the beginning of the debug +output where the full kernel is shown, we can see that at that point, the code +looks like this: + +``` +3440B| %890:vreg_64 = V_LSHLREV_B64_e64 3, %3078:vreg_64, implicit $exec +[...] +16320B| undef %894.sub0:vreg_64, %3334:sreg_64_xexec = V_ADD_CO_U32_e64 %3326:sreg_32, %890.sub0:vreg_64, 0, implicit $exec↩ +16336B| %894.sub1:vreg_64, dead %3335:sreg_64_xexec = V_ADDC_U32_e64 %3340:vgpr_32, %890.sub1:vreg_64, %3334:sreg_64_xexec, 0, implicit $exec↩ +16352B| %3772:vgpr_32 = GLOBAL_LOAD_DWORD %894:vreg_64, 16, 0, implicit $exec :: (load (s32) from %ir.imask97.i, !tbaa !75, addrspace 1)↩ +16368B| S_WAITCNT 0↩ +16384B| S_BARRIER↩ +``` + +In this snippet we can see that the shift by 3 is at `3440` in the code and that +the loop is around `163XX`, and also that at the beginning of the register +allocation, the shift by 3 is indeed outside of the loop as expected, so coming +back to the debug output, we first have: + +``` +Removing 1 back-copies. +Removing 16328r|%3961:vreg_64 = COPY %890:vreg_64 + blit [3440r,3488B:0): [3440r;3488B)=0(%3961)(recalc) + blit [16192B,38336B:0): [16192B;16312r)=0(%3961)(recalc) [16312r;16336r)=1(%3962)(recalc) [16336r;38336B)=0(%3961)(recalc) + rewr %bb.6| 3440r:0|%3961:vreg_64 = V_LSHLREV_B64_e64 3, %3078:vreg_64, implicit $exec + rewr %bb.90| 16320B:1| undef %894.sub0:vreg_64, %3334:sreg_64_xexec = V_ADD_CO_U32_e64 %3326:sreg_32, %3962.sub0:vreg_64, 0, implicit $exec + rewr %bb.90| 16336B:1| %894.sub1:vreg_64, dead %3335:sreg_64_xexec = V_ADDC_U32_e64 %3340:vgpr_32, %3962.sub1:vreg_64, %3334:sreg_64_xexec, 0, implicit $exec + rewr %bb.90| 16312B:0| %3962:vreg_64 = COPY %3961:vreg_64 +``` + +Now this is in the middle of the register allocation modifications so the code +changed a little bit but looks sort of the same, it seems that there's now a +copy inside of the loop of `%890` into `%3961` and that this is trying to remove +it. And we can see the modified instructions in the `rewr` part: + +``` + rewr %bb.6| 3440r:0|%3961:vreg_64 = V_LSHLREV_B64_e64 3, %3078:vreg_64, implicit $exec + rewr %bb.90| 16320B:1| undef %894.sub0:vreg_64, %3334:sreg_64_xexec = V_ADD_CO_U32_e64 %3326:sreg_32, %3962.sub0:vreg_64, 0, implicit $exec + rewr %bb.90| 16336B:1| %894.sub1:vreg_64, dead %3335:sreg_64_xexec = V_ADDC_U32_e64 %3340:vgpr_32, %3962.sub1:vreg_64, %3334:sreg_64_xexec, 0, implicit $exec + rewr %bb.90| 16312B:0| %3962:vreg_64 = COPY %3961:vreg_64 +``` + +So at this point the addition instructions that used to take `%890` take +`%3962`, the shift is now writing to `%3961` instead of `%890` and `%3961` is +copied into `%3962` before the additions. + +And at this stage the shift is still outside of the loop which seems fine, so we +can move on to the next part of the output, and namely the inline spilling part: + +``` +Inline spilling VReg_64:%3961 [3440r,3488B:0)[16192B,38336B:0) 0@3440r L000000000000000C [3440r,3488B:1)[16192B,38336B:1) 0@x 1@3440r L0000000000000003 [3440r,3488B:1) [16192B,38336B:1) 0@x 1@3440r weight:3.681593e-04 +From original %890 +| remat: 16308r| %3963:vreg_64 = V_LSHLREV_B64_e64 3, %3078:vreg_64, implicit $exec +| 16312e| %3962:vreg_64 = COPY killed %3963:vreg_64 +``` + +This is important because this is the first time we see the shift by 3 +instruction moved into the loop, as you can see in `16308` instead of `3440`. + +And you can then see the compiler delete the original shift instruction: + +``` +All defs dead: dead %3961:vreg_64 = V_LSHLREV_B64_e64 3, %3078:vreg_64, implicit $exec +Remat created 1 dead defs. +Deleting dead def 3440r|dead %3961:vreg_64 = V_LSHLREV_B64_e64 3, %3078:vreg_64, implicit $exec +``` + +And then restart the register allocation for it since the instruction was moved: + +``` +unassigning %3078 from $vgpr8_vgpr9: VGPR8_LO16 VGPR8_HI16 VGPR9_LO16 VGPR9_HI16 +Enqueuing %3078 +Shrink: %3078 [2224r,2240r:0)[2240r,3488B:1)[16192B,38336B:1) 0@2224r 1@2240r L0000000000000003 [2224r,3440r:0) 0@2224r L000000000000000C [2240r,3488B:0)[16192B,38336B :0) 0@2240r weight:1.520717e-01 +``` + +Now in practice it took a bit more debugging but here we can start to see where +the problem is coming from on the last line: + +``` +%3078 [2224r,2240r:0)[2240r,3488B:1)[16192B,38336B:1) 0@2224r 1@2240r L0000000000000003 [2224r,3440r:0) 0@2224r L000000000000000C [2240r,3488B:0)[16192B,38336B:0) 0@2240r +``` + +What this represents is the live ranges for the virtual register `%3078`, which +means the parts of the code where the register is considered "alive", so +essentially all the code between the instruction that defines the register and +its last use, but let's break it down a bit further: + +``` +[2224r,2240r:0)[2240r,3488B:1)[16192B,38336B:1) 0@2224r 1@2240r +``` + +This first part tracks the liveness of the full register, these live intervals +contain two "values" (and/or definitions), `0@2224r` and `1@2240r`, indeed if we +look at the full Machine IR: + +``` +2224B| undef %3078.sub0:vreg_64 = V_LSHRREV_B32_e32 5, %19:vgpr_32, implicit $exec +2240B| %3078.sub1:vreg_64 = V_MOV_B32_e32 0, implicit $exec↩ +``` + +This defines the two sub-registers of `%3078`. And so what the rest of the +notation shows us is that `%3078` is alive between `2224` and `2240` for value +`0`: `[2224r,2240r:0)`, then is alive between `2240` to `3488` for value `1`: +`[2240r,3488B:1)`, and then between `16192` to `38336` for value `1`: +`[16192B,38336B:1)`. + +Now as you can probably tell this notation of the live range seems a little +strange because it is for the full register, but here the values `0` and `1` are +only defining parts of the register, and so we need to look at the rest of the +representation of the live range which shows us information about the +sub-registers: + +``` +L0000000000000003 [2224r,3440r:0) 0@2224r +L000000000000000C [2240r,3488B:0)[16192B,38336B:0) 0@2240r +``` + +The notation here is similar to the notation above, with the initial value being +a mask representing a sub-register, in binary `0x3` is `0011` and `0xC` is +`1100`. And so looking at these two lines you can see that the first, `0x3` +represents `%3078.sub0` and `0xC` represents `%3078.sub1`. + +And so now we know that `%3078.sub0` is defined at `2224` and is alive between +`2224` and `3440`, which means it's alive until the shift by 3 but not further. +However `%3078.sub1` is defined at `2240` and is alive between `2240` and `3488` +which means it's alive past the shift, but not only that, it is also alive +between `16192` and `38336`, this second interval is important because it covers +the loop with our problematic load. + +Now that we understand the live intervals of `%3078` the problem becomes fairly +obvious when looking back at the inline spilling: + +``` +Inline spilling VReg_64:%3961 [3440r,3488B:0)[16192B,38336B:0) 0@3440r L000000000000000C [3440r,3488B:1)[16192B,38336B:1) 0@x 1@3440r L0000000000000003 [3440r,3488B:1) [16192B,38336B:1) 0@x 1@3440r weight:3.681593e-04 +From original %890 +| remat: 16308r| %3963:vreg_64 = V_LSHLREV_B64_e64 3, %3078:vreg_64, implicit $exec +| 16312e| %3962:vreg_64 = COPY killed %3963:vreg_64 +``` + +This code moved the shift by 3 inside the loop, but at `16308` where we know +that `%3078.sub0` is not alive, and this is the virtual register that ultimately +gets assigned to `v8`. And so it makes sense that `v8` was being re-used, +because as far as the compiler is aware it is not supposed to be used at that +point. + +Thus we're almost done, we know that the instruction is being incorrectly moved +into the loop, we just need to find how this error manifests in the code and how +to fix it. To do that we can simply search for the printed keywords such as +`remat: ` or `Inline spilling` and then follow the code from there. It took a +little more time until reaching the following code in +`LiveRangeEdit::allUsesAvailableAt`: + +```cpp +// Check that subrange is live at UseIdx. +if (MO.getSubReg()) { + const TargetRegisterInfo *TRI = MRI.getTargetRegisterInfo(); + LaneBitmask LM = TRI->getSubRegIndexLaneMask(MO.getSubReg()); + for (LiveInterval::SubRange &SR : li.subranges()) { + if ((SR.LaneMask & LM).none()) + continue; + if (!SR.liveAt(UseIdx)) + return false; + + // Early exit if all used lanes are checked. No need to continue. + LM &= ~SR.LaneMask; + if (LM.none()) + break; + } +} +``` + +The function this is in is trying to determine if all the uses of an +instructions are available at a given point, which is in turn used to determine +if it is valid to move the instruction there. And it is checking for +sub-register ranges, but only if the operand of the instruction is using a +sub-register. This is not the case for us, our shift instruction uses the full +register, but one of the sub-register is not alive at the destination, and so +this code ends up not checking our instruction for sub-ranges and incorrectly +moves the shift into the loop. + +The fix is then fairly simple, we just need to always check the sub-ranges when +they're available, and so tweaking the code above as follows resolved the issue: + +```cpp +// Check that subrange is live at UseIdx. +if (li.hasSubRanges()) { + const TargetRegisterInfo *TRI = MRI.getTargetRegisterInfo(); + unsigned SubReg = MO.getSubReg(); + LaneBitmask LM = SubReg ? TRI->getSubRegIndexLaneMask(SubReg) + : MRI.getMaxLaneMaskForVReg(MO.getReg()); +``` + +With this patch instead of checking the sub-ranges only if the instruction is +using a sub-register, it checks them if they exist, and if the instruction is +using the full register, it uses a mask containing both sub-registers to check +them both. + +And so, the inline spilling fails to move the shift instruction in the loop: + +``` +Inline spilling VReg_64:%3961 [3440r,3488B:0)[16192B,38336B:0) 0@3440r L000000000000000C [3440r,3488B:1)[16192B,38336B:1) 0@x 1@3440r L0000000000000003 [3440r,3488B:1) [16192B,38336B:1) 0@x 1@3440r weight:3.681593e-04 +From original %890 +| cannot remat for 16312e|%3962:vreg_64 = COPY %3961:vreg_64 +``` + +And since it can't "inline" the spill it simply resorts to a normal spill: + +``` +Merged spilled regs: SS#2 [3440r,3488B:0)[16192B,38336B:0) 0@x weight:0.000000e+00 +spillAroundUses %3961 +| rewrite: 3440r| %3963:vreg_64 = V_LSHLREV_B64_e64 3, %3078:vreg_64, implicit $exec + +| spill: 3448r| SI_SPILL_V64_SAVE killed %3963:vreg_64, %stack.2, $sgpr32, 0, implicit $exec :: (store (s64) into %stack.2, align 4, addrspace 5) +Checking redundant spills for 0@16312r in %3962 [16312r,16336r:0) 0@16312r L000000000000000C [16312r,16336r:0) 0@16312r L0000000000000003 [16312r,16320r:0) 0@16312r w eight:5.705815e-02 +Merged to stack int: SS#2 [3440r,3488B:0)[16192B,38336B:0) 0@x weight:0.000000e+00 +| folded: 16312r| %3962:vreg_64 = SI_SPILL_V64_RESTORE %stack.2, $sgpr32, 0, implicit $exec :: (load (s64) from %stack.2, align 4, addrspace 5) +``` + +And the code generated this way is now correct meaning that the GROMACS test now +passes on `gfx906`. + +## Conclusion + +Finding the root cause of this issue was an interesting journey that took us +from a molecular dynamics kernel all the way down to the AMD GPU ISAs. + +Through describing this journey, this blog post provides some insight on a +number of techniques that can be used either when debugging issues in the LLVM +project, in DPC++ , or when working in an environment with limited debugging +capabilities. And it also shows a glimpse into the DPC++ and LLVM components +used during the compilation of GPU kernels. Which may hopefully be helpful to +anyone wanting to learn more about these technologies. + +And in closing, the full patch fixing this specific issue was submitted to +upstream LLVM and promptly merged: + +* https://reviews.llvm.org/D131884 diff --git a/assets/images/portal/article-images/2025-08-20-gromacs/thumbnail.webp b/assets/images/portal/article-images/2025-08-20-gromacs/thumbnail.webp new file mode 100644 index 0000000000000000000000000000000000000000..cceba26399fc40d1098383458ffa31c760d8192d GIT binary patch literal 120358 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 literal 0 HcmV?d00001