Faster image sampler fetch from key

src/Device/LRUCache.hpp

@@ -19,6 +19,7 @@
 
 #include <cstring>
 #include <type_traits>
+#include <unordered_map>
 
 namespace sw
 {
@@ -28,15 +29,15 @@ namespace sw
 	public:
 		LRUCache(int n);
 
-		~LRUCache();
+		virtual ~LRUCache();
 
 		Data *query(const Key &key) const;
-		Data *add(const Key &key, Data *data);
+		virtual Data *add(const Key &key, Data *data);
 
 		int getSize() {return size;}
 		Key &getKey(int i) {return key[i];}
 
-	private:
+	protected:
 		int size;
 		int mask;
 		int top;
@@ -47,6 +48,29 @@ namespace sw
 		Data **data;
 	};
 
+	template<class Key, class Data>
+	class LRUConstCache : public LRUCache<Key, Data>
+	{
+		using LRUBase = LRUCache<Key, Data>;
+	public:
+		LRUConstCache(int n) : LRUBase(n) {}
+		~LRUConstCache() { clearConstCache(); }
+
+		Data *add(const Key &key, Data *data) override
+		{
+			constCacheNeedsUpdate = true;
+			return LRUBase::add(key, data);
+		}
+
+		void updateConstCache();
+		Data *queryConstCache(const Key &key) const;
+
+	private:
+		void clearConstCache();
+		bool constCacheNeedsUpdate = false;
+		std::unordered_map<Key, Data*> constCache;
+	};
+
 	// Helper class for clearing the memory of objects at construction.
 	// Useful as the first base class of cache keys which may contain padding bytes or bits otherwise left uninitialized.
 	template<class T>
@@ -183,6 +207,45 @@ namespace sw
 
 		return data;
 	}
+
+	template<class Key, class Data>
+	void LRUConstCache<Key, Data>::clearConstCache()
+	{
+		auto it = constCache.begin();
+		auto itEnd = constCache.end();
+		for(; it != itEnd; ++it)
+		{
+			it->second->unbind();
+		}
+		constCache.clear();
+	}
+
+	template<class Key, class Data>
+	void LRUConstCache<Key, Data>::updateConstCache()
+	{
+		if(constCacheNeedsUpdate)
+		{
+			clearConstCache();
+
+			for(int i = 0; i < LRUBase::size; i++)
+			{
+				if(LRUBase::data[i])
+				{
+					LRUBase::data[i]->bind();
+					constCache[*LRUBase::ref[i]] = LRUBase::data[i];
+				}
+			}
+
+			constCacheNeedsUpdate = false;
+		}
+	}
+
+	template<class Key, class Data>
+	Data *LRUConstCache<Key, Data>::queryConstCache(const Key &key) const
+	{
+		auto it = constCache.find(key);
+		return (it != constCache.end()) ? it->second : nullptr;
+	}
 }
 
 #endif   // sw_LRUCache_hpp

src/Device/Renderer.cpp

@@ -26,6 +26,7 @@
 #include "System/Timer.hpp"
 #include "Vulkan/VkConfig.h"
 #include "Vulkan/VkDebug.hpp"
+#include "Vulkan/VkDevice.hpp"
 #include "Vulkan/VkFence.hpp"
 #include "Vulkan/VkImageView.hpp"
 #include "Vulkan/VkQueryPool.hpp"
@@ -162,7 +163,7 @@ namespace sw
 		deallocate(data);
 	}
 
-	Renderer::Renderer()
+	Renderer::Renderer(vk::Device* device) : device(device)
 	{
 		for(int i = 0; i < 16; i++)
 		{
@@ -733,6 +734,7 @@ namespace sw
 	void Renderer::synchronize()
 	{
 		sync.wait();
+		device->updateSamplingRoutineConstCache();
 	}
 
 	void Renderer::finishRendering(Task &pixelTask)

src/Device/Renderer.hpp

@@ -32,6 +32,7 @@
 namespace vk
 {
 	class DescriptorSet;
+	class Device;
 	class Query;
 }
 
@@ -156,7 +157,7 @@ namespace sw
 		};
 
 	public:
-		Renderer();
+		Renderer(vk::Device* device);
 
 		virtual ~Renderer();
 
@@ -254,6 +255,8 @@ namespace sw
 		Routine *vertexRoutine;
 		Routine *setupRoutine;
 		Routine *pixelRoutine;
+
+		vk::Device* device;
 	};
 
 	struct DrawCall

src/Pipeline/SpirvShaderSampling.cpp

