How to get length of runtime sized StructuredBuffer?

[fixgoats]

By "runtime sized" I mean that the size isn't hardcoded in the shader and I'm not using a specialization constant to tell the shader how big it is. I'm trying to bounds check a StructuredBuffer in my shader. From the examples it seems like the way to do this is by using GetDimensions. My shader looks like this (specifically I'm trying to benchmark whether it's faster to do parallel reduction with a loop in the shader vs generating commands accordingly in the C++ program):

RWStructuredBuffer<float> minmax;

[shader("compute")]
[numthreads(64, 1, 1)]
void findminloop(uint3 threadId: SV_DispatchThreadID, uniform uint stride) {
  uint i = threadId.x;
  uint count = 0;
  uint sizeT = 0;
  minmax.GetDimensions(count, sizeT);
  uint local_stride = stride;
  for (; local_stride > 1; local_stride = (local_stride + 1) / 2) {
    if ((i < local_stride) && (i + local_stride < count)) {
      minmax[i] = min(minmax[i], minmax[i + local_stride]);
    }
  }
  minmax[0] = min(minmax[0], minmax[1]);
}

This at least doesn't crash, however, GetDimensions just writes 0 to count, and so the if condition always fails. I expected that GetDimensions would be able to find the size of the buffer at runtime, like .length() does in GLSL. I'm still able to address the buffer, write values to it and send those values to the CPU, so I don't think there's anything wrong on the API side.

Edit: Now I feel like I'm going crazy, because now this isn't working in GLSL either. I'm sure I was able to get the correct length of a buffer in this piece of code:

#version 440

layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
layout(std430, binding = 0) buffer Min {
  vec2 minmax;
  float minima[];
};
layout(push_constant) uniform Stride { uint stride; };

void main() {
  uint i = gl_GlobalInvocationID.x;
  if (i * stride + stride / 2 < minima.length()) {
    minima[stride * i] =
        min(minima[stride * i], minima[i * stride + stride / 2]);
  }
  minmax.y = minima[0];
}

Now when I try to make a minimum reproducible example like this

#version 440

layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
layout(std430, binding = 0) buffer Min { float minima[]; };
layout(push_constant) uniform Stride { uint stride; };

void main() {
  uint i = gl_GlobalInvocationID.x;
  if (minima[0] > -1.0) {
    minima[i] = minima.length();
  } else {
    minima[i] = i;
  }
}

it also reports the array as having size 0

[fixgoats]

I think I've at least found out why the size was being reported as 0. At 512 * 1024 *1024 elements, the length function reports the array as having length 0 for some reason. When I lower the count to 256 * 1024 * 1024 I get a sensible length, although it seems there is still some problem with my algorithm because it doesn't find the correct minimum, but that's outside the scope of the initial question.