Changeset 13911 for ps

Timestamp:

09/29/13 16:48:11 (11 years ago)

Author:

philip

Message:

Reduce memory allocations in the renderer

Use an arena allocator in ShaderModelRenderer::Render, to reduce
the allocation cost in STL containers.

Avoid unnecessary copying of std::vectors.

Location:

ps/trunk/source

Files:

• graphics/ShaderDefines.cpp (modified) (2 diffs)
• graphics/ShaderDefines.h (modified) (1 diff)
• lib/allocators/allocator_adapters.h (modified) (1 diff)
• renderer/DecalRData.cpp (modified) (1 diff)
• renderer/ModelRenderer.cpp (modified) (11 diffs)
• renderer/PatchRData.cpp (modified) (2 diffs)

ps/trunk/source/graphics/ShaderDefines.cpp

@@ -106 +106 @@
 CShaderParams<value_t>::CShaderParams()
 {
+    *this = s_Empty;
+}
+
+template<typename value_t>
+CShaderParams<value_t>::CShaderParams(SItems* items) : m_Items(items)
+{
+}
+
+template<typename value_t>
+CShaderParams<value_t> CShaderParams<value_t>::CreateEmpty()
+{
     SItems items;
     items.RecalcHash();
-    m_Items = GetInterned(items);
+    return CShaderParams(GetInterned(items));
 }
 
@@ -268 +279 @@
 template<> CShaderParams<CVector4D>::InternedItems_t CShaderParams<CVector4D>::s_InternedItems = CShaderParams<CVector4D>::InternedItems_t();
 
+template<> CShaderParams<CStrIntern> CShaderParams<CStrIntern>::s_Empty = CShaderParams<CStrIntern>::CreateEmpty();
+template<> CShaderParams<CVector4D> CShaderParams<CVector4D>::s_Empty = CShaderParams<CVector4D>::CreateEmpty();
+
 template class CShaderParams<CStrIntern>;
 template class CShaderParams<CVector4D>;

ps/trunk/source/graphics/ShaderDefines.h

@@ -119 +119 @@
      */
     static SItems* GetInterned(const SItems& items);
+
+    CShaderParams(SItems* items);
+    static CShaderParams CreateEmpty();
+    static CShaderParams s_Empty;
 };
 

ps/trunk/source/lib/allocators/allocator_adapters.h

@@ -116 +116 @@
     };
 
+    // (required to be declared by boost::unordered_map, but should never be called)
+    explicit NOTHROW_DEFINE ProxyAllocator();
+
     explicit NOTHROW_DEFINE ProxyAllocator(Allocator& allocator)
         : allocator(&allocator)

ps/trunk/source/renderer/DecalRData.cpp

@@ -122 +122 @@
             if (material.GetSamplers().size() != 0)
             {
-                CMaterial::SamplersVector samplers = material.GetSamplers();
+                const CMaterial::SamplersVector& samplers = material.GetSamplers();
                 size_t samplersNum = samplers.size();
                 
                 for (size_t s = 0; s < samplersNum; ++s)
                 {
-                    CMaterial::TextureSampler &samp = samplers[s];
+                    const CMaterial::TextureSampler& samp = samplers[s];
                     shader->BindTexture(samp.Name, samp.Sampler);
                 }

ps/trunk/source/renderer/ModelRenderer.cpp

@@ -18 +18 @@
 #include "precompiled.h"
 
+#include "lib/allocators/allocator_adapters.h"
+#include "lib/allocators/arena.h"
 #include "lib/ogl.h"
 #include "maths/Vector3D.h"
@@ -418 +420 @@
      */
 
-    typedef boost::unordered_map<SMRMaterialBucketKey, std::vector<CModel*>, SMRMaterialBucketKeyHash> MaterialBuckets_t;
-    MaterialBuckets_t materialBuckets;
+    Allocators::Arena<> arena(1*MiB);
+    typedef ProxyAllocator<void*, Allocators::Arena<> > ArenaProxyAllocator;
+    typedef std::vector<CModel*, ArenaProxyAllocator> ModelList_t;
+    typedef boost::unordered_map<SMRMaterialBucketKey, ModelList_t, SMRMaterialBucketKeyHash,
+        std::equal_to<SMRMaterialBucketKey>, ProxyAllocator<void*, Allocators::Arena<> >
+    > MaterialBuckets_t;
+    MaterialBuckets_t materialBuckets((MaterialBuckets_t::allocator_type(arena)));
 
     {
@@ -433 +440 @@
             for (size_t j = 0; j < condefs.GetSize(); ++j)
             {
-                const CShaderConditionalDefines::CondDefine &item = condefs.GetItem(j);
+                const CShaderConditionalDefines::CondDefine& item = condefs.GetItem(j);
                 int type = item.m_CondType;
                 switch (type)
@@ -455 +462 @@
             CShaderDefines defs = model->GetMaterial().GetShaderDefines(condFlags);
             SMRMaterialBucketKey key(model->GetMaterial().GetShaderEffect(), defs);
-            std::vector<CModel*>& bucketItems = materialBuckets[key];
-            bucketItems.push_back(model);
-        }
-    }
-
-    std::vector<SMRSortByDistItem> sortByDistItems;
-
-    std::vector<CShaderTechniquePtr> sortByDistTechs;
+
+            MaterialBuckets_t::iterator it = materialBuckets.find(key);
+            if (it == materialBuckets.end())
+            {
+                std::pair<MaterialBuckets_t::iterator, bool> inserted = materialBuckets.insert(
+                    std::make_pair(key, ModelList_t(ModelList_t::allocator_type(arena))));
+                inserted.first->second.reserve(32);
+                inserted.first->second.push_back(model);
+            }
+            else
+            {
+                it->second.push_back(model);
+            }
+        }
+    }
+
+    std::vector<SMRSortByDistItem, ArenaProxyAllocator> sortByDistItems((ArenaProxyAllocator(arena)));
+
+    std::vector<CShaderTechniquePtr, ArenaProxyAllocator> sortByDistTechs((ArenaProxyAllocator(arena)));
         // indexed by sortByDistItems[i].techIdx
         // (which stores indexes instead of CShaderTechniquePtr directly