@@ -40,10 +40,16 @@ SpirvShader::ImageSampler *SpirvShader::getImageSampler(uint32_t inst, vk::Sampl
 
 	ASSERT(imageDescriptor->device);
 
+	rr::Routine* routine = imageDescriptor->device->findInConstCache(key);
+	if(routine)
+	{
+		return (ImageSampler*)(routine->getEntry());
+	}
+
 	std::unique_lock<std::mutex> lock(imageDescriptor->device->getSamplingRoutineCacheMutex());
 	vk::Device::SamplingRoutineCache* cache = imageDescriptor->device->getSamplingRoutineCache();
 
-	rr::Routine* routine = cache->query(key);
+	routine = cache->query(key);
 	if(routine)
 	{
 		return (ImageSampler*)(routine->getEntry());

src/Vulkan/VkDevice.cpp

@@ -47,7 +47,17 @@ void Device::SamplingRoutineCache::add(const vk::Device::SamplingRoutineCache::K
 	cache.add(hash(key), routine);
 }
 
-std::size_t Device::SamplingRoutineCache::hash(const vk::Device::SamplingRoutineCache::Key &key) const
+rr::Routine* Device::SamplingRoutineCache::queryConst(const vk::Device::SamplingRoutineCache::Key& key) const
+{
+	return cache.queryConstCache(hash(key));
+}
+
+void Device::SamplingRoutineCache::updateConstCache()
+{
+	cache.updateConstCache();
+}
+
+std::size_t Device::SamplingRoutineCache::hash(const vk::Device::SamplingRoutineCache::Key &key)
 {
 	return (key.instruction << 16) ^ (key.sampler << 8) ^ key.imageView;
 }
@@ -71,7 +81,7 @@ Device::Device(const VkDeviceCreateInfo* pCreateInfo, void* mem, PhysicalDevice
 
 		for(uint32_t j = 0; j < queueCreateInfo.queueCount; j++, queueID++)
 		{
-			new (&queues[queueID]) Queue();
+			new (&queues[queueID]) Queue(this);
 		}
 	}
 
@@ -89,6 +99,7 @@ Device::Device(const VkDeviceCreateInfo* pCreateInfo, void* mem, PhysicalDevice
 
 	// FIXME (b/119409619): use an allocator here so we can control all memory allocations
 	blitter.reset(new sw::Blitter());
+	samplingRoutineCache.reset(new SamplingRoutineCache());
 }
 
 void Device::destroy(const VkAllocationCallbacks* pAllocator)
@@ -235,15 +246,22 @@ void Device::updateDescriptorSets(uint32_t descriptorWriteCount, const VkWriteDe
 	}
 }
 
-Device::SamplingRoutineCache* Device::getSamplingRoutineCache()
+Device::SamplingRoutineCache* Device::getSamplingRoutineCache() const
 {
-	if(!samplingRoutineCache.get())
-	{
-		samplingRoutineCache.reset(new SamplingRoutineCache());
-	}
 	return samplingRoutineCache.get();
 }
 
+rr::Routine* Device::findInConstCache(const SamplingRoutineCache::Key& key) const
+{
+	return samplingRoutineCache->queryConst(key);
+}
+
+void Device::updateSamplingRoutineConstCache()
+{
+	std::unique_lock<std::mutex> lock(samplingRoutineCacheMutex);
+	samplingRoutineCache->updateConstCache();
+}
+
 std::mutex& Device::getSamplingRoutineCacheMutex()
 {
 	return samplingRoutineCacheMutex;

src/Vulkan/VkDevice.hpp

@@ -24,7 +24,6 @@
 namespace sw
 {
 	class Blitter;
-	class SamplingRoutineCache;
 }
 
 namespace vk
@@ -71,13 +70,19 @@ public:
 		rr::Routine* query(const Key& key) const;
 		void add(const Key& key, rr::Routine* routine);
 
+		rr::Routine* queryConst(const Key& key) const;
+		void updateConstCache();
+
+		static std::size_t hash(const Key &key);
+
 	private:
-		std::size_t hash(const Key &key) const;
-		sw::LRUCache<std::size_t, rr::Routine> cache;
+		sw::LRUConstCache<std::size_t, rr::Routine> cache;
 	};
 
-	SamplingRoutineCache* getSamplingRoutineCache();
+	SamplingRoutineCache* getSamplingRoutineCache() const;
 	std::mutex& getSamplingRoutineCacheMutex();
+	rr::Routine* findInConstCache(const SamplingRoutineCache::Key& key) const;
+	void updateSamplingRoutineConstCache();
 
 private:
 	PhysicalDevice *const physicalDevice = nullptr;

src/Vulkan/VkQueue.cpp

@@ -74,7 +74,7 @@ VkSubmitInfo* DeepCopySubmitInfo(uint32_t submitCount, const VkSubmitInfo* pSubm
 namespace vk
 {
 
-Queue::Queue() : renderer()
+Queue::Queue(Device* device) : renderer(device)
 {
 	queueThread = std::thread(TaskLoop, this);
 }

src/Vulkan/VkQueue.hpp

@@ -31,6 +31,7 @@ namespace sw
 namespace vk
 {
 
+class Device;
 class Fence;
 
 class Queue
@@ -38,7 +39,7 @@ class Queue
 	VK_LOADER_DATA loaderData = { ICD_LOADER_MAGIC };
 
 public:
-	Queue();
+	Queue(Device* device);
 	~Queue();
 
 	operator VkQueue()