Ticket #2142: dynamic-arena.patch

source/lib/allocators/arena.h

@@ -1 @@
-/* Copyright (c) 2010 Wildfire Games
+/* Copyright (c) 2013 Wildfire Games
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -83 +83 @@
 
 LIB_API void TestArena();
 
+
+/**
+ * allocator design parameters:
+ * - grow dynamically with a fixed chunkSize
+ * - for frequent allocations of size << chunkSize
+ * - no reallocations, pointers remain valid
+ **/
+class DynamicArena
+{
+    class ArenaChunk
+    {
+        NONCOPYABLE(ArenaChunk);
+    public:
+        ArenaChunk(size_t size)
+            : capacity(size), end(0), storage(malloc(size))
+        {
+        }
+
+        ~ArenaChunk()
+        {
+            free(storage);
+        }
+
+        bool Available(size_t size)
+        {
+            return size <= (capacity - end);
+        }
+
+        uintptr_t Allocate(size_t size)
+        {
+            if (!Available(size))
+                return 0;
+            uintptr_t ptr = uintptr_t(storage) + end;
+            end += size;
+            return ptr;
+        }
+
+        void* storage;
+        size_t end;
+        const size_t capacity;
+    };
+
+    NONCOPYABLE(DynamicArena);
+public:
+    DynamicArena(size_t chunkSize) : chunkSize(chunkSize)
+    {
+        chunkList.push_back(new ArenaChunk(chunkSize));
+    }
+
+    ~DynamicArena()
+    {
+        std::list<ArenaChunk*>::iterator it;
+        for (it = chunkList.begin(); it != chunkList.end(); ++it)
+            delete *it;
+    }
+
+    void* allocate(size_t size)
+    {
+        if (!chunkList.back()->Available(size))
+        {
+            if (size > chunkSize)
+            {
+                debug_warn(L"DynamicArena cannot allocate more than chunk size");
+                throw std::bad_alloc();
+            }
+            chunkList.push_back(new ArenaChunk(chunkSize));
+        }
+
+        return (void*)chunkList.back()->Allocate(size);
+    }
+
+    void deallocate(void* UNUSED(p), size_t UNUSED(size))
+    {
+        // ignored
+    }
+
+private:
+
+    const size_t chunkSize;
+    std::list<ArenaChunk*> chunkList;
+};
+
+
 }   // namespace Allocators
 
 #endif  // #ifndef INCLUDED_ALLOCATORS_ARENA

source/simulation2/serialization/BinarySerializer.cpp

@@ -57 +57 @@
 
 CBinarySerializerScriptImpl::CBinarySerializerScriptImpl(ScriptInterface& scriptInterface, ISerializer& serializer) :
     m_ScriptInterface(scriptInterface), m_Serializer(serializer), m_Rooter(m_ScriptInterface),
-    m_ScriptBackrefsArena(16*MiB), m_ScriptBackrefs(backrefs_t::key_compare(), ScriptBackrefsAlloc(m_ScriptBackrefsArena)), m_ScriptBackrefsNext(1)
+    m_ScriptBackrefsArena(1 * MiB), m_ScriptBackrefs(backrefs_t::key_compare(), ScriptBackrefsAlloc(m_ScriptBackrefsArena)), m_ScriptBackrefsNext(1)
 {
 }
 

source/simulation2/serialization/BinarySerializer.h

@@ -65 +65 @@
     ISerializer& m_Serializer;
 
     // Pooling helps since we do a lot of short-lived allocations
-    typedef ProxyAllocator<std::pair<JSObject* const, u32>, Allocators::Arena<> > ScriptBackrefsAlloc;
+    typedef ProxyAllocator<std::pair<JSObject* const, u32>, Allocators::DynamicArena > ScriptBackrefsAlloc;
     typedef std::map<JSObject*, u32, std::less<JSObject*>, ScriptBackrefsAlloc> backrefs_t;
 
-    Allocators::Arena<> m_ScriptBackrefsArena;
+    Allocators::DynamicArena m_ScriptBackrefsArena;
     backrefs_t m_ScriptBackrefs;
     u32 m_ScriptBackrefsNext;
     u32 GetScriptBackrefTag(JSObject* obj);