| ByteAddressBuffer firstMatrix : register(t0, space0); |
| ByteAddressBuffer secondMatrix : register(t1, space0); |
| RWByteAddressBuffer resultMatrix : register(u2, space0); |
| cbuffer cbuffer_uniforms : register(b3, space0) { |
| uint4 uniforms[1]; |
| }; |
| |
| float mm_readA(uint row, uint col) { |
| const uint scalar_offset = (0u) / 4; |
| bool tint_tmp = (row < uniforms[scalar_offset / 4][scalar_offset % 4]); |
| if (tint_tmp) { |
| const uint scalar_offset_1 = (4u) / 4; |
| tint_tmp = (col < uniforms[scalar_offset_1 / 4][scalar_offset_1 % 4]); |
| } |
| if ((tint_tmp)) { |
| const uint scalar_offset_2 = (4u) / 4; |
| const float result = asfloat(firstMatrix.Load((4u * ((row * uniforms[scalar_offset_2 / 4][scalar_offset_2 % 4]) + col)))); |
| return result; |
| } |
| return 0.0f; |
| } |
| |
| float mm_readB(uint row, uint col) { |
| const uint scalar_offset_3 = (4u) / 4; |
| bool tint_tmp_1 = (row < uniforms[scalar_offset_3 / 4][scalar_offset_3 % 4]); |
| if (tint_tmp_1) { |
| const uint scalar_offset_4 = (8u) / 4; |
| tint_tmp_1 = (col < uniforms[scalar_offset_4 / 4][scalar_offset_4 % 4]); |
| } |
| if ((tint_tmp_1)) { |
| const uint scalar_offset_5 = (8u) / 4; |
| const float result = asfloat(secondMatrix.Load((4u * ((row * uniforms[scalar_offset_5 / 4][scalar_offset_5 % 4]) + col)))); |
| return result; |
| } |
| return 0.0f; |
| } |
| |
| void mm_write(uint row, uint col, float value) { |
| const uint scalar_offset_6 = (0u) / 4; |
| bool tint_tmp_2 = (row < uniforms[scalar_offset_6 / 4][scalar_offset_6 % 4]); |
| if (tint_tmp_2) { |
| const uint scalar_offset_7 = (8u) / 4; |
| tint_tmp_2 = (col < uniforms[scalar_offset_7 / 4][scalar_offset_7 % 4]); |
| } |
| if ((tint_tmp_2)) { |
| const uint scalar_offset_8 = (8u) / 4; |
| const uint index = (col + (row * uniforms[scalar_offset_8 / 4][scalar_offset_8 % 4])); |
| resultMatrix.Store((4u * index), asuint(value)); |
| } |
| } |
| |
| static const uint RowPerThread = 4u; |
| static const uint ColPerThread = 4u; |
| static const uint TileAOuter = 64u; |
| static const uint TileBOuter = 64u; |
| static const uint TileInner = 64u; |
| |
| struct tint_array_wrapper_1 { |
| float arr[64]; |
| }; |
| struct tint_array_wrapper { |
| tint_array_wrapper_1 arr[64]; |
| }; |
| |
| groupshared tint_array_wrapper mm_Asub; |
| groupshared tint_array_wrapper mm_Bsub; |
| |
| struct tint_symbol_1 { |
| uint3 local_id : SV_GroupThreadID; |
| uint local_invocation_index : SV_GroupIndex; |
| uint3 global_id : SV_DispatchThreadID; |
| }; |
| struct tint_array_wrapper_2 { |
| float arr[16]; |
| }; |
| struct tint_array_wrapper_3 { |
| float arr[4]; |
| }; |
| |
| [numthreads(16, 16, 1)] |
| void main(tint_symbol_1 tint_symbol) { |
| const uint3 local_id = tint_symbol.local_id; |
| const uint3 global_id = tint_symbol.global_id; |
| const uint local_invocation_index = tint_symbol.local_invocation_index; |
| if ((local_invocation_index == 0u)) { |
| const tint_array_wrapper tint_symbol_5 = {(tint_array_wrapper_1[64])0}; |
| mm_Asub = tint_symbol_5; |
| const tint_array_wrapper tint_symbol_6 = {(tint_array_wrapper_1[64])0}; |
| mm_Bsub = tint_symbol_6; |
| } |
| GroupMemoryBarrierWithGroupSync(); |
| const uint tileRow = (local_id.y * RowPerThread); |
| const uint tileCol = (local_id.x * ColPerThread); |
| const uint globalRow = (global_id.y * RowPerThread); |
| const uint globalCol = (global_id.x * ColPerThread); |
| const uint scalar_offset_9 = (4u) / 4; |
| const uint numTiles = (((uniforms[scalar_offset_9 / 4][scalar_offset_9 % 4] - 1u) / TileInner) + 1u); |
| tint_array_wrapper_2 acc = (tint_array_wrapper_2)0; |
| float ACached = 0.0f; |
| tint_array_wrapper_3 BCached = (tint_array_wrapper_3)0; |
| { |
| uint index = 0u; |
| while (true) { |
| if (!((index < (RowPerThread * ColPerThread)))) { |
| break; |
| } |
| acc.arr[index] = 0.0f; |
| { |
| index = (index + 1u); |
| } |
| } |
| } |
| const uint ColPerThreadA = (TileInner / 16u); |
| const uint tileColA = (local_id.x * ColPerThreadA); |
| const uint RowPerThreadB = (TileInner / 16u); |
| const uint tileRowB = (local_id.y * RowPerThreadB); |
| { |
| uint t = 0u; |
| while (true) { |
| if (!((t < numTiles))) { |
| break; |
| } |
| { |
| uint innerRow = 0u; |
| while (true) { |
| if (!((innerRow < RowPerThread))) { |
| break; |
| } |
| { |
| uint innerCol = 0u; |
| while (true) { |
| if (!((innerCol < ColPerThreadA))) { |
| break; |
| } |
| const uint inputRow = (tileRow + innerRow); |
| const uint inputCol = (tileColA + innerCol); |
| mm_Asub.arr[inputRow].arr[inputCol] = mm_readA((globalRow + innerRow), ((t * TileInner) + inputCol)); |
| { |
| innerCol = (innerCol + 1u); |
| } |
| } |
| } |
| { |
| innerRow = (innerRow + 1u); |
| } |
| } |
| } |
| { |
| uint innerRow = 0u; |
| while (true) { |
| if (!((innerRow < RowPerThreadB))) { |
| break; |
| } |
| { |
| uint innerCol = 0u; |
| while (true) { |
| if (!((innerCol < ColPerThread))) { |
| break; |
| } |
| const uint inputRow = (tileRowB + innerRow); |
| const uint inputCol = (tileCol + innerCol); |
| mm_Bsub.arr[innerCol].arr[inputCol] = mm_readB(((t * TileInner) + inputRow), (globalCol + innerCol)); |
| { |
| innerCol = (innerCol + 1u); |
| } |
| } |
| } |
| { |
| innerRow = (innerRow + 1u); |
| } |
| } |
| } |
| GroupMemoryBarrierWithGroupSync(); |
| { |
| uint k = 0u; |
| while (true) { |
| if (!((k < TileInner))) { |
| break; |
| } |
| { |
| uint inner = 0u; |
| while (true) { |
| if (!((inner < ColPerThread))) { |
| break; |
| } |
| BCached.arr[inner] = mm_Bsub.arr[k].arr[(tileCol + inner)]; |
| { |
| inner = (inner + 1u); |
| } |
| } |
| } |
| { |
| uint innerRow = 0u; |
| while (true) { |
| if (!((innerRow < RowPerThread))) { |
| break; |
| } |
| ACached = mm_Asub.arr[(tileRow + innerRow)].arr[k]; |
| { |
| uint innerCol = 0u; |
| while (true) { |
| if (!((innerCol < ColPerThread))) { |
| break; |
| } |
| const uint index = ((innerRow * ColPerThread) + innerCol); |
| acc.arr[index] = (acc.arr[index] + (ACached * BCached.arr[innerCol])); |
| { |
| innerCol = (innerCol + 1u); |
| } |
| } |
| } |
| { |
| innerRow = (innerRow + 1u); |
| } |
| } |
| } |
| { |
| k = (k + 1u); |
| } |
| } |
| } |
| GroupMemoryBarrierWithGroupSync(); |
| { |
| t = (t + 1u); |
| } |
| } |
| } |
| { |
| uint innerRow = 0u; |
| while (true) { |
| if (!((innerRow < RowPerThread))) { |
| break; |
| } |
| { |
| uint innerCol = 0u; |
| while (true) { |
| if (!((innerCol < ColPerThread))) { |
| break; |
| } |
| const uint index = ((innerRow * ColPerThread) + innerCol); |
| mm_write((globalRow + innerRow), (globalCol + innerCol), acc.arr[index]); |
| { |
| innerCol = (innerCol + 1u); |
| } |
| } |
| } |
| { |
| innerRow = (innerRow + 1u); |
| } |
| } |
| } |
| return; |
| } |