메모리풀 이야기~

프로그래밍을 할때 가장 많이 호출되는 함수중에 하나가 메모리 할당과 해제에 관련된 함수이다.
C개발자라면 메모리 할당과 해제를 직접 제어할수 있지만, C++ 개발자라면 알게 모르게 호출되어진다.

그러다 보니, 메모리의 효율성을 많이 따지게 되는데.. 나 또한 C++ 기반에서 프로그램을 많이 하게 된다.
그래서 자연스럽게 메모리 풀에 관심을 가지게 되고 사용을 한다.

아래에 소개하는 소스는 내가 사용하는 메모리 풀의 헤더파일로, STL과 같은 allocator를 대신해 사용할수
있도록 만들어져 있다. (STL을 사용할때 많은 도움이 된다. -- boost를 사용해도 좋을듯 하다.)

template 기반으로 되어 있으니 도움이 되지 않을까 생각해 올린다~

* pool.hpp

#ifndef __POOL_HPP
#  define __POOL_HPP

#include <windows.h>

#include "pool.h"
#include <cstddef>

# include <new>
# include <stdexcept>

#undef max
#include <limits>

namespace pool {
 template<typename T>
  class allocator {
  public:
   //    typedefs
   typedef T value_type;
   typedef value_type* pointer;
   typedef const value_type* const_pointer;
   typedef value_type& reference;
   typedef const value_type& const_reference;
   typedef std::size_t size_type;
   typedef std::ptrdiff_t difference_type;
 
  public:
   //    convert an allocator<T> to allocator<U>
   template<typename U>
    struct rebind { typedef allocator<U> other; };
 
  public:
   inline allocator() {}
   inline ~allocator() {}

   inline allocator( allocator const&) {}
   template<typename U>
    inline allocator( allocator<U> const&) {}
   
   //    address
   inline pointer address( reference r) { return &r; }
   inline const_pointer address( const_reference r) { return &r; }
   
   //    memory allocation
   inline pointer allocate( size_type cnt,
     typename std::allocator<void>::const_pointer p = 0) {
    struct POOL *pl;

    ((_S_indexOfTLS == TLS_OUT_OF_INDEXES) ? (_S_indexOfTLS = TlsAlloc()): 0);
    if ((pl = (struct POOL *)TlsGetValue( _S_indexOfTLS)))
     ;
    else {
     if (!(pl = pool_create( 0, NULL)))
      throw std::bad_alloc();
     else {
      if (TlsSetValue( _S_indexOfTLS, pl) < 0)
       throw std::runtime_error("TlsSetValue");
     }
    } return reinterpret_cast<pointer>( pool_resize( pl,
       const_cast<void *>(p), cnt * sizeof(T), 0));
   }

   inline void deallocate( pointer p, size_type l) {
    struct POOL *pl;
   
    if ((_S_indexOfTLS != TLS_OUT_OF_INDEXES) &&
      ((pl = (struct POOL *)TlsGetValue( _S_indexOfTLS))))
    {
     if (p) pool_put( pl, reinterpret_cast<void *>(p));
     else if (l < 0) // 해당 쓰레드에 할당된 메모리풀 제거
     {
      pool_destroy( pl);
      TlsSetValue( _S_indexOfTLS, NULL);
     }
    }
   }

   //    size
   inline size_type max_size() const {
    return std::numeric_limits<size_type>::max() / sizeof(T); }
   
   //    construction/destruction
   inline void construct( pointer p, const T& t) { new(p) T(t); }
   inline void destroy( pointer p) { p->~T(); }

  private:
   static DWORD _S_indexOfTLS;
  };  //    end of class allocator

 template<typename T> DWORD allocator<T>::_S_indexOfTLS = TLS_OUT_OF_INDEXES;

 template<typename T>
  inline bool operator == ( allocator<T> const &, allocator<T> const &) {
   return true; }
 template<typename T>
  inline bool operator != ( allocator<T> const &, allocator<T> const &) {
   return false; }

 static allocator<char> standard;

 // 쓰레드에 할당된 리소스를 반환 받는다.
 inline void destroy() { standard.deallocate( NULL, -1); }

 //
 //
 template<class _Allocator>
  class safer {
  public:
   void *operator new   (size_t l) { return (void *)_Allocator.allocate(l); }
   void  operator delete( void *p) { _Allocator.deallocate( (char *)p, 0); }

   void *operator new[]   (size_t l) { return operator new(l); }
   void  operator delete[]( void *p) { operator delete(p); }
  };

 // scoped<char> buffer(100);
 //
 template <typename Tp>
  class scoped {
  public:
   scoped( std::size_t l = 1)
   {
    if (!(_M_buffer = (Tp *)standard.allocate( _M_sizeof = l)))
     throw std::bad_alloc();
   }

   ~scoped() { standard.deallocate( _M_buffer, 0); }

   Tp *resize( std::size_t l)
   {
    Tp *buffer;

    if (!(buffer = (Tp *)standard.allocate( l, (char *)_M_buffer)))
     throw std::bad_alloc();
    else {
     _M_sizeof = l;
    } return (_M_buffer = buffer);
   }

   Tp *operator *() { return _M_buffer; }
   Tp *operator []( int offset)
   {
    if ((offset < 0) ||
      (offset >= _M_sizeof))
     throw std::out_of_range("operator []: out of range");

    return (_M_buffer + offset);
   }

   const int size() { return _M_sizeof; }
  protected:
   Tp *_M_buffer;
   std::size_t _M_sizeof;
  };
};
#endif

여기에서 사용된 메모리풀은 TLS(Thread Local Storage) 기반으로 만들어져 있다. 즉, 쓰레드별 독립된 메모리 공간을 관리한다는 의미이다.

- 사용상 주의 해야 할 것은, 메모리를 할당한 쓰레드에서 메모리를 해제해야 한다는 것이다.

이렇게 쓰레드별 독립적으로 처리하게 만든 이유는 단일 메모리 풀을 사용 할 경우 메모리 풀에 접근할때 마다 lock 처리가 발생되어 STL과 같은 함수 사용시에 효율성이 떨어진다는 점 때문에 이렇게 구성되었다.

물론, TLS를 무시하고 lock 처리를 한다면 모든 쓰레드에서 같이 사용할수 있지만 효율성은 그다지~

마지막으로 쓸만한 memory pool 엔진을 하나 소개 한다.

    http://www.25thandclement.com/~william/projects/libarena.html
는 libarena라는 Custom Memory Allocator Interface 로 상당히 뛰어난 엔진이다.

많은 도움을 받을수 있을듯 하다.. 위의 예에서 사용된 메모리 pool 또한 이 엔진을 커스터마이징해 사용하고 있으며, 일반적인 malloc()계열에 비해 뛰어난 성능을 보여주니 믿고 써도 후회하지 않을것이다~