Eventually corrected pipelines deduplication

(ex06 now uses just 2 GL shaders)

Author: Crisspl

examples_tests/06.MeshLoaders/main.cpp

@@ -13,6 +13,36 @@
 using namespace irr;
 using namespace core;
 
+static std::size_t pipeline_hash(asset::ICPURenderpassIndependentPipeline* _ppln)
+{
+    constexpr size_t bytesToHash =
+        asset::SVertexInputParams::serializedSize() +
+        asset::SBlendParams::serializedSize() +
+        asset::SRasterizationParams::serializedSize() +
+        asset::SPrimitiveAssemblyParams::serializedSize() +
+        sizeof(void*) * asset::ICPURenderpassIndependentPipeline::SHADER_STAGE_COUNT +//shaders
+        sizeof(void*);//layout
+    uint8_t mem[bytesToHash]{};
+    uint32_t offset = 0u;
+    _ppln->getVertexInputParams().serialize(mem + offset);
+    offset += asset::SVertexInputParams::serializedSize();
+    _ppln->getBlendParams().serialize(mem + offset);
+    offset += asset::SBlendParams::serializedSize();
+    _ppln->getRasterizationParams().serialize(mem + offset);
+    offset += sizeof(asset::SRasterizationParams);
+    _ppln->getPrimitiveAssemblyParams().serialize(mem + offset);
+    offset += sizeof(asset::SPrimitiveAssemblyParams);
+    const asset::ICPUSpecializedShader** shaders = reinterpret_cast<const asset::ICPUSpecializedShader**>(mem + offset);
+    for (uint32_t i = 0u; i < asset::ICPURenderpassIndependentPipeline::SHADER_STAGE_COUNT; ++i)
+        shaders[i] = _ppln->getShaderAtIndex(i);
+    offset += asset::ICPURenderpassIndependentPipeline::SHADER_STAGE_COUNT * sizeof(void*);
+    reinterpret_cast<const asset::ICPUPipelineLayout**>(mem + offset)[0] = _ppln->getLayout();
+
+    const std::size_t hs = std::hash<std::string_view>{}(std::string_view(reinterpret_cast<const char*>(mem), bytesToHash));
+
+    return hs;
+}
+
 int main()
 {
 	// create device with full flexibility over creation parameters

include/irr/video/IGPUObjectFromAssetConverter.h

@@ -217,9 +217,9 @@ class CAssetPreservingGPUObjectFromAssetConverter : public IGPUObjectFromAssetCo
 
 // need to specialize outside because of GCC
 template<>
-struct IGPUObjectFromAssetConverter::Hash<asset::ICPURenderpassIndependentPipeline>
+struct IGPUObjectFromAssetConverter::Hash<const asset::ICPURenderpassIndependentPipeline>
 {
-    inline std::size_t operator()(asset::ICPURenderpassIndependentPipeline* _ppln) const
+    inline std::size_t operator()(const asset::ICPURenderpassIndependentPipeline* _ppln) const
     {
         constexpr size_t bytesToHash = 
             asset::SVertexInputParams::serializedSize()+
@@ -250,9 +250,9 @@ struct IGPUObjectFromAssetConverter::Hash<asset::ICPURenderpassIndependentPipeli
     }
 };
 template<>
-struct IGPUObjectFromAssetConverter::Hash<asset::ICPUComputePipeline>
+struct IGPUObjectFromAssetConverter::Hash<const asset::ICPUComputePipeline>
 {
-    inline std::size_t operator()(asset::ICPUComputePipeline* _ppln) const
+    inline std::size_t operator()(const asset::ICPUComputePipeline* _ppln) const
     {
         constexpr size_t bytesToHash = 
             sizeof(void*)+//shader
@@ -269,16 +269,16 @@ struct IGPUObjectFromAssetConverter::Hash<asset::ICPUComputePipeline>
 };
 
 template<>
-struct IGPUObjectFromAssetConverter::KeyEqual<asset::ICPURenderpassIndependentPipeline>
+struct IGPUObjectFromAssetConverter::KeyEqual<const asset::ICPURenderpassIndependentPipeline>
 {
     //equality depends on hash only
-    bool operator()(asset::ICPURenderpassIndependentPipeline* lhs, asset::ICPURenderpassIndependentPipeline* rhs) const { return true; }
+    bool operator()(const asset::ICPURenderpassIndependentPipeline* lhs, const asset::ICPURenderpassIndependentPipeline* rhs) const { return true; }
 };
 template<>
-struct IGPUObjectFromAssetConverter::KeyEqual<asset::ICPUComputePipeline>
+struct IGPUObjectFromAssetConverter::KeyEqual<const asset::ICPUComputePipeline>
 {
     //equality depends on hash only
-    bool operator()(asset::ICPUComputePipeline* lhs, asset::ICPUComputePipeline* rhs) const { return true; }
+    bool operator()(const asset::ICPUComputePipeline* lhs, const asset::ICPUComputePipeline* rhs) const { return true; }
 };
 
 

src/irr/asset/CGraphicsPipelineLoaderMTL.cpp

@@ -194,8 +194,13 @@ bool CGraphicsPipelineLoaderMTL::isALoadableFileFormat(io::IReadFile* _file) con
 }
 
 
-core::smart_refctd_ptr<ICPUPipelineLayout> CGraphicsPipelineLoaderMTL::makePipelineLayoutFromMtl(const SMtl& _mtl, bool _noDS3)
+core::smart_refctd_ptr<ICPUPipelineLayout> CGraphicsPipelineLoaderMTL::makePipelineLayoutFromMtl(SContext& _ctx, const SMtl& _mtl, bool _noDS3)
 {
+    const auto cacheKey = _ctx.layoutCacheKey(_mtl.clamp, _noDS3);
+
+    if (auto found = _ctx.layoutCache.find(cacheKey); found != _ctx.layoutCache.end())
+        return found->second;
+
     //assumes all supported textures are always present
     //since vulkan doesnt support bindings with no/null descriptor, absent textures will be filled with dummy 2D texture (while creating desc set)
     auto bindings = core::make_refctd_dynamic_array<core::smart_refctd_dynamic_array<ICPUDescriptorSetLayout::SBinding>>(static_cast<size_t>(CMTLPipelineMetadata::EMP_REFL_POSX)+1ull);
@@ -229,6 +234,8 @@ core::smart_refctd_ptr<ICPUPipelineLayout> CGraphicsPipelineLoaderMTL::makePipel
     //ds with textures for material goes to set=3
     auto layout = core::make_smart_refctd_ptr<ICPUPipelineLayout>(&pcRng, &pcRng+1, nullptr, std::move(ds1layout), nullptr, std::move(ds3Layout));
 
+    _ctx.layoutCache.insert({ cacheKey, layout });
+
     return layout;
 }
 
@@ -295,7 +302,7 @@ SAssetBundle CGraphicsPipelineLoaderMTL::loadAsset(io::IReadFile* _file, const I
         vtxParams.attributes[NORMAL].format = EF_A2B10G10R10_SNORM_PACK32;
         vtxParams.attributes[NORMAL].relativeOffset = 20u;
 
-        auto layout = makePipelineLayoutFromMtl(materials[i], true);
+        auto layout = makePipelineLayoutFromMtl(ctx, materials[i], true);
         auto shaders = getShaders(false);
 
         constexpr size_t DS1_METADATA_ENTRY_CNT = 3ull;
@@ -330,7 +337,7 @@ SAssetBundle CGraphicsPipelineLoaderMTL::loadAsset(io::IReadFile* _file, const I
         vtxParams.attributes[UV].format = EF_R32G32_SFLOAT;
         vtxParams.attributes[UV].relativeOffset = 12u;
 
-        layout = makePipelineLayoutFromMtl(materials[i], false);
+        layout = makePipelineLayoutFromMtl(ctx, materials[i], false);
         shaders = getShaders(true);
 
         core::smart_refctd_ptr<ICPUDescriptorSet> ds3;

src/irr/asset/CGraphicsPipelineLoaderMTL.h

@@ -30,6 +30,9 @@ namespace asset
             IAssetLoader::SAssetLoadContext inner;
             uint32_t topHierarchyLevel;
             IAssetLoader::IAssetLoaderOverride* loaderOverride;
+
+            static inline uint32_t layoutCacheKey(uint32_t clamps, bool no_ds3) { return clamps | (static_cast<uint32_t>(no_ds3) << 31); }
+            core::unordered_map<uint32_t, core::smart_refctd_ptr<ICPUPipelineLayout>> layoutCache;
         };
 
 	public:
@@ -50,7 +53,7 @@ namespace asset
 		asset::SAssetBundle loadAsset(io::IReadFile* _file, const asset::IAssetLoader::SAssetLoadParams& _params, asset::IAssetLoader::IAssetLoaderOverride* _override = nullptr, uint32_t _hierarchyLevel = 0u) override;
 
     private:
-        core::smart_refctd_ptr<ICPUPipelineLayout> makePipelineLayoutFromMtl(const SMtl& _mtl, bool _noDS3);
+        core::smart_refctd_ptr<ICPUPipelineLayout> makePipelineLayoutFromMtl(SContext& ctx, const SMtl& _mtl, bool _noDS3);
         core::vector<SMtl> readMaterials(io::IReadFile* _file) const;
         const char* readTexture(const char* _bufPtr, const char* const _bufEnd, SMtl* _currMaterial, const char* _mapType) const;