Skip to content

S
swiftshader
Commit bc1c067b by Ben Clayton
Options

clang-format the src/Pipeline directory

Bug: b/144825072 Change-Id: I869aef91d6318bf6955581e5dad762800bd46296 Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/39655Tested-by: 's avatarBen Clayton <bclayton@google.com> Reviewed-by: 's avatarNicolas Capens <nicolascapens@google.com>
parent fccfc566
Showing with 321 additions and 312 deletions
src/Pipeline/ComputeProgram.cpp
......@@ -26,16 +26,21 @@
namespace {
enum { X, Y, Z };
enum
{
X,
Y,
Z
};
} // anonymous namespace
namespace sw {
ComputeProgram::ComputeProgram(SpirvShader const *shader, vk::PipelineLayout const *pipelineLayout, const vk::DescriptorSet::Bindings &descriptorSets)
: shader(shader),
pipelineLayout(pipelineLayout),
descriptorSets(descriptorSets)
: shader(shader)
, pipelineLayout(pipelineLayout)
, descriptorSets(descriptorSets)
{
}
......@@ -53,46 +58,41 @@ void ComputeProgram::generate()
shader->emitEpilog(&routine);
}
void ComputeProgram::setWorkgroupBuiltins(Pointer<Byte> data, SpirvRoutine* routine, Int workgroupID[3])
void ComputeProgram::setWorkgroupBuiltins(Pointer<Byte> data, SpirvRoutine *routine, Int workgroupID[3])
{
routine->setInputBuiltin(shader, spv::BuiltInNumWorkgroups, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInNumWorkgroups, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
auto numWorkgroups = *Pointer<Int4>(data + OFFSET(Data, numWorkgroups));
for(uint32_t component = 0; component < builtin.SizeInComponents; component++)
{
value[builtin.FirstComponent + component] =
As<SIMD::Float>(SIMD::Int(Extract(numWorkgroups, component)));
As<SIMD::Float>(SIMD::Int(Extract(numWorkgroups, component)));
}
});
routine->setInputBuiltin(shader, spv::BuiltInWorkgroupId, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInWorkgroupId, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
for(uint32_t component = 0; component < builtin.SizeInComponents; component++)
{
value[builtin.FirstComponent + component] =
As<SIMD::Float>(SIMD::Int(workgroupID[component]));
As<SIMD::Float>(SIMD::Int(workgroupID[component]));
}
});
routine->setInputBuiltin(shader, spv::BuiltInWorkgroupSize, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInWorkgroupSize, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
auto workgroupSize = *Pointer<Int4>(data + OFFSET(Data, workgroupSize));
for(uint32_t component = 0; component < builtin.SizeInComponents; component++)
{
value[builtin.FirstComponent + component] =
As<SIMD::Float>(SIMD::Int(Extract(workgroupSize, component)));
As<SIMD::Float>(SIMD::Int(Extract(workgroupSize, component)));
}
});
routine->setInputBuiltin(shader, spv::BuiltInNumSubgroups, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInNumSubgroups, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
ASSERT(builtin.SizeInComponents == 1);
auto subgroupsPerWorkgroup = *Pointer<Int>(data + OFFSET(Data, subgroupsPerWorkgroup));
value[builtin.FirstComponent] = As<SIMD::Float>(SIMD::Int(subgroupsPerWorkgroup));
});
routine->setInputBuiltin(shader, spv::BuiltInSubgroupSize, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInSubgroupSize, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
ASSERT(builtin.SizeInComponents == 1);
auto invocationsPerSubgroup = *Pointer<Int>(data + OFFSET(Data, invocationsPerSubgroup));
value[builtin.FirstComponent] = As<SIMD::Float>(SIMD::Int(invocationsPerSubgroup));
......@@ -101,7 +101,7 @@ void ComputeProgram::setWorkgroupBuiltins(Pointer<Byte> data, SpirvRoutine* rout
routine->setImmutableInputBuiltins(shader);
}
void ComputeProgram::setSubgroupBuiltins(Pointer<Byte> data, SpirvRoutine* routine, Int workgroupID[3], SIMD::Int localInvocationIndex, Int subgroupIndex)
void ComputeProgram::setSubgroupBuiltins(Pointer<Byte> data, SpirvRoutine *routine, Int workgroupID[3], SIMD::Int localInvocationIndex, Int subgroupIndex)
{
Int4 numWorkgroups = *Pointer<Int4>(data + OFFSET(Data, numWorkgroups));
Int4 workgroupSize = *Pointer<Int4>(data + OFFSET(Data, workgroupSize));
......@@ -114,35 +114,31 @@ void ComputeProgram::setSubgroupBuiltins(Pointer<Byte> data, SpirvRoutine* routi
{
SIMD::Int idx = localInvocationIndex;
localInvocationID[Z] = idx / SIMD::Int(workgroupSizeX * workgroupSizeY);
idx -= localInvocationID[Z] * SIMD::Int(workgroupSizeX * workgroupSizeY); // modulo
idx -= localInvocationID[Z] * SIMD::Int(workgroupSizeX * workgroupSizeY); // modulo
localInvocationID[Y] = idx / SIMD::Int(workgroupSizeX);
idx -= localInvocationID[Y] * SIMD::Int(workgroupSizeX); // modulo
idx -= localInvocationID[Y] * SIMD::Int(workgroupSizeX); // modulo
localInvocationID[X] = idx;
}
routine->setInputBuiltin(shader, spv::BuiltInLocalInvocationIndex, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInLocalInvocationIndex, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
ASSERT(builtin.SizeInComponents == 1);
value[builtin.FirstComponent] = As<SIMD::Float>(localInvocationIndex);
});
routine->setInputBuiltin(shader, spv::BuiltInSubgroupId, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInSubgroupId, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
ASSERT(builtin.SizeInComponents == 1);
value[builtin.FirstComponent] = As<SIMD::Float>(SIMD::Int(subgroupIndex));
});
routine->setInputBuiltin(shader, spv::BuiltInLocalInvocationId, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInLocalInvocationId, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
for(uint32_t component = 0; component < builtin.SizeInComponents; component++)
{
value[builtin.FirstComponent + component] =
As<SIMD::Float>(localInvocationID[component]);
As<SIMD::Float>(localInvocationID[component]);
}
});
routine->setInputBuiltin(shader, spv::BuiltInGlobalInvocationId, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine->setInputBuiltin(shader, spv::BuiltInGlobalInvocationId, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
SIMD::Int wgID = 0;
wgID = Insert(wgID, workgroupID[X], X);
wgID = Insert(wgID, workgroupID[Y], Y);
......@@ -156,7 +152,7 @@ void ComputeProgram::setSubgroupBuiltins(Pointer<Byte> data, SpirvRoutine* routi
});
}
void ComputeProgram::emit(SpirvRoutine* routine)
void ComputeProgram::emit(SpirvRoutine *routine)
{
Pointer<Byte> data = Arg<0>();
Int workgroupX = Arg<1>();
......@@ -174,7 +170,7 @@ void ComputeProgram::emit(SpirvRoutine* routine)
Int invocationsPerWorkgroup = *Pointer<Int>(data + OFFSET(Data, invocationsPerWorkgroup));
Int workgroupID[3] = {workgroupX, workgroupY, workgroupZ};
Int workgroupID[3] = { workgroupX, workgroupY, workgroupZ };
setWorkgroupBuiltins(data, routine, workgroupID);
For(Int i = 0, i < subgroupCount, i++)
......@@ -194,11 +190,11 @@ void ComputeProgram::emit(SpirvRoutine* routine)
}
void ComputeProgram::run(
vk::DescriptorSet::Bindings const &descriptorSets,
vk::DescriptorSet::DynamicOffsets const &descriptorDynamicOffsets,
PushConstantStorage const &pushConstants,
uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ,
uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
vk::DescriptorSet::Bindings const &descriptorSets,
vk::DescriptorSet::DynamicOffsets const &descriptorDynamicOffsets,
PushConstantStorage const &pushConstants,
uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ,
uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
{
auto &modes = shader->getModes();
......@@ -231,8 +227,7 @@ void ComputeProgram::run(
for(uint32_t batchID = 0; batchID < batchCount && batchID < groupCount; batchID++)
{
wg.add(1);
marl::schedule([=, &data]
{
marl::schedule([=, &data] {
defer(wg.done());
std::vector<uint8_t> workgroupMemory(shader->workgroupMemory.size());
......
src/Pipeline/ComputeProgram.hpp
......@@ -17,13 +17,15 @@
#include "SpirvShader.hpp"
#include "Reactor/Coroutine.hpp"
#include "Device/Context.hpp"
#include "Reactor/Coroutine.hpp"
#include "Vulkan/VkDescriptorSet.hpp"
#include <functional>
namespace vk { class PipelineLayout; }
namespace vk {
class PipelineLayout;
}
namespace sw {
......@@ -34,13 +36,13 @@ struct Constants;
// ComputeProgram builds a SPIR-V compute shader.
class ComputeProgram : public Coroutine<SpirvShader::YieldResult(
void* data,
int32_t workgroupX,
int32_t workgroupY,
int32_t workgroupZ,
void* workgroupMemory,
int32_t firstSubgroup,
int32_t subgroupCount)>
void *data,
int32_t workgroupX,
int32_t workgroupY,
int32_t workgroupZ,
void *workgroupMemory,
int32_t firstSubgroup,
int32_t subgroupCount)>
{
public:
ComputeProgram(SpirvShader const *spirvShader, vk::PipelineLayout const *pipelineLayout, const vk::DescriptorSet::Bindings &descriptorSets);
......@@ -52,35 +54,35 @@ public:
// run executes the compute shader routine for all workgroups.
void run(
vk::DescriptorSet::Bindings const &descriptorSetBindings,
vk::DescriptorSet::DynamicOffsets const &descriptorDynamicOffsets,
PushConstantStorage const &pushConstants,
uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ,
uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
vk::DescriptorSet::Bindings const &descriptorSetBindings,
vk::DescriptorSet::DynamicOffsets const &descriptorDynamicOffsets,
PushConstantStorage const &pushConstants,
uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ,
uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
protected:
void emit(SpirvRoutine* routine);
void setWorkgroupBuiltins(Pointer<Byte> data, SpirvRoutine* routine, Int workgroupID[3]);
void setSubgroupBuiltins(Pointer<Byte> data, SpirvRoutine* routine, Int workgroupID[3], SIMD::Int localInvocationIndex, Int subgroupIndex);
void emit(SpirvRoutine *routine);
void setWorkgroupBuiltins(Pointer<Byte> data, SpirvRoutine *routine, Int workgroupID[3]);
void setSubgroupBuiltins(Pointer<Byte> data, SpirvRoutine *routine, Int workgroupID[3], SIMD::Int localInvocationIndex, Int subgroupIndex);
struct Data
{
vk::DescriptorSet::Bindings descriptorSets;
vk::DescriptorSet::DynamicOffsets descriptorDynamicOffsets;
uint4 numWorkgroups; // [x, y, z, 0]
uint4 workgroupSize; // [x, y, z, 0]
uint32_t invocationsPerSubgroup; // SPIR-V: "SubgroupSize"
uint32_t subgroupsPerWorkgroup; // SPIR-V: "NumSubgroups"
uint32_t invocationsPerWorkgroup; // Total number of invocations per workgroup.
uint4 numWorkgroups; // [x, y, z, 0]
uint4 workgroupSize; // [x, y, z, 0]
uint32_t invocationsPerSubgroup; // SPIR-V: "SubgroupSize"
uint32_t subgroupsPerWorkgroup; // SPIR-V: "NumSubgroups"
uint32_t invocationsPerWorkgroup; // Total number of invocations per workgroup.
PushConstantStorage pushConstants;
const Constants *constants;
};
SpirvShader const * const shader;
vk::PipelineLayout const * const pipelineLayout;
SpirvShader const *const shader;
vk::PipelineLayout const *const pipelineLayout;
const vk::DescriptorSet::Bindings &descriptorSets;
};
} // namespace sw
#endif // sw_ComputeProgram_hpp
#endif // sw_ComputeProgram_hpp
src/Pipeline/Constants.hpp
......@@ -15,8 +15,8 @@
#ifndef sw_Constants_hpp
#define sw_Constants_hpp
#include "System/Types.hpp"
#include "System/Math.hpp"
#include "System/Types.hpp"
#include "Vulkan/VkConfig.h"
namespace sw {
......@@ -68,8 +68,8 @@ struct Constants
word4 maskW01Q[4];
dword4 maskD01X[4];
word4 mask565Q[8];
dword2 mask10Q[16]; // 4 bit writemask -> A2B10G10R10 bit patterns, replicated 2x
word4 mask5551Q[16]; // 4 bit writemask -> A1R5G5B5 bit patterns, replicated 4x
dword2 mask10Q[16]; // 4 bit writemask -> A2B10G10R10 bit patterns, replicated 2x
word4 mask5551Q[16]; // 4 bit writemask -> A1R5G5B5 bit patterns, replicated 4x
unsigned short sRGBtoLinear8_16[256];
......@@ -91,10 +91,10 @@ struct Constants
// VK_SAMPLE_COUNT_4_BIT
// https://www.khronos.org/registry/vulkan/specs/1.1/html/vkspec.html#primsrast-multisampling
static constexpr float VkSampleLocations4[][2] = {
{0.375, 0.125},
{0.875, 0.375},
{0.125, 0.625},
{0.625, 0.875},
{ 0.375, 0.125 },
{ 0.875, 0.375 },
{ 0.125, 0.625 },
{ 0.625, 0.875 },
};
// Vulkan spec sample positions are relative to 0,0 in top left corner, with Y+ going down.
......@@ -141,6 +141,6 @@ struct Constants
extern Constants constants;
} // namepsace sw
} // namespace sw
#endif // sw_Constants_hpp
#endif // sw_Constants_hpp
src/Pipeline/PixelProgram.hpp
......@@ -23,18 +23,18 @@ class PixelProgram : public PixelRoutine
{
public:
PixelProgram(
const PixelProcessor::State &state,
vk::PipelineLayout const *pipelineLayout,
SpirvShader const *spirvShader,
const vk::DescriptorSet::Bindings &descriptorSets) :
PixelRoutine(state, pipelineLayout, spirvShader, descriptorSets)
const PixelProcessor::State &state,
vk::PipelineLayout const *pipelineLayout,
SpirvShader const *spirvShader,
const vk::DescriptorSet::Bindings &descriptorSets)
: PixelRoutine(state, pipelineLayout, spirvShader, descriptorSets)
{
}
virtual ~PixelProgram() {}
protected:
virtual void setBuiltins(Int &x, Int &y, Float4(&z)[4], Float4 &w, Int cMask[4]);
virtual void setBuiltins(Int &x, Int &y, Float4 (&z)[4], Float4 &w, Int cMask[4]);
virtual void applyShader(Int cMask[4], Int sMask[4], Int zMask[4]);
virtual Bool alphaTest(Int cMask[4]);
virtual void rasterOperation(Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4]);
......
src/Pipeline/PixelRoutine.cpp
This source diff could not be displayed because it is too large. You can view the blob instead.
src/Pipeline/PixelRoutine.hpp
......@@ -26,16 +26,16 @@ class PixelRoutine : public sw::QuadRasterizer
{
public:
PixelRoutine(const PixelProcessor::State &state,
vk::PipelineLayout const *pipelineLayout,
SpirvShader const *spirvShader,
const vk::DescriptorSet::Bindings &descriptorSets);
vk::PipelineLayout const *pipelineLayout,
SpirvShader const *spirvShader,
const vk::DescriptorSet::Bindings &descriptorSets);
virtual ~PixelRoutine();
protected:
Float4 z[4]; // Multisampled z
Float4 w; // Used as is
Float4 rhw; // Reciprocal w
Float4 z[4]; // Multisampled z
Float4 w; // Used as is
Float4 rhw; // Reciprocal w
SpirvRoutine routine;
const vk::DescriptorSet::Bindings &descriptorSets;
......@@ -43,7 +43,7 @@ protected:
// Depth output
Float4 oDepth;
virtual void setBuiltins(Int &x, Int &y, Float4(&z)[4], Float4 &w, Int cMask[4]) = 0;
virtual void setBuiltins(Int &x, Int &y, Float4 (&z)[4], Float4 &w, Int cMask[4]) = 0;
virtual void applyShader(Int cMask[4], Int sMask[4], Int zMask[4]) = 0;
virtual Bool alphaTest(Int cMask[4]) = 0;
virtual void rasterOperation(Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4]) = 0;
......@@ -55,7 +55,7 @@ protected:
// Raster operations
void alphaBlend(int index, const Pointer<Byte> &cBuffer, Vector4s &current, const Int &x);
void writeColor(int index, const Pointer<Byte> &cBuffer, const Int& x, Vector4f& oC, const Int& sMask, const Int& zMask, const Int& cMask);
void writeColor(int index, const Pointer<Byte> &cBuffer, const Int &x, Vector4f &oC, const Int &sMask, const Int &zMask, const Int &cMask);
void alphaBlend(int index, const Pointer<Byte> &cBuffer, Vector4f &oC, const Int &x);
void writeColor(int index, const Pointer<Byte> &cBuffer, const Int &x, Vector4s &current, const Int &sMask, const Int &zMask, const Int &cMask);
......@@ -93,4 +93,4 @@ private:
} // namespace sw
#endif // sw_PixelRoutine_hpp
#endif // sw_PixelRoutine_hpp
src/Pipeline/SamplerCore.hpp
......@@ -21,7 +21,7 @@
#include "Reactor/Reactor.hpp"
#ifdef None
#undef None // b/127920555
# undef None // b/127920555
#endif
namespace sw {
......@@ -45,7 +45,9 @@ enum SamplerMethod : uint32_t
struct SamplerFunction
{
SamplerFunction(SamplerMethod method, bool offset = false, bool sample = false)
: method(method), offset(offset), sample(sample)
: method(method)
, offset(offset)
, sample(sample)
{}
operator SamplerMethod() { return method; }
......@@ -60,20 +62,20 @@ class SamplerCore
public:
SamplerCore(Pointer<Byte> &constants, const Sampler &state);
Vector4f sampleTexture(Pointer<Byte> &texture, Pointer<Byte> &sampler, Float4 uvw[4], Float4 &q, Float &&lodOrBias, Float4 &dsx, Float4 &dsy, Vector4f &offset, Int4& sampleId, SamplerFunction function);
Vector4f sampleTexture(Pointer<Byte> &texture, Pointer<Byte> &sampler, Float4 uvw[4], Float4 &q, Float &&lodOrBias, Float4 &dsx, Float4 &dsy, Vector4f &offset, Int4 &sampleId, SamplerFunction function);
private:
Short4 offsetSample(Short4 &uvw, Pointer<Byte> &mipmap, int halfOffset, bool wrap, int count, Float &lod);
Vector4s sampleFilter(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, SamplerFunction function);
Vector4s sampleAniso(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, bool secondLOD, SamplerFunction function);
Vector4s sampleQuad(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4s sampleQuad2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4s sample3D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4f sampleFloatFilter(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, SamplerFunction function);
Vector4f sampleFloatAniso(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, bool secondLOD, SamplerFunction function);
Vector4f sampleFloat(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4f sampleFloat2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4f sampleFloat3D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4& cubeArrayCoord, const Int4& sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4s sampleFilter(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, SamplerFunction function);
Vector4s sampleAniso(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, bool secondLOD, SamplerFunction function);
Vector4s sampleQuad(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4s sampleQuad2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4s sample3D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4f sampleFloatFilter(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, SamplerFunction function);
Vector4f sampleFloatAniso(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, bool secondLOD, SamplerFunction function);
Vector4f sampleFloat(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4f sampleFloat2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Vector4f sampleFloat3D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, const Float4 &cubeArrayCoord, const Int4 &sampleId, Float &lod, bool secondLOD, SamplerFunction function);
Float log2sqrt(Float lod);
Float log2(Float lod);
void computeLod(Pointer<Byte> &texture, Pointer<Byte> &sampler, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Float4 &u, Float4 &v, Float4 &dsx, Float4 &dsy, SamplerFunction function);
......@@ -81,15 +83,15 @@ private:
void computeLod3D(Pointer<Byte> &texture, Pointer<Byte> &sampler, Float &lod, Float4 &u, Float4 &v, Float4 &w, Float4 &dsx, Float4 &dsy, SamplerFunction function);
Int4 cubeFace(Float4 &U, Float4 &V, Float4 &x, Float4 &y, Float4 &z, Float4 &M);
Short4 applyOffset(Short4 &uvw, Float4 &offset, const Int4 &whd, AddressingMode mode);
void computeIndices(UInt index[4], Short4 uuuu, Short4 vvvv, Short4 wwww, Vector4f &offset, const Pointer<Byte> &mipmap, const Short4& cubeArrayId, const Int4& sampleId, SamplerFunction function);
void computeIndices(UInt index[4], Int4 uuuu, Int4 vvvv, Int4 wwww, Int4 valid, const Pointer<Byte> &mipmap, const Int4& cubeArrayId, const Int4& sampleId, SamplerFunction function);
Vector4s sampleTexel(Short4 &u, Short4 &v, Short4 &s, Vector4f &offset, Pointer<Byte> &mipmap, const Short4& cubeArrayId, const Int4& sampleId, Pointer<Byte> buffer, SamplerFunction function);
void computeIndices(UInt index[4], Short4 uuuu, Short4 vvvv, Short4 wwww, Vector4f &offset, const Pointer<Byte> &mipmap, const Short4 &cubeArrayId, const Int4 &sampleId, SamplerFunction function);
void computeIndices(UInt index[4], Int4 uuuu, Int4 vvvv, Int4 wwww, Int4 valid, const Pointer<Byte> &mipmap, const Int4 &cubeArrayId, const Int4 &sampleId, SamplerFunction function);
Vector4s sampleTexel(Short4 &u, Short4 &v, Short4 &s, Vector4f &offset, Pointer<Byte> &mipmap, const Short4 &cubeArrayId, const Int4 &sampleId, Pointer<Byte> buffer, SamplerFunction function);
Vector4s sampleTexel(UInt index[4], Pointer<Byte> buffer);
Vector4f sampleTexel(Int4 &u, Int4 &v, Int4 &s, Float4 &z, Pointer<Byte> &mipmap, const Int4& cubeArrayId, const Int4& sampleId, Pointer<Byte> buffer, SamplerFunction function);
Vector4f sampleTexel(Int4 &u, Int4 &v, Int4 &s, Float4 &z, Pointer<Byte> &mipmap, const Int4 &cubeArrayId, const Int4 &sampleId, Pointer<Byte> buffer, SamplerFunction function);
Vector4f replaceBorderTexel(const Vector4f &c, Int4 valid);
void selectMipmap(const Pointer<Byte> &texture, Pointer<Byte> &mipmap, Pointer<Byte> &buffer, const Float &lod, bool secondLOD);
Short4 address(const Float4 &uw, AddressingMode addressingMode, Pointer<Byte>& mipmap);
void address(const Float4 &uw, Int4& xyz0, Int4& xyz1, Float4& f, Pointer<Byte>& mipmap, Float4 &texOffset, Int4 &filter, int whd, AddressingMode addressingMode, SamplerFunction function);
Short4 address(const Float4 &uw, AddressingMode addressingMode, Pointer<Byte> &mipmap);
void address(const Float4 &uw, Int4 &xyz0, Int4 &xyz1, Float4 &f, Pointer<Byte> &mipmap, Float4 &texOffset, Int4 &filter, int whd, AddressingMode addressingMode, SamplerFunction function);
Int4 computeFilterOffset(Float &lod);
void convertSigned15(Float4 &cf, Short4 &ci);
......@@ -120,21 +122,22 @@ private:
#ifdef ENABLE_RR_PRINT
namespace rr {
template <> struct PrintValue::Ty<sw::SamplerFunction>
template<>
struct PrintValue::Ty<sw::SamplerFunction>
{
static std::string fmt(const sw::SamplerFunction& v)
static std::string fmt(const sw::SamplerFunction &v)
{
return std::string("SamplerFunction[") +
"method: " + std::to_string(v.method) +
", offset: " + std::to_string(v.offset) +
", sample: " + std::to_string(v.sample) +
"]";
"method: " + std::to_string(v.method) +
", offset: " + std::to_string(v.offset) +
", sample: " + std::to_string(v.sample) +
"]";
}
static std::vector<rr::Value*> val(const sw::SamplerFunction& v) { return {}; }
static std::vector<rr::Value *> val(const sw::SamplerFunction &v) { return {}; }
};
} // namespace rr
#endif // ENABLE_RR_PRINT
#endif // ENABLE_RR_PRINT
#endif // sw_SamplerCore_hpp
#endif // sw_SamplerCore_hpp
src/Pipeline/SetupRoutine.hpp
......@@ -45,4 +45,4 @@ private:
} // namespace sw
#endif // sw_SetupRoutine_hpp
#endif // sw_SetupRoutine_hpp
src/Pipeline/SpirvID.hpp
......@@ -15,8 +15,8 @@
#ifndef sw_ID_hpp
#define sw_ID_hpp
#include <unordered_map>
#include <cstdint>
#include <unordered_map>
namespace sw {
......@@ -25,39 +25,43 @@ namespace sw {
// ID; instead it is used to prevent implicit casts between identifiers of
// different T types.
// IDs are typically used as a map key to value of type T.
template <typename T>
template<typename T>
class SpirvID
{
public:
SpirvID() : id(0) {}
SpirvID(uint32_t id) : id(id) {}
bool operator == (const SpirvID<T>& rhs) const { return id == rhs.id; }
bool operator != (const SpirvID<T>& rhs) const { return id != rhs.id; }
bool operator < (const SpirvID<T>& rhs) const { return id < rhs.id; }
SpirvID()
: id(0)
{}
SpirvID(uint32_t id)
: id(id)
{}
bool operator==(const SpirvID<T> &rhs) const { return id == rhs.id; }
bool operator!=(const SpirvID<T> &rhs) const { return id != rhs.id; }
bool operator<(const SpirvID<T> &rhs) const { return id < rhs.id; }
// value returns the numerical value of the identifier.
uint32_t value() const { return id; }
private:
uint32_t id;
};
// HandleMap<T> is an unordered map of SpirvID<T> to T.
template <typename T>
template<typename T>
using HandleMap = std::unordered_map<SpirvID<T>, T>;
}
} // namespace sw
namespace std
{
namespace std {
// std::hash implementation for sw::SpirvID<T>
template<typename T>
struct hash< sw::SpirvID<T> >
struct hash<sw::SpirvID<T> >
{
std::size_t operator()(const sw::SpirvID<T>& id) const noexcept
std::size_t operator()(const sw::SpirvID<T> &id) const noexcept
{
return std::hash<uint32_t>()(id.value());
}
};
} // namespace sw
} // namespace std
#endif // sw_ID_hpp
src/Pipeline/SpirvShader.cpp
This source diff could not be displayed because it is too large. You can view the blob instead.
src/Pipeline/SpirvShaderControlFlow.cpp
......@@ -14,7 +14,7 @@
#include "SpirvShader.hpp"
#include "Reactor/Coroutine.hpp" // rr::Yield
#include "Reactor/Coroutine.hpp" // rr::Yield
#include "ShaderCore.hpp"
......@@ -24,7 +24,9 @@
namespace sw {
SpirvShader::Block::Block(InsnIterator begin, InsnIterator end) : begin_(begin), end_(end)
SpirvShader::Block::Block(InsnIterator begin, InsnIterator end)
: begin_(begin)
, end_(end)
{
// Default to a Simple, this may change later.
kind = Block::Simple;
......@@ -111,7 +113,7 @@ SpirvShader::Block::Block(InsnIterator begin, InsnIterator end) : begin_(begin),
}
}
void SpirvShader::Function::TraverseReachableBlocks(Block::ID id, SpirvShader::Block::Set& reachable) const
void SpirvShader::Function::TraverseReachableBlocks(Block::ID id, SpirvShader::Block::Set &reachable) const
{
if(reachable.count(id) == 0)
{
......@@ -156,8 +158,8 @@ void SpirvShader::Function::ForeachBlockDependency(Block::ID blockId, std::funct
auto block = getBlock(blockId);
for(auto dep : block.ins)
{
if(block.kind != Block::Loop || // if not a loop...
!ExistsPath(blockId, dep, block.mergeBlock)) // or a loop and not a loop back edge
if(block.kind != Block::Loop || // if not a loop...
!ExistsPath(blockId, dep, block.mergeBlock)) // or a loop and not a loop back edge
{
f(dep);
}
......@@ -196,7 +198,7 @@ void SpirvShader::EmitState::addOutputActiveLaneMaskEdge(Block::ID to, RValue<SI
void SpirvShader::EmitState::addActiveLaneMaskEdge(Block::ID from, Block::ID to, RValue<SIMD::Int> mask)
{
auto edge = Block::Edge{from, to};
auto edge = Block::Edge{ from, to };
auto it = edgeActiveLaneMasks.find(edge);
if(it == edgeActiveLaneMasks.end())
{
......@@ -212,7 +214,7 @@ void SpirvShader::EmitState::addActiveLaneMaskEdge(Block::ID from, Block::ID to,
RValue<SIMD::Int> SpirvShader::GetActiveLaneMaskEdge(EmitState *state, Block::ID from, Block::ID to) const
{
auto edge = Block::Edge{from, to};
auto edge = Block::Edge{ from, to };
auto it = state->edgeActiveLaneMasks.find(edge);
ASSERT_MSG(it != state->edgeActiveLaneMasks.end(), "Could not find edge %d -> %d", from.value(), to.value());
return it->second;
......@@ -239,8 +241,7 @@ void SpirvShader::EmitBlocks(Block::ID id, EmitState *state, Block::ID ignore /*
// Ensure all dependency blocks have been generated.
auto depsDone = true;
function.ForeachBlockDependency(id, [&](Block::ID dep)
{
function.ForeachBlockDependency(id, [&](Block::ID dep) {
if(state->visited.count(dep) == 0)
{
state->pending->push_front(dep);
......@@ -287,7 +288,7 @@ void SpirvShader::EmitNonLoop(EmitState *state) const
if(!state->visited.emplace(blockId).second)
{
return; // Already generated this block.
return; // Already generated this block.
}
if(blockId != function.entry)
......@@ -323,7 +324,7 @@ void SpirvShader::EmitLoop(EmitState *state) const
if(!state->visited.emplace(blockId).second)
{
return; // Already emitted this loop.
return; // Already emitted this loop.
}
// Gather all the blocks that make up the loop.
......@@ -414,7 +415,7 @@ void SpirvShader::EmitLoop(EmitState *state) const
// Add active lanes to the merge lane mask.
for(auto in : function.getBlock(mergeBlockId).ins)
{
auto edge = Block::Edge{in, mergeBlockId};
auto edge = Block::Edge{ in, mergeBlockId };
auto it = state->edgeActiveLaneMasks.find(edge);
if(it != state->edgeActiveLaneMasks.end())
{
......@@ -563,9 +564,9 @@ SpirvShader::EmitResult SpirvShader::EmitKill(InsnIterator insn, EmitState *stat
SpirvShader::EmitResult SpirvShader::EmitFunctionCall(InsnIterator insn, EmitState *state) const
{
auto functionId = Function::ID(insn.word(3));
const auto& functionIt = functions.find(functionId);
const auto &functionIt = functions.find(functionId);
ASSERT(functionIt != functions.end());
auto& function = functionIt->second;
auto &function = functionIt->second;
// TODO(b/141246700): Add full support for spv::OpFunctionCall
// The only supported function is a single OpKill wrapped in a
......@@ -608,15 +609,15 @@ SpirvShader::EmitResult SpirvShader::EmitControlBarrier(InsnIterator insn, EmitS
switch(executionScope)
{
case spv::ScopeWorkgroup:
Yield(YieldResult::ControlBarrier);
break;
case spv::ScopeSubgroup:
break;
default:
// See Vulkan 1.1 spec, Appendix A, Validation Rules within a Module.
UNREACHABLE("Scope for execution must be limited to Workgroup or Subgroup");
break;
case spv::ScopeWorkgroup:
Yield(YieldResult::ControlBarrier);
break;
case spv::ScopeSubgroup:
break;
default:
// See Vulkan 1.1 spec, Appendix A, Validation Rules within a Module.
UNREACHABLE("Scope for execution must be limited to Workgroup or Subgroup");
break;
}
return EmitResult::Continue;
......@@ -654,7 +655,7 @@ void SpirvShader::LoadPhi(InsnIterator insn, EmitState *state) const
}
}
void SpirvShader::StorePhi(Block::ID currentBlock, InsnIterator insn, EmitState *state, std::unordered_set<SpirvShader::Block::ID> const& filter) const
void SpirvShader::StorePhi(Block::ID currentBlock, InsnIterator insn, EmitState *state, std::unordered_set<SpirvShader::Block::ID> const &filter) const
{
auto typeId = Type::ID(insn.word(1));
auto type = getType(typeId);
......@@ -688,7 +689,7 @@ void SpirvShader::Fence(spv::MemorySemanticsMask semantics) const
{
if(semantics == spv::MemorySemanticsMaskNone)
{
return; //no-op
return; //no-op
}
rr::Fence(MemoryOrder(semantics));
}
......
src/Pipeline/SpirvShaderEnumNames.cpp
......@@ -14,15 +14,15 @@
// This file contains code used to aid debugging.
#include <spirv/unified1/spirv.h>
#include "SpirvShader.hpp"
#include <spirv/unified1/spirv.h>
// Prototypes for SPIRV-Tools functions that do not have public headers.
// This is a C++ function, so the name is mangled, and signature changes will
// result in a linker error instead of runtime signature mismatches.
// Gets the name of an instruction, without the "Op" prefix.
extern const char* spvOpcodeString(const SpvOp opcode);
extern const char *spvOpcodeString(const SpvOp opcode);
namespace sw {
......@@ -31,4 +31,4 @@ std::string SpirvShader::OpcodeName(spv::Op op)
return spvOpcodeString(static_cast<SpvOp>(op));
}
} // namespace sw
} // namespace sw
src/Pipeline/VertexProgram.cpp
......@@ -25,30 +25,27 @@
namespace sw {
VertexProgram::VertexProgram(
const VertexProcessor::State &state,
vk::PipelineLayout const *pipelineLayout,
SpirvShader const *spirvShader,
const vk::DescriptorSet::Bindings &descriptorSets)
: VertexRoutine(state, pipelineLayout, spirvShader),
descriptorSets(descriptorSets)
const VertexProcessor::State &state,
vk::PipelineLayout const *pipelineLayout,
SpirvShader const *spirvShader,
const vk::DescriptorSet::Bindings &descriptorSets)
: VertexRoutine(state, pipelineLayout, spirvShader)
, descriptorSets(descriptorSets)
{
routine.setImmutableInputBuiltins(spirvShader);
routine.setInputBuiltin(spirvShader, spv::BuiltInViewIndex, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine.setInputBuiltin(spirvShader, spv::BuiltInViewIndex, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
assert(builtin.SizeInComponents == 1);
value[builtin.FirstComponent] = As<Float4>(Int4((*Pointer<Int>(data + OFFSET(DrawData, viewID)))));
});
routine.setInputBuiltin(spirvShader, spv::BuiltInInstanceIndex, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine.setInputBuiltin(spirvShader, spv::BuiltInInstanceIndex, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
// TODO: we could do better here; we know InstanceIndex is uniform across all lanes
assert(builtin.SizeInComponents == 1);
value[builtin.FirstComponent] = As<Float4>(Int4((*Pointer<Int>(data + OFFSET(DrawData, instanceID)))));
});
routine.setInputBuiltin(spirvShader, spv::BuiltInSubgroupSize, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
{
routine.setInputBuiltin(spirvShader, spv::BuiltInSubgroupSize, [&](const SpirvShader::BuiltinMapping &builtin, Array<SIMD::Float> &value) {
ASSERT(builtin.SizeInComponents == 1);
value[builtin.FirstComponent] = As<SIMD::Float>(SIMD::Int(SIMD::Width));
});
......@@ -63,7 +60,7 @@ VertexProgram::~VertexProgram()
{
}
void VertexProgram::program(Pointer<UInt> &batch, UInt& vertexCount)
void VertexProgram::program(Pointer<UInt> &batch, UInt &vertexCount)
{
auto it = spirvShader->inputBuiltins.find(spv::BuiltInVertexIndex);
if(it != spirvShader->inputBuiltins.end())
......@@ -71,8 +68,8 @@ void VertexProgram::program(Pointer<UInt> &batch, UInt& vertexCount)
assert(it->second.SizeInComponents == 1);
routine.getVariable(it->second.Id)[it->second.FirstComponent] =
As<Float4>(*Pointer<Int4>(As<Pointer<Int4>>(batch)) +
Int4(*Pointer<Int>(data + OFFSET(DrawData, baseVertex))));
As<Float4>(*Pointer<Int4>(As<Pointer<Int4>>(batch)) +
Int4(*Pointer<Int>(data + OFFSET(DrawData, baseVertex))));
}
auto activeLaneMask = SIMD::Int(0xFFFFFFFF);
......@@ -82,4 +79,4 @@ void VertexProgram::program(Pointer<UInt> &batch, UInt& vertexCount)
spirvShader->emitEpilog(&routine);
}
} // namepsace sw
} // namespace sw
src/Pipeline/VertexProgram.hpp
......@@ -15,8 +15,8 @@
#ifndef sw_VertexProgram_hpp
#define sw_VertexProgram_hpp
#include "VertexRoutine.hpp"
#include "ShaderCore.hpp"
#include "VertexRoutine.hpp"
namespace sw {
......@@ -26,19 +26,19 @@ class VertexProgram : public VertexRoutine
{
public:
VertexProgram(
const VertexProcessor::State &state,
vk::PipelineLayout const *pipelineLayout,
SpirvShader const *spirvShader,
const vk::DescriptorSet::Bindings &descriptorSets);
const VertexProcessor::State &state,
vk::PipelineLayout const *pipelineLayout,
SpirvShader const *spirvShader,
const vk::DescriptorSet::Bindings &descriptorSets);
virtual ~VertexProgram();
private:
void program(Pointer<UInt> &batch, UInt& vertexCount) override;
void program(Pointer<UInt> &batch, UInt &vertexCount) override;
const vk::DescriptorSet::Bindings &descriptorSets;
};
} // namepsace sw
} // namespace sw
#endif // sw_VertexProgram_hpp
#endif // sw_VertexProgram_hpp
src/Pipeline/VertexRoutine.hpp
......@@ -20,14 +20,21 @@
#include "Device/Color.hpp"
#include "Device/VertexProcessor.hpp"
namespace vk { class PipelineLayout; }
namespace vk {
class PipelineLayout;
}
namespace sw {
class VertexRoutinePrototype : public VertexRoutineFunction
{
public:
VertexRoutinePrototype() : vertex(Arg<0>()), batch(Arg<1>()), task(Arg<2>()), data(Arg<3>()) {}
VertexRoutinePrototype()
: vertex(Arg<0>())
, batch(Arg<1>())
, task(Arg<2>())
, data(Arg<3>())
{}
virtual ~VertexRoutinePrototype() {}
protected:
......@@ -41,9 +48,9 @@ class VertexRoutine : public VertexRoutinePrototype
{
public:
VertexRoutine(
const VertexProcessor::State &state,
vk::PipelineLayout const *pipelineLayout,
SpirvShader const *spirvShader);
const VertexProcessor::State &state,
vk::PipelineLayout const *pipelineLayout,
SpirvShader const *spirvShader);
virtual ~VertexRoutine();
void generate();
......@@ -57,15 +64,15 @@ protected:
SpirvRoutine routine;
const VertexProcessor::State &state;
SpirvShader const * const spirvShader;
SpirvShader const *const spirvShader;
private:
virtual void program(Pointer<UInt> &batch, UInt& vertexCount) = 0;
virtual void program(Pointer<UInt> &batch, UInt &vertexCount) = 0;
typedef VertexProcessor::State::Input Stream;
Vector4f readStream(Pointer<Byte> &buffer, UInt &stride, const Stream &stream, Pointer<UInt> &batch,
bool robustBufferAccess, UInt& robustnessSize, Int baseVertex);
bool robustBufferAccess, UInt &robustnessSize, Int baseVertex);
void readInput(Pointer<UInt> &batch);
void computeClipFlags();
void computeCullMask();
......@@ -75,4 +82,4 @@ private:
} // namespace sw
#endif // sw_VertexRoutine_hpp
#endif // sw_VertexRoutine_hpp
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment