Changeset 7264 for code/branches/consolecommands3/src/libraries

Timestamp:

Aug 29, 2010, 9:37:38 PM (14 years ago)

Author:

landauf

Message:

Added new utility SmallObjectAllocator.
Merged counter and destroyer in SharedPtr and allocate them with SmallObjectAllocator

Location:

code/branches/consolecommands3/src/libraries/util

Files:

• CMakeLists.txt (modified) (1 diff)
• SharedPtr.cc (added)
• SharedPtr.h (modified) (6 diffs)
• SmallObjectAllocator.cc (added)
• SmallObjectAllocator.h (added)

code/branches/consolecommands3/src/libraries/util/CMakeLists.txt

@@ -32 +32 @@
   OutputHandler.cc
   ScopedSingletonManager.cc
+  SharedPtr.cc
   SignalHandler.cc
   Sleep.cc
+  SmallObjectAllocator.cc
   SubString.cc
 COMPILATION_END

code/branches/consolecommands3/src/libraries/util/SharedPtr.h

@@ -31 +31 @@
 
 #include "UtilPrereqs.h"
+
 #include <algorithm>
 #include <cassert>
 
+#include "SmallObjectAllocator.h"
+
 namespace orxonox
 {
-    class SharedPtrDestroyer
+    class SharedCounter
     {
         public:
+            SharedCounter() : count_(1) {}
             virtual void destroy() = 0;
+
+            int count_;
     };
 
     template <class T>
-    class SharedPtrDestroyerImpl : public SharedPtrDestroyer
+    class SharedCounterImpl : public SharedCounter
     {
         public:
-            SharedPtrDestroyerImpl(T* pointer) : pointer_(pointer) {}
+            SharedCounterImpl(T* pointer) : pointer_(pointer) {}
 
             void destroy()
@@ -57 +63 @@
     };
 
+    _UtilExport SmallObjectAllocator& createSharedCounterPool();
+
+    FORCEINLINE SmallObjectAllocator& getSharedCounterPool()
+    {
+        static SmallObjectAllocator& instance = createSharedCounterPool();
+        return instance;
+    }
+
     template <class T>
     class SharedPtr
@@ -64 +78 @@
 
         public:
-            inline SharedPtr() : pointer_(0), counter_(0), destroyer_(0)
+            inline SharedPtr() : pointer_(0), counter_(0)
             {
             }
 
-            inline SharedPtr(T* pointer) : pointer_(pointer), counter_(0), destroyer_(0)
+            inline SharedPtr(T* pointer) : pointer_(pointer), counter_(0)
             {
                 if (this->pointer_)
                 {
-                    this->counter_ = new int(1);
-                    this->destroyer_ = new SharedPtrDestroyerImpl<T>(this->pointer_);
+                    void* chunk = getSharedCounterPool().alloc();
+                    this->counter_ = new (chunk) SharedCounterImpl<T>(this->pointer_);
                 }
             }
 
-            inline SharedPtr(const SharedPtr& other) : pointer_(other.pointer_), counter_(other.counter_), destroyer_(other.destroyer_)
+            inline SharedPtr(const SharedPtr& other) : pointer_(other.pointer_), counter_(other.counter_)
             {
                 if (this->pointer_)
-                    ++(*this->counter_);
+                    ++this->counter_->count_;
             }
 
             template <class O>
-            inline SharedPtr(const SharedPtr<O>& other) : pointer_(other.pointer_), counter_(other.counter_), destroyer_(other.destroyer_)
+            inline SharedPtr(const SharedPtr<O>& other) : pointer_(other.pointer_), counter_(other.counter_)
             {
                 if (this->pointer_)
-                    ++(*this->counter_);
+                    ++this->counter_->count_;
             }
 
@@ -94 +108 @@
                 if (this->pointer_)
                 {
-                    --(*this->counter_);
+                    --this->counter_->count_;
 
-                    if (*this->counter_ == 0)
+                    if (this->counter_->count_ == 0)
                     {
-                        this->destroyer_->destroy();
-                        delete this->destroyer_;
-                        delete this->counter_;
+                        this->counter_->destroy();
+                        getSharedCounterPool().free(this->counter_);
                     }
                 }
@@ -122 +135 @@
             {
                 O* temp = static_cast<O*>(this->pointer_); // temp value for prettier compiler error in case of an invalid static_cast
-                return SharedPtr<O>(temp, this->counter_, this->destroyer_);
+                return SharedPtr<O>(temp, this->counter_);
             }
 
@@ -151 +164 @@
                 std::swap(this->pointer_, other.pointer_);
                 std::swap(this->counter_, other.counter_);
-                std::swap(this->destroyer_, other.destroyer_);
             }
 
         private:
-            inline SharedPtr(T* pointer, int* counter, SharedPtrDestroyer* destroyer) : pointer_(pointer), counter_(counter), destroyer_(destroyer)
+            inline SharedPtr(T* pointer, SharedCounter* counter) : pointer_(pointer), counter_(counter)
             {
                 if (this->pointer_)
-                    ++(*this->counter_);
+                    ++this->counter_->count_;
             }
 
             T* pointer_;
-            int* counter_;
-            SharedPtrDestroyer* destroyer_;
+            SharedCounter* counter_;
     };