Public API Reference

csutil/allocator.h

Go to the documentation of this file.

/*
    Copyright (C) 2006-2007 by Frank Richter

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_CSUTIL_ALLOCATOR_H__
#define __CS_CSUTIL_ALLOCATOR_H__

#include "csutil/alignedalloc.h"
#include "csutil/memdebug.h"
#include "csutil/ref.h"
#include "csutil/threading/mutex.h"
#include "iutil/allocator.h"

namespace CS
{
  namespace Memory
  {
    class AllocatorMalloc
    {
    #ifdef CS_MEMORY_TRACKER
      const char* mti;
    #endif
    public:
    #ifdef CS_MEMORY_TRACKER
      AllocatorMalloc() : mti (0) {}
    #endif
      CS_ATTRIBUTE_MALLOC void* Alloc (const size_t n)
      {
      #ifdef CS_MEMORY_TRACKER
        size_t* p = (size_t*)cs_malloc (n);
        if (mti) CS::Debug::MemTracker::RegisterAlloc (p, n, mti);
        return p;
      #else
        return cs_malloc (n);
      #endif
      }
      void Free (void* p)
      {
      #ifdef CS_MEMORY_TRACKER
        CS::Debug::MemTracker::RegisterFree (p);
      #endif
        cs_free (p);
      }
      void* Realloc (void* p, size_t newSize)
      {
      #ifdef CS_MEMORY_TRACKER
        if (p == 0) return Alloc (newSize);
        size_t* np = (size_t*)cs_realloc (p, newSize);
        CS::Debug::MemTracker::UpdateSize (p, np, newSize);
        return np;
      #else
        return cs_realloc (p, newSize);
      #endif
      }
      void SetMemTrackerInfo (const char* info)
      {
      #ifdef CS_MEMORY_TRACKER
        mti = info;
      #else
        (void)info;
      #endif
      }
    };

    template<typename T, size_t N, class ExcessAllocator = AllocatorMalloc,
      bool SingleAllocation = false>
    class LocalBufferAllocator : public ExcessAllocator
    {
    #ifdef CS_DEBUG
      void* startThis;
    #endif
      static const size_t localSize = N * sizeof (T);
      static const uint8 freePattern = 0xfa;
      static const uint8 newlyAllocatedSalt = 0xac;
      uint8 localBuf[localSize + (SingleAllocation ? 0 : 1)];
    public:
      LocalBufferAllocator ()
      {
        if (SingleAllocation) 
        {
      #ifdef CS_DEBUG
          memset (localBuf, freePattern, localSize);
      #endif
        }
        else
          localBuf[localSize] = 0;
      #ifdef CS_DEBUG
        startThis = this;
      #endif
      }
      LocalBufferAllocator (const ExcessAllocator& xalloc) : 
        ExcessAllocator (xalloc)
      {
        if (SingleAllocation) 
        {
      #ifdef CS_DEBUG
          memset (localBuf, freePattern, localSize);
      #endif
        }
        else
          localBuf[localSize] = 0;
      #ifdef CS_DEBUG
        startThis = this;
      #endif
      }
      void* Alloc (size_t allocSize)
      {
        CS_ASSERT(startThis == this);
        if (SingleAllocation)
        {
      #ifdef CS_DEBUG
          /* Verify that the local buffer consists entirely of the "local
             buffer unallocated" pattern. (Not 100% safe since a valid 
             allocated buffer may be coincidentally filled with just that
             pattern, but let's just assume that it's unlikely.) */
          bool validPattern = true;
          for (size_t n = 0; n < localSize; n++)
          {
            if (localBuf[n] != freePattern)
            {
              validPattern = false;
              break;
            }
          }
          CS_ASSERT_MSG("This LocalBufferAllocator only allows one allocation "
            "a time!", validPattern);
          memset (localBuf, newlyAllocatedSalt, localSize);
      #endif
          if (allocSize <= localSize)
            return (void*)localBuf;
          else
          {
            void* p = ExcessAllocator::Alloc (allocSize);
            return p;
          }
        }
        else
        {
          void* p;
          if ((allocSize <= localSize) && !localBuf[localSize])
          {
            localBuf[localSize] = 1;
            p = localBuf;
        #ifdef CS_DEBUG
            memset (p, newlyAllocatedSalt, allocSize);
        #endif
          }
          else
          {
            p = ExcessAllocator::Alloc (allocSize);
          }
          return (T*)p;
        }
      }
    
      void Free (void* mem)
      {
        CS_ASSERT(startThis == this);
        if (SingleAllocation)
        {
          if (mem != (void*)localBuf)
            ExcessAllocator::Free (mem);
          else
          {
      #ifdef CS_DEBUG
            /* Verify that the local buffer does entirely consist of the "local
               buffer unallocated" pattern. (Not 100% safe since a valid 
               allocated buffer may be coincidentally filled with just that
               pattern, but let's just assume that it's unlikely.) */
            bool validPattern = true;
            for (size_t n = 0; n < localSize; n++)
            {
              if (localBuf[n] != freePattern)
              {
                validPattern = false;
                break;
              }
            }
            CS_ASSERT_MSG("Free() without prior allocation", !validPattern);
      #endif
          }
      #ifdef CS_DEBUG
          memset (localBuf, freePattern, localSize);
      #endif
        }
        else
        {
          if (mem != (void*)localBuf) 
            ExcessAllocator::Free (mem);
          else
          {
            localBuf[localSize] = 0;
          }
        }
      }
    
      // The 'relevantcount' parameter should be the number of items
      // in the old array that are initialized.
      void* Realloc (void* p, size_t newSize)
      {
        CS_ASSERT(startThis == this);
        if (p == 0) return Alloc (newSize);
        if (p == localBuf)
        {
          if (newSize <= localSize)
            return p;
          else
          {
            p = ExcessAllocator::Alloc (newSize);
            memcpy (p, localBuf, localSize);
        #ifdef CS_DEBUG
            memset (localBuf, freePattern, localSize);
        #endif
            if (!SingleAllocation) localBuf[localSize] = 0;
            return p;
          }
        }
        else
        {
          if ((newSize <= localSize) && (SingleAllocation || !localBuf[localSize]))
          {
            memcpy (localBuf, p, newSize);
            ExcessAllocator::Free (p);
            if (!SingleAllocation) localBuf[localSize] = 1;
            return localBuf;
          }
          else
            return ExcessAllocator::Realloc (p, newSize);
        }
      }

      using ExcessAllocator::SetMemTrackerInfo;
    };
    
    template<typename T, size_t N, class ExcessAllocator = AllocatorMalloc,
      bool SingleAllocation = false>
    class LocalBufferAllocatorUnchecked : public ExcessAllocator
    {
      static const size_t localSize = N * sizeof (T);
      uint8 localBuf[localSize + (SingleAllocation ? 0 : 1)];
    public:
      LocalBufferAllocatorUnchecked ()
      {
        if (!SingleAllocation) 
          localBuf[localSize] = 0;
      }
      LocalBufferAllocatorUnchecked (const ExcessAllocator& xalloc) : 
        ExcessAllocator (xalloc)
      {
        if (!SingleAllocation) 
          localBuf[localSize] = 0;
      }
      T* Alloc (size_t allocSize)
      {
        if (SingleAllocation)
        {
          if (allocSize <= localSize)
            return (T*)localBuf;
          else
          {
            void* p = ExcessAllocator::Alloc (allocSize);
            return (T*)p;
          }
        }
        else
        {
          void* p;
          if ((allocSize <= localSize) && !localBuf[localSize])
          {
            localBuf[localSize] = 1;
            p = localBuf;
          }
          else
          {
            p = ExcessAllocator::Alloc (allocSize);
          }
          return (T*)p;
        }
      }
    
      void Free (T* mem)
      {
        if (SingleAllocation)
        {
          if (mem != (T*)localBuf)
            ExcessAllocator::Free (mem);
        }
        else
        {
          if (mem != (T*)localBuf) 
            ExcessAllocator::Free (mem);
          else
          {
            localBuf[localSize] = 0;
          }
        }
      }
    
      // The 'relevantcount' parameter should be the number of items
      // in the old array that are initialized.
      void* Realloc (void* p, size_t newSize)
      {
        if (p == 0) return Alloc (newSize);
        if (p == localBuf)
        {
          if (newSize <= localSize)
            return p;
          else
          {
            p = ExcessAllocator::Alloc (newSize);
            memcpy (p, localBuf, localSize);
            if (!SingleAllocation) localBuf[localSize] = 0;
            return p;
          }
        }
        else
        {
          if ((newSize <= localSize) && (SingleAllocation || !localBuf[localSize]))
          {
            memcpy (localBuf, p, newSize);
            ExcessAllocator::Free (p);
            if (!SingleAllocation) localBuf[localSize] = 1;
            return localBuf;
          }
          else
            return ExcessAllocator::Realloc (p, newSize);
        }
      }

      using ExcessAllocator::SetMemTrackerInfo;
    };
    
    template <size_t A = 1>
    class AllocatorAlign
    {
    public:
      static inline CS_ATTRIBUTE_MALLOC void* Alloc (size_t size) 
      {
        return AlignedMalloc (size, A);
      }

      static inline void Free (void* p)
      {
        AlignedFree (p);
      }

      void* Realloc (void* p, size_t newSize)
      {
        return AlignedRealloc (p, newSize, A);
      }

      void SetMemTrackerInfo (const char* info)
      {
        (void)info;
      }
    };

    template<bool Reallocatable = true>
    class AllocatorNewChar
    {
    #ifdef CS_MEMORY_TRACKER
      const char* mti;
    #endif
    public:
    #ifdef CS_MEMORY_TRACKER
      AllocatorNewChar() : mti (0) {}
    #endif
      CS_ATTRIBUTE_MALLOC void* Alloc (const size_t n)
      {
        if (!Reallocatable)
        {
          char* p = new char[n];
      #ifdef CS_MEMORY_TRACKER
          if (mti) CS::Debug::MemTracker::RegisterAlloc (p, n, mti);
      #endif
          return p;
        }
        size_t* p = (size_t*)new char[n + sizeof (size_t)];
        *p = n;
        p++;
      #ifdef CS_MEMORY_TRACKER
        if (mti) CS::Debug::MemTracker::RegisterAlloc (p, n, mti);
      #endif
        return p;
      }
      void Free (void* p)
      {
      #ifdef CS_MEMORY_TRACKER
        CS::Debug::MemTracker::RegisterFree (p);
      #endif
        if (!Reallocatable)
        {
          delete[] (char*)p;
          return;
        }
        size_t* x = (size_t*)p;
        x--;
        delete[] (char*)x;
      }
      void* Realloc (void* p, size_t newSize)
      {
        if (!Reallocatable) return 0;
          
        if (p == 0) return Alloc (newSize);
        size_t* x = (size_t*)p;
        x--;
        size_t oldSize = *x;
        size_t* np = (size_t*)Alloc (newSize);
        if (newSize < oldSize)
          memcpy (np, p, newSize);
        else
          memcpy (np, p, oldSize);
        Free (p);
      #ifdef CS_MEMORY_TRACKER
        if (mti) CS::Debug::MemTracker::UpdateSize (p, np, newSize);
      #endif
        return np;
      }
      void SetMemTrackerInfo (const char* info)
      {
      #ifdef CS_MEMORY_TRACKER
        if (!Reallocatable) return;
        mti = info;
      #else
        (void)info;
      #endif
      }
    };

    template<typename T>
    class AllocatorNew
    {
    public:
      CS_ATTRIBUTE_MALLOC void* Alloc (const size_t n)
      {
        return new T[((n + sizeof(T) - 1) / sizeof(T)) * sizeof(T)];
      }
      void Free (void* p)
      {
        delete[] (T*)p;
      }
      void* Realloc (void* p, size_t newSize)
      {
        CS_ASSERT_MSG("Realloc() called on AllocatorNew", false);
        return 0;
      }
      void SetMemTrackerInfo (const char* /*info*/)
      {
      }
    };

    
    template<typename T, typename Allocator>
    struct AllocatorPointerWrapper : public Allocator
    {
      T* p;

      AllocatorPointerWrapper () {}
      AllocatorPointerWrapper (const Allocator& alloc) : 
        Allocator (alloc) {}
      AllocatorPointerWrapper (T* p) : p (p) {}
      AllocatorPointerWrapper (const Allocator& alloc, T* p) : 
        Allocator (alloc), p (p) {}
    };

    class AllocatorMallocPlatform
    {
    public:
      CS_ATTRIBUTE_MALLOC void* Alloc (const size_t n)
      {
        return malloc (n);
      }
      void Free (void* p)
      {
        free (p);
      }
      void* Realloc (void* p, size_t newSize)
      {
        return realloc (p, newSize);
      }
      void SetMemTrackerInfo (const char* info)
      {
        (void)info;
      }
    };

    template<typename OtherAllocator>
    class AllocatorRef
    {
      OtherAllocator& alloc;
    public:
      AllocatorRef (OtherAllocator& referencedAlloc)
       : alloc (referencedAlloc) {}
    
      CS_ATTRIBUTE_MALLOC void* Alloc (const size_t n)
      { return alloc.Alloc (n); }
      void Free (void* p) { alloc.Free (p); }
      void* Realloc (void* p, size_t newSize)
      { return alloc.Realloc (p, newSize); }
      void SetMemTrackerInfo (const char* info)
      { alloc.SetMemTrackerInfo (info); }
    };

    template <class Allocator>
    class AllocatorSafe : protected Allocator
    {
    protected:
      typedef Allocator WrappedAllocatorType;
      typedef AllocatorSafe<Allocator> AllocatorSafeType;
      CS::Threading::RecursiveMutex mutex;

    public:
      AllocatorSafe () : Allocator ()
      {
      }

      template<typename A1>
      AllocatorSafe (const A1& a1) : Allocator (a1)
      {
      }

      template<typename A1, typename A2>
      AllocatorSafe (const A1& a1, const A2& a2) : Allocator (a1, a2)
      {
      }

      void Free (void* p)
      {
        CS::Threading::RecursiveMutexScopedLock lock(mutex);
        Allocator::Free(p);
      }

      CS_ATTRIBUTE_MALLOC void* Alloc (const size_t n)
      {
        CS::Threading::RecursiveMutexScopedLock lock(mutex);
        return Allocator::Alloc(n);
      }

      void* Realloc (void* p, size_t newSize)
      {
        CS::Threading::RecursiveMutexScopedLock lock(mutex);
        return Allocator::Realloc(p, newSize);
      }

      void SetMemTrackerInfo (const char* info)
      {
        CS::Threading::RecursiveMutexScopedLock lock(mutex);
        Allocator::SetMemTrackerInfo(info);
      }
    };

    class AllocatorInterface
    {
      csRef<iAllocator> alloc;
    public:
      AllocatorInterface (iAllocator* alloc)
       : alloc (alloc) {}

      CS_ATTRIBUTE_MALLOC void* Alloc (const size_t n)
      { return alloc->Alloc (n); }
      void Free (void* p) { alloc->Free (p); }
      void* Realloc (void* p, size_t newSize)
      { return alloc->Realloc (p, newSize); }
      void SetMemTrackerInfo (const char* info)
      { alloc->SetMemTrackerInfo (info); }
    };

  } // namespace Memory
} // namespace CS

#endif // __CS_CSUTIL_ALLOCATOR_H__

---