[HLK] Modify Wave match test logic to support modifications in different lanes and vector position by joaosaffran · Pull Request #7991 · microsoft/DirectXShaderCompiler

joaosaffran · 2025-12-08T22:46:00Z

This patch modifies the Wave Match test to test modifications in different lanes and vector
indexes. This is achieved by forcing lanes 0, WAVE_SIZE/2 and WAVE_SIZE -1, to modify
the vector at indexes 0, WAVE_SIZE/2 or WAVE_SIZE -1, respectively.

… positions

alsepkow

Made some comments. It looks like we need a few fixes on this iteration still.

alsepkow · 2025-12-12T19:57:25Z

+    const UINT HighWaves = NumWaves - LowWaves;
+    LowWaveMask = (LowWaves < 64) ? (1ULL << LowWaves) - 1 : ~0ULL;
+    HighWaveMask = (HighWaves < 64) ? (1ULL << HighWaves) - 1 : ~0ULL;
+    LowBits &= LowWaveMask;


The assignment to LowBits and HighBits seems redundant? They're initialized to zero so the result of these operations will still always just be 0?

….com/joaosaffran/DirectXShaderCompiler into hlk/improve-wave-match-test-coverage

alsepkow · 2026-01-08T03:10:01Z

+  return Word;
+}
+
+void StoreWords(UINT *Dest, std::bitset<128> LanesState) {


Update LanesState to be a const reference to avoid the copy every time this is called.

alsepkow · 2026-01-09T02:33:24Z


-    const uint64_t LowExpected = ~1ULL & LowWaveMask;
-    const uint64_t HighExpected = ~0ULL & HighWaveMask;
+  const uint64_t LowActiveLanes = (LanesState & LowWaveMask).to_ullong();


I think LanesState is intended to represent if we expect the values between 'this' lane and other lanes to match? So, I don't think it actually represents a state? In other words, 'ChangedLanes' and 'UnchangedLanes' are intended to represent the expected values on lane for the comparison of each vector element across lanes (the definition of the WaveMatch intrinsic).

You could better convey this by changing the names 'UnchangedLanes' to 'DefaultExpectedValue'. And 'ChangedLanes' to 'ExpectedValue'.

alsepkow · 2026-01-09T02:36:05Z

+    const UINT MidLaneID = WaveSize / 2;
+    const UINT LastLaneID = std::min(WaveSize - 1, VectorSize - 1);
+
+    std::bitset<128> UnchangedLanes;


nit: I suggesting adding a comment to further clarify the reason for a bitest.
// Use a std::bitset<128> to represent the uint4 returned by WaveMatch as its convenient this way in c++ #Resolved

alsepkow · 2026-01-09T21:28:03Z

+  }
+
+  void WriteExpectedValueForLane(UINT *Dest, const UINT Lane,
+                                 const std::bitset<128> &LanesState) {


Suggested change

const std::bitset<128> &LanesState) {

const std::bitset<128> &ExpectedValue) {

alsepkow · 2026-01-09T21:29:02Z

+    HighWaveMask = ComputeWaveMask(HighWaves);
+  }
+
+  void WriteExpectedValueForLane(UINT *Dest, const UINT Lane,


Suggested change

void WriteExpectedValueForLane(UINT *Dest, const UINT Lane,

void WriteExpectedValueForLane(UINT *Dest, const UINT LaneID,

alsepkow · 2026-01-09T21:29:46Z

-    // WaveMatch as well.
+    // For this test, the shader arranges it so that lanes 0, WAVE_SIZE/2 and
+    // WAVE_SIZE-1 are different from all the other lanes, also those
+    // lanes modify the vector at positions 0, WAVE_SIZE/2 and WAVE_SIZE-1.


'WAVE_SIZE-1' Isn't accurate if the wave size is larger than the vector size

alsepkow · 2026-01-09T21:34:16Z

+
+struct WaveMatchExpectedResultWritter {
+private:
+  UINT LowWaves;


LowWave and HighWaves don't need to be members. You only use them to compute the wave mask when constructing the WaveMatchExpectedResultWriter

alsepkow · 2026-01-09T21:37:29Z

+    const uint64_t HighActiveLanes =
+        ((LanesState >> 64) & HighWaveMask).to_ullong();
+
+    const UINT LaneIndex = 4 * Lane;


nit: Naming, this isn't a 'LaneIndex'.
Just change it to something simple like 'I'

alsepkow · 2026-01-09T21:39:41Z

+
+    const UINT LaneIndex = 4 * Lane;
+    Dest[LaneIndex + 0] = static_cast<UINT>(LowActiveLanes);
+    Dest[LaneIndex + 1] = static_cast<UINT>(LowActiveLanes << 32);


Did you test this with values in the 'upper' half of the low/high lanes?
I think this and the subsequent shift should be a right shift, not a left shift?

The 32 bit shifts are correct, I just investigated it. I fixed another bug that I found investigating this though

You still swapped them to RHS though?

You are right, I change those to right shift, sorry for the confusion

alsepkow · 2026-01-10T00:34:23Z

+  WaveMatchExpectedResultWritter(UINT WaveSize) {
    const UINT LowWaves = std::min(64U, WaveSize);
-    const UINT HighWaves = WaveSize - LowWaves;
+    LowWaveMask = ComputeWaveMask(LowWaves);


Given that we only ever call ComputeWaveMask with a value of 64 or less we have no need for the helper anymore.

I removed the wrapper and made that a one-liner, however, I still need to check if the shift is below 64, because there is a bug when shifting 64 bits, that cause the number to be zeroed instead of being filled with one, damyan and I investigated and found this issue together.

alsepkow · 2026-01-10T00:44:50Z

-        (LowWaves < 64) ? (1ULL << LowWaves) - 1 : ~0ULL;
+  void WriteExpectedValueForLane(UINT *Dest, const UINT LaneID,
+                                 const std::bitset<128> &ExpectedValue) {
+    const uint64_t LowActiveLanes = (ExpectedValue & LowWaveMask).to_ullong();


nit: naming, while there is a relationship between the active lanes and the results. These values don't explicitly represent active/inactive lanes.

I would just call these low/high (or lo/hi as I've seen that in multiple places referencing similar things).

alsepkow · 2026-01-10T00:53:18Z

-    // all the other lanes. Besides that all other lines write their result of
-    // WaveMatch as well.
+static constexpr std::bitset<128> ComputeWaveMask(UINT NumWaves) {
+  return (NumWaves < 64) ? (1ULL << NumWaves) - 1 : ~0UL;


Just a note that ~0UL should have been ~0ULL, but we're getting rid of that anyways.

alsepkow

LGTM

damyanp

LGTM, some suggestions and a question.

damyanp · 2026-01-12T23:53:31Z

+            // Making sure all lanes finish updating their vectors.
+            AllMemoryBarrierWithGroupSync();


Out of interest, did you find that this was needed for the test to work?

I was under impression that this test arranged for only a single wave to run at a time, so I wouldn't think that this would have any effect.

Agree that the small size, and the test complexity, do make that likely unnecessary.

I just didn't want to rely on chance, I added that as a precaution to make sure my test results are always consistent.

If this test is designed to run a single wave then things will go wrong if more than one wave ends up running. Sprinkling memory barriers in because they might be needed can hide other bugs as well as make it harder to understand what the code is doing.

Seeing this I spent a good few minutes trying to read through to code to figure out where more than one wave might be dispatched.

damyanp

LGTM, one editorial suggestion.

damyanp · 2026-01-13T03:02:31Z


+static void WriteExpectedValueForLane(UINT *Dest, const UINT LaneID,
+                                      const std::bitset<128> &ExpectedValue) {
+  // We need the mask to always be 32 bits, this calculation assurers that.


Fix typo:

Suggested change

// We need the mask to always be 32 bits, this calculation assurers that.

// We need the mask to always be 32 bits, this calculation assures that.

My preference would be to remove this comment, it's pretty clear what the code is doing without it and the IMO the comment makes it harder to read.

Suggested change

// We need the mask to always be 32 bits, this calculation assurers that.

alsepkow

LGTM

modify test logic to test value changed in different waves and vector…

e89f1f3

… positions

github-project-automation Bot added this to HLSL Roadmap Dec 8, 2025

github-project-automation Bot moved this to New in HLSL Roadmap Dec 8, 2025

joaosaffran requested review from alsepkow and damyanp December 8, 2025 22:46

add Wave struct

343df5a

damyanp reviewed Dec 9, 2025

View reviewed changes

Comment thread tools/clang/unittests/HLSLExec/LongVectors.cpp Outdated

Comment thread tools/clang/unittests/HLSLExec/LongVectors.cpp Outdated

Comment thread tools/clang/unittests/HLSLExec/LongVectors.cpp Outdated

Comment thread tools/clang/unittests/HLSLExec/LongVectors.cpp Outdated

address comment from damyan

d1f0d9e

joaosaffran requested a review from damyanp December 9, 2025 19:57

alsepkow requested changes Dec 12, 2025

View reviewed changes

github-project-automation Bot moved this from New to In progress in HLSL Roadmap Dec 12, 2025

joaosaffran added 3 commits January 5, 2026 10:36

Merge branch 'main' into hlk/improve-wave-match-test-coverage

719ade7

Merge branch 'hlk/improve-wave-match-test-coverage' of https://github…

2eee5b6

….com/joaosaffran/DirectXShaderCompiler into hlk/improve-wave-match-test-coverage

address comments from alex

64779aa

joaosaffran requested a review from alsepkow January 5, 2026 23:35

change code to use bitset

f0d2cfd

alsepkow reviewed Jan 7, 2026

View reviewed changes

Comment thread tools/clang/unittests/HLSLExec/LongVectors.cpp Outdated

joaosaffran force-pushed the hlk/improve-wave-match-test-coverage branch from d884ec7 to f0d2cfd Compare January 7, 2026 20:04

fix xml editor formating

2138c2a

joaosaffran force-pushed the hlk/improve-wave-match-test-coverage branch from 79cc228 to 2138c2a Compare January 7, 2026 20:05

joaosaffran added 3 commits January 7, 2026 12:08

modify test to account for multiple lanes being modified

f958d39

fix editor auto messes

4986ef4

fix editor mess

c7775b7

joaosaffran requested a review from alsepkow January 7, 2026 20:40

alsepkow reviewed Jan 8, 2026

View reviewed changes

Comment thread tools/clang/unittests/HLSLExec/LongVectors.cpp Outdated

alsepkow reviewed Jan 8, 2026

View reviewed changes

Comment thread tools/clang/unittests/HLSLExec/LongVectors.cpp Outdated

alsepkow reviewed Jan 8, 2026

View reviewed changes

Comment thread tools/clang/unittests/HLSLExec/LongVectors.cpp Outdated

alsepkow reviewed Jan 8, 2026

View reviewed changes

Comment thread tools/clang/unittests/HLSLExec/LongVectors.cpp Outdated

alsepkow reviewed Jan 8, 2026

View reviewed changes

Comment thread tools/clang/unittests/HLSLExec/LongVectors.cpp

alsepkow reviewed Jan 9, 2026

View reviewed changes

fix naming and improve encapsulation

dd8e4e9

joaosaffran requested a review from alsepkow January 9, 2026 20:00

alsepkow reviewed Jan 9, 2026

View reviewed changes

fix bug in high wave logic

5c17f0c

joaosaffran requested a review from alsepkow January 9, 2026 23:50

alsepkow reviewed Jan 10, 2026

View reviewed changes

joaosaffran added 2 commits January 9, 2026 23:14

remove reduntant functions

72f1548

simplify function to convert 128 bitset into uint[4]

dbbbedc

joaosaffran requested a review from alsepkow January 12, 2026 20:32

alsepkow approved these changes Jan 12, 2026

View reviewed changes

damyanp requested changes Jan 12, 2026

View reviewed changes

address sugestions from damyan

e0360fb

damyanp approved these changes Jan 13, 2026

View reviewed changes

joaosaffran requested a review from alsepkow January 13, 2026 21:55

remove wave barier

1225174

joaosaffran requested a review from damyanp January 13, 2026 21:55

damyanp approved these changes Jan 13, 2026

View reviewed changes

joaosaffran enabled auto-merge (squash) January 13, 2026 22:13

alsepkow approved these changes Jan 13, 2026

View reviewed changes

joaosaffran merged commit f255809 into microsoft:main Jan 14, 2026
12 checks passed

github-project-automation Bot moved this from In progress to Done in HLSL Roadmap Jan 14, 2026

	const std::bitset<128> &LanesState) {
	const std::bitset<128> &ExpectedValue) {

	void WriteExpectedValueForLane(UINT *Dest, const UINT Lane,
	void WriteExpectedValueForLane(UINT *Dest, const UINT LaneID,

		// Making sure all lanes finish updating their vectors.
		AllMemoryBarrierWithGroupSync();

	// We need the mask to always be 32 bits, this calculation assurers that.
	// We need the mask to always be 32 bits, this calculation assures that.

Conversation

joaosaffran commented Dec 8, 2025

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

alsepkow left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

alsepkow Jan 9, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

alsepkow left a comment

Choose a reason for hiding this comment

Uh oh!

damyanp left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

damyanp left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

alsepkow left a comment

alsepkow Jan 9, 2026 •

edited

Loading