GLTFResourceManager: shard texture allocations to reduce contention

Author: TheMostDiligent

AssetLoader/interface/GLTFResourceManager.hpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2025 Diligent Graphics LLC
+ *  Copyright 2019-2026 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -146,6 +146,11 @@ class ResourceManager final : public ObjectBase<IObject>
         /// The number of elements in pTexAtlasCIs array.
         Uint32 NumTexAtlases = 0;
 
+        /// The number of shards in texture allocation map.
+        /// Shards are used to reduce contention when allocating texture space and finding texture allocations by cache ID
+        /// from multiple threads simultaneously. The more shards, the less contention, but the more memory is used by the map.
+        Uint32 NumTextureAllocationShards = 1;
+
         /// Default texture atlas description that is used to create texture
         /// atlas not explicitly specified in pTexAtlasCIs.
         /// If DefaultAtlasDesc.Desc.Type is Diligent::RESOURCE_DIM_UNDEFINED,
@@ -490,9 +495,22 @@ class ResourceManager final : public ObjectBase<IObject>
     std::vector<IVertexPool*>          m_VertexPoolSnapshot;
     std::vector<IBufferSuballocator*>  m_IndexAllocatorSnapshot;
 
-    using TexAllocationsHashMapType = std::unordered_map<std::string, RefCntWeakPtr<ITextureAtlasSuballocation>>;
-    std::shared_mutex         m_TexAllocationsMtx;
-    TexAllocationsHashMapType m_TexAllocations;
+    class TexAllocations
+    {
+    public:
+        RefCntAutoPtr<ITextureAtlasSuballocation> Find(const char* CacheId);
+
+        void Add(const char* CacheId, RefCntAutoPtr<ITextureAtlasSuballocation> pSuballocation);
+
+        static size_t GetShardIndex(const char* CacheId, size_t ShardCount);
+
+    private:
+        using TexAllocationsHashMapType = std::unordered_map<std::string, RefCntWeakPtr<ITextureAtlasSuballocation>>;
+
+        std::shared_mutex         m_Mtx;
+        TexAllocationsHashMapType m_Map;
+    };
+    std::vector<TexAllocations> m_TexAllocations;
 
     std::vector<StateTransitionDesc> m_Barriers;
 };

