InterlockedSubtract workaround - memory barriers - hlsl

Question

I have a situation where I would love to have an InterlockedSubtract function in HLSL. InterlockedAdd works fine for integers, but I'm stuck using a RWByteAddressBuffer of uints - I'm using every single bit, and I would rather not resort to having an encode/decode function to make ints behave exactly like uints.
My current workaround looks like this:
uint oldValue = Source.Load(oldParent, y);
Source.InterlockedMin(oldParent, oldValue - 1, y);
The issue is that I understand that it is possible for these operations to be confused across several threads, like so:
Thread 1: Thread 2:
o1 = Source.Load(l) l = 10, o1 = 10
o2 = Source.Load(l) l = 10, o2 = 10
Source.InterlockedMin(l, o1 - 1) l = 9
Source.InterlockedMin(l, o2 - 1) l = 9
These would only decrement the value once, despite the two calls.
As I understand it, I can't just make it a one-liner, as the compiled instructions could desync anyway.
Is there a workaround I'm missing? I could refactor my code to use another uint as a subtraction counter, then use another kernel to subtract those from the actual counts, but I'd much prefer to keep it within one kernel.

Answer 1

Thanks #PeterCordes you were absolutely right.
I did something very simple to test:
HLSL
#pragma kernel Overflow
RWByteAddressBuffer buff;
uint ByteIndex(uint3 id)
{
return (id.x + id.y * 8) * 4;
}
[numthreads(8,8,1)]
void Overflow (uint3 id : SV_DispatchThreadID)
{
uint originalValue;
buff.InterlockedAdd(ByteIndex(id), 1, originalValue);
}
And C#
public ComputeShader shade;
private ComputeBuffer b;
private int kernel;
private uint[] uints = new uint[64];
private void Start()
{
for(int i = 0; i < 64; i++) { uints[i] = 4294967294; }
for(int i = 0; i < 64; i++) { Debug.Log(uints[i]); }
}
void Update()
{
if(Input.GetKeyDown(KeyCode.Space))
{
b = new ComputeBuffer(64, sizeof(uint));
b.SetData(uints);
kernel = shade.FindKernel("Overflow");
shade.SetBuffer(kernel, Shader.PropertyToID("buff"), b);
shade.Dispatch(kernel, 1, 1, 1);
b.GetData(uints);
b.Dispose();
for (int i = 0; i < 64; i++) { Debug.Log(uints[i]); }
}
}
This clearly exhibits the desired behavior.
It would be nice if this behavior was documented in HLSL, but at least I know it now.