It's not possible to "leave async shaders off". All D3D12 drivers must support this feature. The hardware may stumble when fed that kind of workload. If the developer discovers this, they can create a version of the graphics algorithms that does not use async shaders.
RWStructuredBuffer<float> oUAV : register(u0);
float4 vsMain(float4 pos : POSITION) : SV_Position {
return pos;
}
float4 psMain() : SV_Target {
return float4(1.0f, 1.0f, 1.0f, 1.0f);
}
[numthreads(1, 1, 1)]
void csMain(uint3 id : SV_DispatchThreadID) {
float a1 = id.x + 1.0f;
float a2 = id.y + 1.0f;
float a3;
for (int i = 0; i < 1024 * 4; ++i) {
for (int j = 0; j < 128; ++j) {
a3 = a1 + a2;
a3 = a3 * 0.500001f;
a1 = a2;
a2 = a3;
}
}
oUAV[0] = a3;
}Unrolled loop version from GPGPU expert (Vlev):
RWStructuredBuffer<float> oUAV : register(u0);
float4 vsMain(float4 pos : POSITION) : SV_Position {
return pos;
}
float4 psMain() : SV_Target {
return float4(1.0f, 1.0f, 1.0f, 1.0f);
}
[numthreads(1, 1, 1)]
void csMain(uint3 id : SV_DispatchThreadID) {
float a1 = id.x + 1.0f;
float a2 = id.y + 1.0f;
float a3;
for (int i = 0; i < 1024 * 32; ++i) {
float b3 = a1 + a2; a3 = b3 * 0.50001f;
float b4 = a2 + b3 * 0.50001f; float a4 = b4 * 0.50001f;
float b5 = a3 + b4 * 0.50001f; float a5 = b5 * 0.50001f;
float b6 = a4 + b5 * 0.50001f; float a6 = b6 * 0.50001f;
float b7 = a5 + b6 * 0.50001f; float a7 = b7 * 0.50001f;
float b8 = a6 + b7 * 0.50001f; float a8 = b8 * 0.50001f;
float b9 = a7 + b8 * 0.50001f; float a9 = b9 * 0.50001f;
float b10 = a8 + b9 * 0.50001f; float a10 = b10 * 0.50001f;
float b11 = a9 + b10 * 0.50001f; float a11 = b11 * 0.50001f;
float b12 = a10 + b11 * 0.50001f; float a12 = b12 * 0.50001f;
float b13 = a11 + b12 * 0.50001f; float a13 = b13 * 0.50001f;
float b14 = a12 + b13 * 0.50001f; float a14 = b14 * 0.50001f;
float b15 = a13 + b14 * 0.50001f; float a15 = b15 * 0.50001f;
float b16 = a14 + b15 * 0.50001f; float a16 = b16 * 0.50001f;
float b17 = a15 + b16 * 0.50001f; float a17 = b17 * 0.50001f;
float b18 = a16 + b17 * 0.50001f; float a18 = b18 * 0.50001f;
float b19 = a17 + b18 * 0.50001f; float a19 = b19 * 0.50001f;
float b20 = a18 + b19 * 0.50001f; float a20 = b20 * 0.50001f;
float b21 = a19 + b20 * 0.50001f; float a21 = b21 * 0.50001f;
float b22 = a20 + b21 * 0.50001f; float a22 = b22 * 0.50001f;
float b23 = a21 + b22 * 0.50001f; float a23 = b23 * 0.50001f;
float b24 = a22 + b23 * 0.50001f; float a24 = b24 * 0.50001f;
float b25 = a23 + b24 * 0.50001f; float a25 = b25 * 0.50001f;
float b26 = a24 + b25 * 0.50001f; float a26 = b26 * 0.50001f;
float b27 = a25 + b26 * 0.50001f; float a27 = b27 * 0.50001f;
float b28 = a26 + b27 * 0.50001f; float a28 = b28 * 0.50001f;
float b29 = a27 + b28 * 0.50001f; float a29 = b29 * 0.50001f;
float b30 = a28 + b29 * 0.50001f; float a30 = b30 * 0.50001f;
float b31 = a29 + b30 * 0.50001f; float a31 = b31 * 0.50001f;
float b32 = a30 + b31 * 0.50001f; float a32 = b32 * 0.50001f;
float b33 = a31 + b32 * 0.50001f; float a33 = b33 * 0.50001f;
float b34 = a32 + b33 * 0.50001f; float a34 = b34 * 0.50001f;
a1 = a33;
a2 = a34;
}
oUAV[0] = a3;
}
Hi Benny-ua, thanks for your results. It looks as if performance becomes less reliable the harder the workload in compute + graphics async. I also notice that all of the steps in time are in increments of approximately 64, which is unlike most AMD cards running MDolenc's original code. But I can't tell if this is because of the unrolled code from Vlev or if it's because of the card and/or driver.
Original shader, early version of this test - http://pastebin.com/XSfm4baS
Ah, sorry, I meant the version of MDolenc's test without unroll (which also uses up to 512 kernels). I was curious to see what happens with the width of the steps and whether faster execution affects the width of the steps or causes more erratic performance.
These new results are very erratic. I wonder if overclocking is causing some throttling or some related effect. Or maybe the erratic results are simply because of the short run time of each kernel. Though I still can't rationalise the mechanism for this, other than just saying "chaos".
I dare say ka_rf's graph indicate that Fury X async shaders are worse than 7950's.
These look about the same as your overclocked results I reckon, so it seems that overclocking is probably not relevant.
That's to be expected, since it is the best-performing scenario.
I think you're right. I wonder what Hawaii does on this test with the unroll, since the behaviour reported earlier in the week seemed to be the closest to what is desirable.
