ComputeProgram: Clean up usage of Float4/Int4 and SIMD::Float/SIMD::Int

Bug: b/126126820
Change-Id: I0df0841952dcaa9c8376847704a9697b9c9e9894
Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/27093
Presubmit-Ready: Ben Clayton <bclayton@google.com>
Kokoro-Presubmit: kokoro <noreply+kokoro@google.com>
Tested-by: Ben Clayton <bclayton@google.com>
Reviewed-by: Chris Forbes <chrisforbes@google.com>

diff --git a/src/Pipeline/ComputeProgram.cpp b/src/Pipeline/ComputeProgram.cpp
index 8f5ae99..a119a3c 100644 (file)
--- a/src/Pipeline/ComputeProgram.cpp
+++ b/src/Pipeline/ComputeProgram.cpp
@@ -17,6 +17,11 @@
 #include "Vulkan/VkDebug.hpp"
 #include "Vulkan/VkPipelineLayout.hpp"
 
+namespace
+{
+       enum { X, Y, Z };
+} // anonymous namespace
+
 namespace sw
 {
        ComputeProgram::ComputeProgram(SpirvShader const *shader, vk::PipelineLayout const *pipelineLayout)
@@ -54,95 +59,94 @@ namespace sw
                const int subgroupSize = SIMD::Width;
 
                // Total number of invocations required to execute this workgroup.
-               int numInvocations = localSize[0] * localSize[1] * localSize[2];
+               int numInvocations = localSize[X] * localSize[Y] * localSize[Z];
 
                Int4 numWorkgroups = *Pointer<Int4>(data + OFFSET(Data, numWorkgroups));
                Int4 workgroupID = *Pointer<Int4>(data + OFFSET(Data, workgroupID));
-               Int4 workgroupSize = Int4(localSize[0], localSize[1], localSize[2], 0);
+               Int4 workgroupSize = Int4(localSize[X], localSize[Y], localSize[Z], 0);
                Int numSubgroups = (numInvocations + subgroupSize - 1) / subgroupSize;
 
-               setInputBuiltin(spv::BuiltInNumWorkgroups, [&](const SpirvShader::BuiltinMapping& builtin, Array<Float4>& value)
+               setInputBuiltin(spv::BuiltInNumWorkgroups, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
                {
                        for (uint32_t component = 0; component < builtin.SizeInComponents; component++)
                        {
                                value[builtin.FirstComponent + component] =
-                                       As<Float4>(Int4(Extract(numWorkgroups, component)));
+                                       As<SIMD::Float>(SIMD::Int(Extract(numWorkgroups, component)));
                        }
                });
 
-               setInputBuiltin(spv::BuiltInWorkgroupSize, [&](const SpirvShader::BuiltinMapping& builtin, Array<Float4>& value)
+               setInputBuiltin(spv::BuiltInWorkgroupSize, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
                {
                        for (uint32_t component = 0; component < builtin.SizeInComponents; component++)
                        {
                                value[builtin.FirstComponent + component] =
-                                       As<Float4>(Int4(Extract(workgroupSize, component)));
+                                       As<SIMD::Float>(SIMD::Int(Extract(workgroupSize, component)));
                        }
                });
 
-               setInputBuiltin(spv::BuiltInNumSubgroups, [&](const SpirvShader::BuiltinMapping& builtin, Array<Float4>& value)
+               setInputBuiltin(spv::BuiltInNumSubgroups, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
                {
                        ASSERT(builtin.SizeInComponents == 1);
-                       value[builtin.FirstComponent] = As<Float4>(Int4(numSubgroups));
+                       value[builtin.FirstComponent] = As<SIMD::Float>(SIMD::Int(numSubgroups));
                });
 
-               setInputBuiltin(spv::BuiltInSubgroupSize, [&](const SpirvShader::BuiltinMapping& builtin, Array<Float4>& value)
+               setInputBuiltin(spv::BuiltInSubgroupSize, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
                {
                        ASSERT(builtin.SizeInComponents == 1);
-                       value[builtin.FirstComponent] = As<Float4>(Int4(subgroupSize));
+                       value[builtin.FirstComponent] = As<SIMD::Float>(SIMD::Int(subgroupSize));
                });
 
-               setInputBuiltin(spv::BuiltInSubgroupLocalInvocationId, [&](const SpirvShader::BuiltinMapping& builtin, Array<Float4>& value)
+               setInputBuiltin(spv::BuiltInSubgroupLocalInvocationId, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
                {
                        ASSERT(builtin.SizeInComponents == 1);
-                       value[builtin.FirstComponent] = As<Float4>(Int4(0, 1, 2, 3));
+                       value[builtin.FirstComponent] = As<SIMD::Float>(SIMD::Int(0, 1, 2, 3));
                });
 
-               enum { XXXX, YYYY, ZZZZ };
-
                For(Int subgroupIndex = 0, subgroupIndex < numSubgroups, subgroupIndex++)
                {
-                       Int4 localInvocationIndex = Int4(subgroupIndex * 4) + Int4(0, 1, 2, 3);
+                       // TODO: Replace SIMD::Int(0, 1, 2, 3) with SIMD-width equivalent
+                       auto localInvocationIndex = SIMD::Int(subgroupIndex * SIMD::Width) + SIMD::Int(0, 1, 2, 3);
 
                        // Disable lanes where (invocationIDs >= numInvocations)
-                       routine.activeLaneMask = CmpLT(localInvocationIndex, Int4(numInvocations));
+                       routine.activeLaneMask = CmpLT(localInvocationIndex, SIMD::Int(numInvocations));
 
-                       Int4 localInvocationID[3];
+                       SIMD::Int localInvocationID[3];
                        {
-                               Int4 idx = localInvocationIndex;
-                               localInvocationID[ZZZZ] = idx / Int4(localSize[0] * localSize[1]);
-                               idx -= localInvocationID[ZZZZ] * Int4(localSize[0] * localSize[1]); // modulo
-                               localInvocationID[YYYY] = idx / Int4(localSize[0]);
-                               idx -= localInvocationID[YYYY] * Int4(localSize[0]); // modulo
-                               localInvocationID[XXXX] = idx;
+                               SIMD::Int idx = localInvocationIndex;
+                               localInvocationID[Z] = idx / SIMD::Int(localSize[X] * localSize[Y]);
+                               idx -= localInvocationID[Z] * SIMD::Int(localSize[X] * localSize[Y]); // modulo
+                               localInvocationID[Y] = idx / SIMD::Int(localSize[X]);
+                               idx -= localInvocationID[Y] * SIMD::Int(localSize[X]); // modulo
+                               localInvocationID[X] = idx;
                        }
 
-                       setInputBuiltin(spv::BuiltInLocalInvocationIndex, [&](const SpirvShader::BuiltinMapping& builtin, Array<Float4>& value)
+                       setInputBuiltin(spv::BuiltInLocalInvocationIndex, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
                        {
                                ASSERT(builtin.SizeInComponents == 1);
-                               value[builtin.FirstComponent] = As<Float4>(localInvocationIndex);
+                               value[builtin.FirstComponent] = As<SIMD::Float>(localInvocationIndex);
                        });
 
-                       setInputBuiltin(spv::BuiltInSubgroupId, [&](const SpirvShader::BuiltinMapping& builtin, Array<Float4>& value)
+                       setInputBuiltin(spv::BuiltInSubgroupId, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
                        {
                                ASSERT(builtin.SizeInComponents == 1);
-                               value[builtin.FirstComponent] = As<Float4>(Int4(subgroupIndex));
+                               value[builtin.FirstComponent] = As<SIMD::Float>(SIMD::Int(subgroupIndex));
                        });
 
-                       setInputBuiltin(spv::BuiltInLocalInvocationId, [&](const SpirvShader::BuiltinMapping& builtin, Array<Float4>& value)
+                       setInputBuiltin(spv::BuiltInLocalInvocationId, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
                        {
                                for (uint32_t component = 0; component < builtin.SizeInComponents; component++)
                                {
-                                       value[builtin.FirstComponent + component] = As<Float4>(localInvocationID[component]);
+                                       value[builtin.FirstComponent + component] = As<SIMD::Float>(localInvocationID[component]);
                                }
                        });
 
-                       setInputBuiltin(spv::BuiltInGlobalInvocationId, [&](const SpirvShader::BuiltinMapping& builtin, Array<Float4>& value)
+                       setInputBuiltin(spv::BuiltInGlobalInvocationId, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
                        {
-                               Int4 localBase = workgroupID * workgroupSize;
+                               auto localBase = workgroupID * workgroupSize;
                                for (uint32_t component = 0; component < builtin.SizeInComponents; component++)
                                {
-                                       Int4 globalInvocationID = Int4(Extract(localBase, component)) + localInvocationID[component];
-                                       value[builtin.FirstComponent + component] = As<Float4>(globalInvocationID);
+                                       auto globalInvocationID = SIMD::Int(Extract(localBase, component)) + localInvocationID[component];
+                                       value[builtin.FirstComponent + component] = As<SIMD::Float>(globalInvocationID);
                                }
                        });
 
@@ -151,7 +155,7 @@ namespace sw
                }
        }
 
-       void ComputeProgram::setInputBuiltin(spv::BuiltIn id, std::function<void(const SpirvShader::BuiltinMapping& builtin, Array<Float4>& value)> cb)
+       void ComputeProgram::setInputBuiltin(spv::BuiltIn id, std::function<void(const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)> cb)
        {
                auto it = shader->inputBuiltins.find(id);
                if (it != shader->inputBuiltins.end())
@@ -170,21 +174,21 @@ namespace sw
 
                Data data;
                data.descriptorSets = descriptorSets;
-               data.numWorkgroups[0] = groupCountX;
-               data.numWorkgroups[1] = groupCountY;
-               data.numWorkgroups[2] = groupCountZ;
+               data.numWorkgroups[X] = groupCountX;
+               data.numWorkgroups[Y] = groupCountY;
+               data.numWorkgroups[Z] = groupCountZ;
                data.numWorkgroups[3] = 0;
 
                // TODO(bclayton): Split work across threads.
                for (uint32_t groupZ = 0; groupZ < groupCountZ; groupZ++)
                {
-                       data.workgroupID[2] = groupZ;
+                       data.workgroupID[Z] = groupZ;
                        for (uint32_t groupY = 0; groupY < groupCountY; groupY++)
                        {
-                               data.workgroupID[1] = groupY;
+                               data.workgroupID[Y] = groupY;
                                for (uint32_t groupX = 0; groupX < groupCountX; groupX++)
                                {
-                                       data.workgroupID[0] = groupX;
+                                       data.workgroupID[X] = groupX;
                                        runWorkgroup(&data);
                                }
                        }

diff --git a/src/Pipeline/ComputeProgram.hpp b/src/Pipeline/ComputeProgram.hpp
index 8473980..ef3a4de 100644 (file)
--- a/src/Pipeline/ComputeProgram.hpp
+++ b/src/Pipeline/ComputeProgram.hpp
@@ -53,7 +53,7 @@ namespace sw
        protected:
                void emit();
 
-               void setInputBuiltin(spv::BuiltIn id, std::function<void(const SpirvShader::BuiltinMapping& builtin, Array<Float4>& value)> cb);
+               void setInputBuiltin(spv::BuiltIn id, std::function<void(const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)> cb);
 
                Pointer<Byte> data; // argument 0