SpirvShader: Add a single-entry, last-used sampler cache

src/Pipeline/SpirvShader.cpp

@@ -2057,6 +2057,25 @@ namespace sw
 				routine->phis.emplace(resultId, SpirvRoutine::Variable(type.sizeInComponents));
 				break;
 			}
+
+			case spv::OpImageDrefGather:
+			case spv::OpImageFetch:
+			case spv::OpImageGather:
+			case spv::OpImageQueryLod:
+			case spv::OpImageSampleDrefExplicitLod:
+			case spv::OpImageSampleDrefImplicitLod:
+			case spv::OpImageSampleExplicitLod:
+			case spv::OpImageSampleImplicitLod:
+			case spv::OpImageSampleProjDrefExplicitLod:
+			case spv::OpImageSampleProjDrefImplicitLod:
+			case spv::OpImageSampleProjExplicitLod:
+			case spv::OpImageSampleProjImplicitLod:
+			{
+				Object::ID resultId = insn.word(2);
+				routine->samplerCache.emplace(resultId, SpirvRoutine::SamplerCache{});
+				break;
+			}
+
 			default:
 				// Nothing else produces interface variables, so can all be safely ignored.
 				break;
@@ -5013,10 +5032,20 @@ namespace sw
 			in[i] = sampleValue.Float(0);
 		}
 
-		auto samplerFunc = Call(getImageSampler, instruction.parameters, imageDescriptor, sampler);
+		auto cacheIt = state->routine->samplerCache.find(resultId);
+		ASSERT(cacheIt != state->routine->samplerCache.end());
+		auto &cache = cacheIt->second;
+		auto cacheHit = cache.imageDescriptor == imageDescriptor && cache.sampler == sampler;
+
+		If(!cacheHit)
+		{
+			cache.function = Call(getImageSampler, instruction.parameters, imageDescriptor, sampler);
+			cache.imageDescriptor = imageDescriptor;
+			cache.sampler = sampler;
+		}
 
 		Array<SIMD::Float> out(4);
-		Call<ImageSampler>(samplerFunc, texture, sampler, &in[0], &out[0], state->routine->constants);
+		Call<ImageSampler>(cache.function, texture, sampler, &in[0], &out[0], state->routine->constants);
 
 		for (auto i = 0u; i < resultType.sizeInComponents; i++) { result.move(i, out[i]); }
 

src/Pipeline/SpirvShader.hpp

@@ -1251,10 +1251,17 @@ namespace sw
 
 		using Variable = Array<SIMD::Float>;
 
+		struct SamplerCache
+		{
+			Pointer<Byte> imageDescriptor;
+			Pointer<Byte> sampler;
+			Pointer<Byte> function;
+		};
+
 		vk::PipelineLayout const * const pipelineLayout;
 
 		std::unordered_map<SpirvShader::Object::ID, Variable> variables;
-
+		std::unordered_map<SpirvShader::Object::ID, SamplerCache> samplerCache;
 		Variable inputs = Variable{MAX_INTERFACE_COMPONENTS};
 		Variable outputs = Variable{MAX_INTERFACE_COMPONENTS};
 

src/Reactor/LLVMReactor.cpp

@@ -1953,6 +1953,12 @@ namespace rr
 		return V(jit->builder->CreateBitCast(V(v), T(destType)));
 	}
 
+	Value *Nucleus::createPtrEQ(Value *lhs, Value *rhs)
+	{
+		RR_DEBUG_INFO_UPDATE_LOC();
+		return V(jit->builder->CreateICmpEQ(V(lhs), V(rhs)));
+	}
+
 	Value *Nucleus::createICmpEQ(Value *lhs, Value *rhs)
 	{
 		RR_DEBUG_INFO_UPDATE_LOC();

src/Reactor/Nucleus.hpp

@@ -230,6 +230,7 @@ namespace rr
 		static Value *createBitCast(Value *V, Type *destType);
 
 		// Compare instructions
+		static Value *createPtrEQ(Value *lhs, Value *rhs);
 		static Value *createICmpEQ(Value *lhs, Value *rhs);
 		static Value *createICmpNE(Value *lhs, Value *rhs);
 		static Value *createICmpUGT(Value *lhs, Value *rhs);

src/Reactor/Reactor.hpp

@@ -2356,6 +2356,12 @@ namespace rr
 	RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, RValue<Int> offset);
 	RValue<Pointer<Byte>> operator-=(Pointer<Byte> &lhs, RValue<UInt> offset);
 
+	template <typename T>
+	RValue<Bool> operator==(const Pointer<T> &lhs, const Pointer<T> &rhs)
+	{
+		return RValue<Bool>(Nucleus::createPtrEQ(lhs.loadValue(), rhs.loadValue()));
+	}
+
 	template<typename T>
 	RValue<T> Load(RValue<Pointer<T>> pointer, unsigned int alignment, bool atomic, std::memory_order memoryOrder)
 	{

src/Reactor/ReactorUnitTests.cpp

@@ -1072,6 +1072,39 @@ TEST(ReactorUnitTests, MulAdd)
 
 }
 
+TEST(ReactorUnitTests, PointersEqual)
+{
+	Function<Int(Pointer<Byte>, Pointer<Byte>)> function;
+	{
+		Pointer<Byte> ptrA = function.Arg<0>();
+		Pointer<Byte> ptrB = function.Arg<1>();
+		If (ptrA == ptrB)
+		{
+			Return(1);
+		}
+		Else
+		{
+			Return(0);
+		}
+	}
+
+	auto routine = function("one");
+	auto equal = (int(*)(void*, void*))routine->getEntry();
+	int* a = reinterpret_cast<int*>(uintptr_t(0x0000000000000000));
+	int* b = reinterpret_cast<int*>(uintptr_t(0x00000000F0000000));
+	int* c = reinterpret_cast<int*>(uintptr_t(0xF000000000000000));
+	EXPECT_EQ(equal(&a, &a), 1);
+	EXPECT_EQ(equal(&b, &b), 1);
+	EXPECT_EQ(equal(&c, &c), 1);
+
+	EXPECT_EQ(equal(&a, &b), 0);
+	EXPECT_EQ(equal(&b, &a), 0);
+	EXPECT_EQ(equal(&b, &c), 0);
+	EXPECT_EQ(equal(&c, &b), 0);
+	EXPECT_EQ(equal(&c, &a), 0);
+	EXPECT_EQ(equal(&a, &c), 0);
+}
+
 TEST(ReactorUnitTests, Call)
 {
 	if (!rr::Caps.CallSupported)

src/Reactor/SubzeroReactor.cpp

@@ -1222,6 +1222,11 @@ namespace rr
 		return V(result);
 	}
 
+	Value *Nucleus::createPtrEQ(Value *lhs, Value *rhs)
+	{
+		return createIntCompare(Ice::InstIcmp::Eq, lhs, rhs);
+	}
+
 	Value *Nucleus::createICmpEQ(Value *lhs, Value *rhs)
 	{
 		return createIntCompare(Ice::InstIcmp::Eq, lhs, rhs);