@@ -469 +487 @@
         // will keep it alive long enough)
 
-    std::vector<SMRTechBucket> techBuckets;
+    std::vector<SMRTechBucket, ArenaProxyAllocator> techBuckets((ArenaProxyAllocator(arena)));
 
     {
@@ -529 +547 @@
     // we could avoid the cost of copying into this list by adding
     // a stride length into techBuckets and not requiring contiguous CModel*s)
-    std::vector<CModel*> sortByDistModels;
+    std::vector<CModel*, ArenaProxyAllocator> sortByDistModels((ArenaProxyAllocator(arena)));
 
     if (!sortByDistItems.empty())
@@ -578 +596 @@
         // loops to avoid excessive reallocations. The token allocation of 64 elements 
         // should be plenty, though it is reallocated below (at a cost) if necessary.
-        std::vector<CTexture*> currentTexs;
+        std::vector<CTexture*, ArenaProxyAllocator> currentTexs((ArenaProxyAllocator(arena)));
         currentTexs.reserve(64);
         
@@ -584 +602 @@
         // statically in the ShaderRenderModifier class. texBindingNames uses interned strings to
         // keep track of when bindings need to be reevaluated.
-        std::vector<CShaderProgram::Binding> texBindings;
+        std::vector<CShaderProgram::Binding, ArenaProxyAllocator> texBindings((ArenaProxyAllocator(arena)));
         texBindings.reserve(64);
-        std::vector<CStrIntern> texBindingNames;
+        std::vector<CStrIntern, ArenaProxyAllocator> texBindingNames((ArenaProxyAllocator(arena)));
         texBindingNames.reserve(64);
 
@@ -634 +652 @@
                             continue;
 
-                        CMaterial::SamplersVector samplers = model->GetMaterial().GetSamplers();
+                        const CMaterial::SamplersVector& samplers = model->GetMaterial().GetSamplers();
                         size_t samplersNum = samplers.size();
                         
@@ -654 +672 @@
                         for (size_t s = 0; s < samplersNum; ++s)
                         {
-                            CMaterial::TextureSampler &samp = samplers[s];
+                            const CMaterial::TextureSampler& samp = samplers[s];
                             
                             CShaderProgram::Binding bind = texBindings[s];
@@ -695 +713 @@
                         }
                         
-                        CShaderRenderQueries renderQueries = model->GetMaterial().GetRenderQueries();
+                        const CShaderRenderQueries& renderQueries = model->GetMaterial().GetRenderQueries();
                         
                         for (size_t q = 0; q < renderQueries.GetSize(); q++)

ps/trunk/source/renderer/PatchRData.cpp

@@ -788 +788 @@
             if (itt->first->GetMaterial().GetSamplers().size() != 0)
             {
-                CMaterial::SamplersVector samplers = itt->first->GetMaterial().GetSamplers();
+                const CMaterial::SamplersVector& samplers = itt->first->GetMaterial().GetSamplers();
                 size_t samplersNum = samplers.size();
                 
                 for (size_t s = 0; s < samplersNum; ++s)
                 {
-                    CMaterial::TextureSampler &samp = samplers[s];
+                    const CMaterial::TextureSampler& samp = samplers[s];
                     shader->BindTexture(samp.Name, samp.Sampler);
                 }
@@ -1018 +1018 @@
             if (itt->m_Texture)
             {
-                CMaterial::SamplersVector samplers = itt->m_Texture->GetMaterial().GetSamplers();
+                const CMaterial::SamplersVector& samplers = itt->m_Texture->GetMaterial().GetSamplers();
                 size_t samplersNum = samplers.size();
                 
                 for (size_t s = 0; s < samplersNum; ++s)
                 {
-                    CMaterial::TextureSampler &samp = samplers[s];
+                    const CMaterial::TextureSampler& samp = samplers[s];
                     shader->BindTexture(samp.Name, samp.Sampler);
                 }