AssetLoader/src/GLTFResourceManager.cpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2025 Diligent Graphics LLC
+ *  Copyright 2019-2026 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -62,7 +62,8 @@ ResourceManager::ResourceManager(IReferenceCounters* pRefCounters,
     m_DefaultVertPoolDesc{CI.DefaultPoolDesc},
     m_DefaultAtlasName{CI.DefaultAtlasDesc.Desc.Name != nullptr ? CI.DefaultAtlasDesc.Desc.Name : "GLTF texture atlas"},
     m_DefaultAtlasDesc{CI.DefaultAtlasDesc},
-    m_IndexAllocatorCI{CI.IndexAllocatorCI}
+    m_IndexAllocatorCI{CI.IndexAllocatorCI},
+    m_TexAllocations{CI.NumTextureAllocationShards != 0 ? CI.NumTextureAllocationShards : 1}
 {
     m_DefaultVertPoolDesc.Name   = m_DefaultVertPoolName.c_str();
     m_DefaultAtlasDesc.Desc.Name = m_DefaultAtlasName.c_str();
@@ -122,45 +123,75 @@ ResourceManager::ResourceManager(IReferenceCounters* pRefCounters,
 }
 
 
-RefCntAutoPtr<ITextureAtlasSuballocation> ResourceManager::FindTextureAllocation(const char* CacheId)
+RefCntAutoPtr<ITextureAtlasSuballocation> ResourceManager::TexAllocations::Find(const char* CacheId)
 {
-    if (CacheId != nullptr && *CacheId != 0)
+    if (CacheId == nullptr || *CacheId == 0)
+        return {};
+
+    bool AllocationExpired = false;
+
+    // First, try to find the allocation with a shared lock
     {
-        bool AllocationExpired = false;
+        std::shared_lock<std::shared_mutex> SharedLock{m_Mtx};
 
-        // First, try to find the allocation with a shared lock
+        auto it = m_Map.find(CacheId);
+        if (it != m_Map.end())
         {
-            std::shared_lock<std::shared_mutex> SharedLock{m_TexAllocationsMtx};
-
-            auto it = m_TexAllocations.find(CacheId);
-            if (it != m_TexAllocations.end())
-            {
-                if (RefCntAutoPtr<ITextureAtlasSuballocation> pAllocation = it->second.Lock())
-                    return pAllocation;
-                else
-                    AllocationExpired = true;
-            }
+            if (RefCntAutoPtr<ITextureAtlasSuballocation> pAllocation = it->second.Lock())
+                return pAllocation;
+            else
+                AllocationExpired = true;
         }
+    }
 
-        // If the allocation was found but has expired, acquire a unique lock to erase it
-        if (AllocationExpired)
-        {
-            std::unique_lock<std::shared_mutex> UniqueLock{m_TexAllocationsMtx};
+    // If the allocation was found but has expired, acquire a unique lock to erase it
+    if (AllocationExpired)
+    {
+        std::unique_lock<std::shared_mutex> UniqueLock{m_Mtx};
 
-            auto it = m_TexAllocations.find(CacheId);
-            if (it != m_TexAllocations.end())
-            {
-                if (RefCntAutoPtr<ITextureAtlasSuballocation> pAllocation = it->second.Lock())
-                    return pAllocation;
-                else
-                    m_TexAllocations.erase(it);
-            }
+        auto it = m_Map.find(CacheId);
+        if (it != m_Map.end())
+        {
+            if (RefCntAutoPtr<ITextureAtlasSuballocation> pAllocation = it->second.Lock())
+                return pAllocation;
+            else
+                m_Map.erase(it);
         }
     }
 
     return {};
 }
 
+void ResourceManager::TexAllocations::Add(const char* CacheId, RefCntAutoPtr<ITextureAtlasSuballocation> pSuballocation)
+{
+    if (CacheId == nullptr || *CacheId == 0)
+        return;
+
+    std::unique_lock<std::shared_mutex> UniqueLock{m_Mtx};
+    // Note that the same allocation may potentially be created by more
+    // than one thread if it has not been found in the cache originally
+    auto [it, inserted] = m_Map.emplace(CacheId, pSuballocation);
+    if (!inserted)
+    {
+        if (auto pExistingAllocation = it->second.Lock())
+            pSuballocation = pExistingAllocation;
+        else
+            it->second = pSuballocation;
+    }
+}
+
+size_t ResourceManager::TexAllocations::GetShardIndex(const char* CacheId, size_t ShardCount)
+{
+    if (CacheId == nullptr || *CacheId == 0)
+        return 0;
+    return ShardCount > 1 ? CStringHash<Char>{}(CacheId) % ShardCount : 0;
+}
+
+RefCntAutoPtr<ITextureAtlasSuballocation> ResourceManager::FindTextureAllocation(const char* CacheId)
+{
+    return m_TexAllocations[TexAllocations::GetShardIndex(CacheId, m_TexAllocations.size())].Find(CacheId);
+}
+
 RefCntAutoPtr<ITextureAtlasSuballocation> ResourceManager::AllocateTextureSpace(
     TEXTURE_FORMAT Fmt,
     Uint32         Width,
@@ -232,20 +263,7 @@ RefCntAutoPtr<ITextureAtlasSuballocation> ResourceManager::AllocateTextureSpace(
         pAllocation->SetUserData(pUserData);
     }
 
-    if (CacheId != nullptr && *CacheId != 0)
-    {
-        std::unique_lock<std::shared_mutex> UniqueLock{m_TexAllocationsMtx};
-        // Note that the same allocation may potentially be created by more
-        // than one thread if it has not been found in the cache originally
-        auto [it, inserted] = m_TexAllocations.emplace(CacheId, pAllocation);
-        if (!inserted)
-        {
-            if (auto pExistingAllocation = it->second.Lock())
-                pAllocation = pExistingAllocation;
-            else
-                it->second = pAllocation;
-        }
-    }
+    m_TexAllocations[TexAllocations::GetShardIndex(CacheId, m_TexAllocations.size())].Add(CacheId, pAllocation);
 
     return pAllocation;
 }