Skip to content

S
swiftshader
Commit 88ac367c by Nicolas Capens Committed by Nicolas Capens
Options

Remove idle Blitter fallbacks

For Vulkan we must support all blittable formats natively, so there's no fallback to C++ code. Also, if by error an unsupported format is used we don't have to immediately abort routine generation but can continue with something that's benign. This change simplifies the code, makes it more readable/maintainable, and marks other formats as unsupported instead of unimplemented. Bug: b/138944025 Bug: b/131243109 Change-Id: I4d246cdd280c5a352f18341996c92111a5144d96 Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/34588 Presubmit-Ready: Nicolas Capens <nicolascapens@google.com> Tested-by: 's avatarNicolas Capens <nicolascapens@google.com> Kokoro-Presubmit: kokoro <noreply+kokoro@google.com> Reviewed-by: 's avatarBen Clayton <bclayton@google.com>
parent 30857ca2
Showing with 122 additions and 148 deletions
src/Device/Blitter.cpp
......@@ -257,9 +257,9 @@ namespace sw
return true;
}
bool Blitter::read(Float4 &c, Pointer<Byte> element, const State &state)
Float4 Blitter::readFloat4(Pointer<Byte> element, const State &state)
{
c = Float4(0.0f, 0.0f, 0.0f, 1.0f);
Float4 c(0.0f, 0.0f, 0.0f, 1.0f);
switch(state.sourceFormat)
{
......@@ -448,13 +448,13 @@ namespace sw
c.x = Float(Int(*Pointer<Byte>(element)));
break;
default:
return false;
UNSUPPORTED("Blitter source format %d", (int)state.sourceFormat);
}
return true;
return c;
}
bool Blitter::write(Float4 &c, Pointer<Byte> element, const State &state)
void Blitter::write(Float4 &c, Pointer<Byte> element, const State &state)
{
bool writeR = state.writeRed;
bool writeG = state.writeGreen;
......@@ -983,14 +983,14 @@ namespace sw
*Pointer<Byte>(element) = Byte(RoundInt(Float(c.x)));
break;
default:
return false;
UNSUPPORTED("Blitter destination format %d", (int)state.destFormat);
break;
}
return true;
}
bool Blitter::read(Int4 &c, Pointer<Byte> element, const State &state)
Int4 Blitter::readInt4(Pointer<Byte> element, const State &state)
{
c = Int4(0, 0, 0, 1);
Int4 c(0, 0, 0, 1);
switch(state.sourceFormat)
{
......@@ -1046,13 +1046,13 @@ namespace sw
c = Insert(c, *Pointer<Int>(element), 0);
break;
default:
return false;
UNSUPPORTED("Blitter source format %d", (int)state.sourceFormat);
}
return true;
return c;
}
bool Blitter::write(Int4 &c, Pointer<Byte> element, const State &state)
void Blitter::write(Int4 &c, Pointer<Byte> element, const State &state)
{
bool writeR = state.writeRed;
bool writeG = state.writeGreen;
......@@ -1273,15 +1273,14 @@ namespace sw
if(writeR) { *Pointer<UInt>(element) = As<UInt>(Extract(c, 0)); }
break;
default:
return false;
UNSUPPORTED("Blitter destination format %d", (int)state.destFormat);
}
return true;
}
bool Blitter::ApplyScaleAndClamp(Float4 &value, const State &state, bool preScaled)
void Blitter::ApplyScaleAndClamp(Float4 &value, const State &state, bool preScaled)
{
float4 scale, unscale;
if(state.clearOperation &&
state.sourceFormat.isNonNormalizedInteger() &&
!state.destFormat.isNonNormalizedInteger())
......@@ -1297,18 +1296,15 @@ namespace sw
unscale = replicate(static_cast<float>(0xFFFFFFFF));
break;
default:
return false;
UNSUPPORTED("Blitter source format %d", (int)state.sourceFormat);
}
}
else if(!state.sourceFormat.getScale(unscale))
else
{
return false;
unscale = state.sourceFormat.getScale();
}
if(!state.destFormat.getScale(scale))
{
return false;
}
scale = state.destFormat.getScale();
bool srcSRGB = state.sourceFormat.isSRGBformat();
bool dstSRGB = state.destFormat.isSRGBformat();
......@@ -1334,8 +1330,6 @@ namespace sw
state.destFormat.isUnsignedComponent(2) ? 0.0f : -scale.z,
state.destFormat.isUnsignedComponent(3) ? 0.0f : -scale.w));
}
return true;
}
Int Blitter::ComputeOffset(Int &x, Int &y, Int &pitchB, int bytes, bool quadLayout)
......@@ -1416,24 +1410,15 @@ namespace sw
{
if(intBoth) // Integer types
{
if(!read(constantColorI, source, state))
{
return nullptr;
}
constantColorI = readInt4(source, state);
hasConstantColorI = true;
}
else
{
if(!read(constantColorF, source, state))
{
return nullptr;
}
constantColorF = readFloat4(source, state);
hasConstantColorF = true;
if(!ApplyScaleAndClamp(constantColorF, state))
{
return nullptr;
}
ApplyScaleAndClamp(constantColorF, state);
}
}
......@@ -1449,26 +1434,19 @@ namespace sw
if(hasConstantColorI)
{
if(!write(constantColorI, d, state))
{
return nullptr;
}
write(constantColorI, d, state);
}
else if(hasConstantColorF)
{
for(int s = 0; s < state.destSamples; s++)
{
if(!write(constantColorF, d, state))
{
return nullptr;
}
write(constantColorF, d, state);
d += *Pointer<Int>(blit + OFFSET(BlitData, dSliceB));
}
}
else if(intBoth) // Integer types do not support filtering
{
Int4 color; // When both formats are true integer types, we don't go to float to avoid losing precision
Int X = Int(x);
Int Y = Int(y);
......@@ -1480,15 +1458,9 @@ namespace sw
Pointer<Byte> s = source + ComputeOffset(X, Y, sPitchB, srcBytes, srcQuadLayout);
if(!read(color, s, state))
{
return nullptr;
}
if(!write(color, d, state))
{
return nullptr;
}
// When both formats are true integer types, we don't go to float to avoid losing precision
Int4 color = readInt4(s, state);
write(color, d, state);
}
else
{
......@@ -1508,29 +1480,24 @@ namespace sw
Pointer<Byte> s = source + ComputeOffset(X, Y, sPitchB, srcBytes, srcQuadLayout);
if(!read(color, s, state))
{
return nullptr;
}
color = readFloat4(s, state);
if(state.srcSamples > 1) // Resolve multisampled source
{
if(state.convertSRGB && state.sourceFormat.isSRGBformat()) // sRGB -> RGB
{
if(!ApplyScaleAndClamp(color, state)) return nullptr;
ApplyScaleAndClamp(color, state);
preScaled = true;
}
Float4 accum = color;
for(int sample = 1; sample < state.srcSamples; sample++)
{
s += *Pointer<Int>(blit + OFFSET(BlitData, sSliceB));
if(!read(color, s, state))
{
return nullptr;
}
color = readFloat4(s, state);
if(state.convertSRGB && state.sourceFormat.isSRGBformat()) // sRGB -> RGB
{
if(!ApplyScaleAndClamp(color, state)) return nullptr;
ApplyScaleAndClamp(color, state);
preScaled = true;
}
accum += color;
......@@ -1565,17 +1532,17 @@ namespace sw
Pointer<Byte> s10 = source + ComputeOffset(X0, Y1, sPitchB, srcBytes, srcQuadLayout);
Pointer<Byte> s11 = source + ComputeOffset(X1, Y1, sPitchB, srcBytes, srcQuadLayout);
Float4 c00; if(!read(c00, s00, state)) return nullptr;
Float4 c01; if(!read(c01, s01, state)) return nullptr;
Float4 c10; if(!read(c10, s10, state)) return nullptr;
Float4 c11; if(!read(c11, s11, state)) return nullptr;
Float4 c00 = readFloat4(s00, state);
Float4 c01 = readFloat4(s01, state);
Float4 c10 = readFloat4(s10, state);
Float4 c11 = readFloat4(s11, state);
if(state.convertSRGB && state.sourceFormat.isSRGBformat()) // sRGB -> RGB
{
if(!ApplyScaleAndClamp(c00, state)) return nullptr;
if(!ApplyScaleAndClamp(c01, state)) return nullptr;
if(!ApplyScaleAndClamp(c10, state)) return nullptr;
if(!ApplyScaleAndClamp(c11, state)) return nullptr;
ApplyScaleAndClamp(c00, state);
ApplyScaleAndClamp(c01, state);
ApplyScaleAndClamp(c10, state);
ApplyScaleAndClamp(c11, state);
preScaled = true;
}
......@@ -1588,17 +1555,11 @@ namespace sw
(c10 * ix + c11 * fx) * fy;
}
if(!ApplyScaleAndClamp(color, state, preScaled))
{
return nullptr;
}
ApplyScaleAndClamp(color, state, preScaled);
for(int s = 0; s < state.destSamples; s++)
{
if(!write(color, d, state))
{
return nullptr;
}
write(color, d, state);
d += *Pointer<Int>(blit + OFFSET(BlitData,dSliceB));
}
......@@ -1618,13 +1579,6 @@ namespace sw
if(!blitRoutine)
{
blitRoutine = generate(state);
if(!blitRoutine)
{
UNIMPLEMENTED("blitRoutine");
return nullptr;
}
blitCache.add(state, blitRoutine);
}
......@@ -1639,13 +1593,6 @@ namespace sw
if(!cornerUpdateRoutine)
{
cornerUpdateRoutine = generateCornerUpdate(state);
if(!cornerUpdateRoutine)
{
UNIMPLEMENTED("cornerUpdateRoutine");
return nullptr;
}
cornerUpdateCache.add(state, cornerUpdateRoutine);
}
......@@ -1918,15 +1865,13 @@ namespace sw
int bytes = state.sourceFormat.bytes();
bool quadLayout = state.sourceFormat.hasQuadLayout();
Float4 c0;
read(c0, layer + ComputeOffset(x0, y1, pitchB, bytes, quadLayout), state);
Float4 c1;
read(c1, layer + ComputeOffset(x1, y0, pitchB, bytes, quadLayout), state);
c0 += c1;
read(c1, layer + ComputeOffset(x1, y1, pitchB, bytes, quadLayout), state);
c0 += c1;
c0 *= Float4(1.0f / 3.0f);
write(c0, layer + ComputeOffset(x0, y0, pitchB, bytes, quadLayout), state);
Float4 c = readFloat4(layer + ComputeOffset(x0, y1, pitchB, bytes, quadLayout), state) +
readFloat4(layer + ComputeOffset(x1, y0, pitchB, bytes, quadLayout), state) +
readFloat4(layer + ComputeOffset(x1, y1, pitchB, bytes, quadLayout), state);
c *= Float4(1.0f / 3.0f);
write(c, layer + ComputeOffset(x0, y0, pitchB, bytes, quadLayout), state);
}
std::shared_ptr<Routine> Blitter::generateCornerUpdate(const State& state)
......@@ -2082,7 +2027,7 @@ namespace sw
int h = extent.height;
if(w != h)
{
UNIMPLEMENTED("Cube doesn't have square faces : (%d, %d)", w, h);
UNSUPPORTED("Cube doesn't have square faces : (%d, %d)", w, h);
}
// Src is expressed in the regular [0, width-1], [0, height-1] space
......
src/Device/Blitter.hpp
......@@ -126,11 +126,11 @@ namespace sw
bool fastClear(void *pixel, vk::Format format, vk::Image *dest, const vk::Format& viewFormat, const VkImageSubresourceRange& subresourceRange, const VkRect2D* renderArea);
bool read(Float4 &color, Pointer<Byte> element, const State &state);
bool write(Float4 &color, Pointer<Byte> element, const State &state);
bool read(Int4 &color, Pointer<Byte> element, const State &state);
bool write(Int4 &color, Pointer<Byte> element, const State &state);
static bool ApplyScaleAndClamp(Float4 &value, const State &state, bool preScaled = false);
Float4 readFloat4(Pointer<Byte> element, const State &state);
void write(Float4 &color, Pointer<Byte> element, const State &state);
Int4 readInt4(Pointer<Byte> element, const State &state);
void write(Int4 &color, Pointer<Byte> element, const State &state);
static void ApplyScaleAndClamp(Float4 &value, const State &state, bool preScaled = false);
static Int ComputeOffset(Int &x, Int &y, Int &pitchB, int bytes, bool quadLayout);
static Float4 LinearToSRGB(Float4 &color);
static Float4 sRGBtoLinear(Float4 &color);
......
src/Reactor/LLVMReactor.cpp
......@@ -3508,6 +3508,18 @@ namespace rr
return T(Type_v2f32);
}
RValue<Float> Exp2(RValue<Float> v)
{
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::exp2, { T(Float::getType()) } );
return RValue<Float>(V(jit->builder->CreateCall(func, V(v.value))));
}
RValue<Float> Log2(RValue<Float> v)
{
auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::log2, { T(Float::getType()) } );
return RValue<Float>(V(jit->builder->CreateCall(func, V(v.value))));
}
Float4::Float4(RValue<Float> rhs) : XYZW(this)
{
RR_DEBUG_INFO_UPDATE_LOC();
......
src/Reactor/Reactor.hpp
......@@ -2092,11 +2092,38 @@ namespace rr
RValue<Float> Rcp_pp(RValue<Float> val, bool exactAtPow2 = false);
RValue<Float> RcpSqrt_pp(RValue<Float> val);
RValue<Float> Sqrt(RValue<Float> x);
RValue<Float> Round(RValue<Float> val);
RValue<Float> Trunc(RValue<Float> val);
RValue<Float> Frac(RValue<Float> val);
RValue<Float> Floor(RValue<Float> val);
RValue<Float> Ceil(RValue<Float> val);
// RValue<Int4> IsInf(RValue<Float> x);
// RValue<Int4> IsNan(RValue<Float> x);
RValue<Float> Round(RValue<Float> x);
RValue<Float> Trunc(RValue<Float> x);
RValue<Float> Frac(RValue<Float> x);
RValue<Float> Floor(RValue<Float> x);
RValue<Float> Ceil(RValue<Float> x);
// Trigonometric functions
// TODO: Currently unimplemented for Subzero.
// RValue<Float> Sin(RValue<Float> x);
// RValue<Float> Cos(RValue<Float> x);
// RValue<Float> Tan(RValue<Float> x);
// RValue<Float> Asin(RValue<Float> x);
// RValue<Float> Acos(RValue<Float> x);
// RValue<Float> Atan(RValue<Float> x);
// RValue<Float> Sinh(RValue<Float> x);
// RValue<Float> Cosh(RValue<Float> x);
// RValue<Float> Tanh(RValue<Float> x);
// RValue<Float> Asinh(RValue<Float> x);
// RValue<Float> Acosh(RValue<Float> x);
// RValue<Float> Atanh(RValue<Float> x);
// RValue<Float> Atan2(RValue<Float> x, RValue<Float> y);
// Exponential functions
// TODO: Currently unimplemented for Subzero.
// RValue<Float> Pow(RValue<Float> x, RValue<Float> y);
// RValue<Float> Exp(RValue<Float> x);
// RValue<Float> Log(RValue<Float> x);
RValue<Float> Exp2(RValue<Float> x);
RValue<Float> Log2(RValue<Float> x);
class Float2 : public LValue<Float2>
{
......@@ -2264,7 +2291,7 @@ namespace rr
RValue<Float4> Ceil(RValue<Float4> x);
// Trigonometric functions
// TODO: Currentlhy unimplemented for Subzero.
// TODO: Currently unimplemented for Subzero.
RValue<Float4> Sin(RValue<Float4> x);
RValue<Float4> Cos(RValue<Float4> x);
RValue<Float4> Tan(RValue<Float4> x);
......@@ -2280,7 +2307,7 @@ namespace rr
RValue<Float4> Atan2(RValue<Float4> x, RValue<Float4> y);
// Exponential functions
// TODO: Currentlhy unimplemented for Subzero.
// TODO: Currently unimplemented for Subzero.
RValue<Float4> Pow(RValue<Float4> x, RValue<Float4> y);
RValue<Float4> Exp(RValue<Float4> x);
RValue<Float4> Log(RValue<Float4> x);
......@@ -2288,7 +2315,7 @@ namespace rr
RValue<Float4> Log2(RValue<Float4> x);
// Bit Manipulation functions.
// TODO: Currentlhy unimplemented for Subzero.
// TODO: Currently unimplemented for Subzero.
// Count leading zeros.
// Returns 32 when: isZeroUndef && x == 0.
......
src/Reactor/SubzeroReactor.cpp
......@@ -3522,6 +3522,8 @@ namespace rr
void Nucleus::createMaskedStore(Value *ptr, Value *val, Value *mask, unsigned int alignment) { UNIMPLEMENTED("Subzero createMaskedStore()"); }
Value *Nucleus::createGather(Value *base, Type *elTy, Value *offsets, Value *mask, unsigned int alignment, bool zeroMaskedLanes) { UNIMPLEMENTED("Subzero createGather()"); return nullptr; }
void Nucleus::createScatter(Value *base, Value *val, Value *offsets, Value *mask, unsigned int alignment) { UNIMPLEMENTED("Subzero createScatter()"); }
RValue<Float> Exp2(RValue<Float> x) { UNIMPLEMENTED("Subzero Exp2()"); return Float(0); }
RValue<Float> Log2(RValue<Float> x) { UNIMPLEMENTED("Subzero Log2()"); return Float(0); }
RValue<Float4> Sin(RValue<Float4> x) { UNIMPLEMENTED("Subzero Sin()"); return Float4(0); }
RValue<Float4> Cos(RValue<Float4> x) { UNIMPLEMENTED("Subzero Cos()"); return Float4(0); }
RValue<Float4> Tan(RValue<Float4> x) { UNIMPLEMENTED("Subzero Tan()"); return Float4(0); }
......
src/Vulkan/VkFormat.cpp
......@@ -1724,15 +1724,14 @@ int Format::sliceB(int width, int height, int border, bool target) const
return sw::align<16>(sliceBUnpadded(width, height, border, target) + 15);
}
bool Format::getScale(sw::float4 &scale) const
sw::float4 Format::getScale() const
{
switch(format)
{
case VK_FORMAT_R4G4_UNORM_PACK8:
case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
scale = sw::vector(0xF, 0xF, 0xF, 0xF);
break;
return sw::vector(0xF, 0xF, 0xF, 0xF);
case VK_FORMAT_R8_UNORM:
case VK_FORMAT_R8G8_UNORM:
case VK_FORMAT_R8G8B8_UNORM:
......@@ -1747,8 +1746,7 @@ bool Format::getScale(sw::float4 &scale) const
case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
case VK_FORMAT_R8G8B8A8_SRGB:
case VK_FORMAT_B8G8R8A8_SRGB:
scale = sw::vector(0xFF, 0xFF, 0xFF, 0xFF);
break;
return sw::vector(0xFF, 0xFF, 0xFF, 0xFF);
case VK_FORMAT_R8_SNORM:
case VK_FORMAT_R8G8_SNORM:
case VK_FORMAT_R8G8B8_SNORM:
......@@ -1756,20 +1754,17 @@ bool Format::getScale(sw::float4 &scale) const
case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
case VK_FORMAT_R8G8B8A8_SNORM:
case VK_FORMAT_B8G8R8A8_SNORM:
scale = sw::vector(0x7F, 0x7F, 0x7F, 0x7F);
break;
return sw::vector(0x7F, 0x7F, 0x7F, 0x7F);
case VK_FORMAT_R16_UNORM:
case VK_FORMAT_R16G16_UNORM:
case VK_FORMAT_R16G16B16_UNORM:
case VK_FORMAT_R16G16B16A16_UNORM:
scale = sw::vector(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF);
break;
return sw::vector(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF);
case VK_FORMAT_R16_SNORM:
case VK_FORMAT_R16G16_SNORM:
case VK_FORMAT_R16G16B16_SNORM:
case VK_FORMAT_R16G16B16A16_SNORM:
scale = sw::vector(0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF);
break;
return sw::vector(0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF);
case VK_FORMAT_R8_SINT:
case VK_FORMAT_R8_UINT:
case VK_FORMAT_R8G8_SINT:
......@@ -1838,42 +1833,35 @@ bool Format::getScale(sw::float4 &scale) const
case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
case VK_FORMAT_A2B10G10R10_UINT_PACK32:
case VK_FORMAT_A2B10G10R10_SINT_PACK32:
scale = sw::vector(1.0f, 1.0f, 1.0f, 1.0f);
break;
return sw::vector(1.0f, 1.0f, 1.0f, 1.0f);
case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
scale = sw::vector(0x1F, 0x1F, 0x1F, 0x01);
break;
return sw::vector(0x1F, 0x1F, 0x1F, 0x01);
case VK_FORMAT_R5G6B5_UNORM_PACK16:
case VK_FORMAT_B5G6R5_UNORM_PACK16:
scale = sw::vector(0x1F, 0x3F, 0x1F, 1.0f);
break;
return sw::vector(0x1F, 0x3F, 0x1F, 1.0f);
case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
scale = sw::vector(0x3FF, 0x3FF, 0x3FF, 0x03);
break;
return sw::vector(0x3FF, 0x3FF, 0x3FF, 0x03);
case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
scale = sw::vector(0x1FF, 0x1FF, 0x1FF, 0x01);
break;
return sw::vector(0x1FF, 0x1FF, 0x1FF, 0x01);
case VK_FORMAT_D16_UNORM:
scale = sw::vector(0xFFFF, 0.0f, 0.0f, 0.0f);
break;
return sw::vector(0xFFFF, 0.0f, 0.0f, 0.0f);
case VK_FORMAT_D24_UNORM_S8_UINT:
case VK_FORMAT_X8_D24_UNORM_PACK32:
scale = sw::vector(0xFFFFFF, 0.0f, 0.0f, 0.0f);
break;
return sw::vector(0xFFFFFF, 0.0f, 0.0f, 0.0f);
case VK_FORMAT_D32_SFLOAT:
case VK_FORMAT_D32_SFLOAT_S8_UINT:
case VK_FORMAT_S8_UINT:
scale = sw::vector(1.0f, 1.0f, 1.0f, 1.0f);
break;
return sw::vector(1.0f, 1.0f, 1.0f, 1.0f);
default:
return false;
UNSUPPORTED("format %d", int(format));
break;
}
return true;
return sw::vector(1.0f, 1.0f, 1.0f, 1.0f);
}
bool Format::has16bitTextureFormat() const
......
src/Vulkan/VkFormat.h
......@@ -60,7 +60,7 @@ public:
int pitchB(int width, int border, bool target) const;
int sliceB(int width, int height, int border, bool target) const;
bool getScale(sw::float4 &scale) const;
sw::float4 getScale() const;
// Texture sampling utilities
bool has16bitTextureFormat() const;
......
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