337 lines
8.6 KiB
C++
337 lines
8.6 KiB
C++
#pragma once
|
|
|
|
#include <boost/pool/pool.hpp>
|
|
#include "SunSTL.UtiltiyTMP.h"
|
|
|
|
|
|
// 고정형 크기 메모리 풀 사용
|
|
//#ifndef _DEBUG
|
|
#define USE_FIXED_SIZE_MEMORY_POOL
|
|
//#endif
|
|
|
|
|
|
namespace memory {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// 고정형 크기 메모리 풀
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
class NoParent
|
|
{
|
|
};
|
|
|
|
// 다형성 지원 버전
|
|
template <typename OBJECT_T, typename PARENT_T = NoParent>
|
|
class FixedSizeMemoryPool
|
|
{
|
|
public:
|
|
FixedSizeMemoryPool() :
|
|
impl_(sizeof(OBJECT_T))
|
|
{
|
|
}
|
|
~FixedSizeMemoryPool()
|
|
{
|
|
}
|
|
|
|
public:
|
|
void ReleaseAll()
|
|
{
|
|
impl_.release_memory();
|
|
}
|
|
|
|
void* Malloc()
|
|
{
|
|
return impl_.malloc();
|
|
}
|
|
void Free(void* const ptr)
|
|
{
|
|
impl_.free(ptr);
|
|
}
|
|
|
|
OBJECT_T* New()
|
|
{
|
|
OBJECT_T* alloc = (OBJECT_T*)impl_.malloc();
|
|
if (alloc != NULL)
|
|
{
|
|
new(alloc) OBJECT_T();
|
|
}
|
|
return alloc;
|
|
}
|
|
void Delete(OBJECT_T* const ptr)
|
|
{
|
|
if (ptr != NULL)
|
|
{
|
|
ptr->~OBJECT_T();
|
|
impl_.free(ptr);
|
|
}
|
|
}
|
|
void DeleteByParent(PARENT_T* const parent_ptr)
|
|
{
|
|
OBJECT_T* const ptr = dynamic_cast<OBJECT_T*>(parent_ptr);
|
|
if (ptr == NULL)
|
|
{
|
|
return;
|
|
}
|
|
ptr->~OBJECT_T();
|
|
impl_.free(ptr);
|
|
}
|
|
|
|
private:
|
|
typedef boost::pool<> PoolImpl;
|
|
PoolImpl impl_;
|
|
|
|
}; // FixedSizeMemoryPool
|
|
|
|
// 다형성 지원하지 않는 버전
|
|
template <typename OBJECT_T>
|
|
class FixedSizeMemoryPool<OBJECT_T, NoParent>
|
|
{
|
|
public:
|
|
FixedSizeMemoryPool() :
|
|
impl_(sizeof(OBJECT_T))
|
|
{
|
|
}
|
|
~FixedSizeMemoryPool()
|
|
{
|
|
}
|
|
|
|
public:
|
|
void ReleaseAll()
|
|
{
|
|
impl_.release_memory();
|
|
}
|
|
|
|
void* Malloc()
|
|
{
|
|
return impl_.malloc();
|
|
}
|
|
void Free(void* const ptr)
|
|
{
|
|
impl_.free(ptr);
|
|
}
|
|
|
|
OBJECT_T* New()
|
|
{
|
|
OBJECT_T* alloc = (OBJECT_T*)impl_.malloc();
|
|
if (alloc != NULL)
|
|
{
|
|
new(alloc) OBJECT_T();
|
|
}
|
|
return alloc;
|
|
}
|
|
void Delete(OBJECT_T* const ptr)
|
|
{
|
|
if (ptr != NULL)
|
|
{
|
|
ptr->~OBJECT_T();
|
|
impl_.free(ptr);
|
|
}
|
|
}
|
|
|
|
private:
|
|
typedef boost::pool<> PoolImpl;
|
|
PoolImpl impl_;
|
|
|
|
}; // FixedSizeMemoryPool
|
|
|
|
} // memory
|
|
|
|
|
|
//==================================================================================================
|
|
extern void _SetSharedMemoryLeakDetect(void (*userhook)(DWORD));
|
|
extern BOOL TraceShareMemoryLeak(const char* const path_file_name);
|
|
extern void TestUnit_UsedLogOutput();
|
|
//==================================================================================================
|
|
// <SharedMemoryPool>
|
|
// <Usage>
|
|
// Init - EntryPoint 재설정 후 첫번째 라인에 SharedMemoryPool::CreateInstance()를 호출해 주면 끝
|
|
// <HISTORY>
|
|
// 07/09/07 - CheckIn (Waverix)
|
|
// 11/07/05 - upgrade to v0250
|
|
class SharedMemoryPool
|
|
{
|
|
public:
|
|
static const ulong kVersion = 0x0250;
|
|
//
|
|
static void* MemoryAllocate(size_t sz, const char* name, const int line_no);
|
|
static void MemoryDeAllocate(void* ptr);
|
|
static void* RedirectNew_MemoryAllocate(size_t size,
|
|
const char* name, const int line_no, SharedMemoryPool*);
|
|
static void RedirectNew_MemoryDeallocate(void* ptr);
|
|
// NOTE: f110708.5L, added the token validation routine
|
|
static bool CheckValidAllocatedMemory(void* ptr);
|
|
|
|
static bool CreateInstance();
|
|
static void DestroyInstance();
|
|
static bool CheckInstanced();
|
|
private:
|
|
static const DWORD kInstancedTag = 0x3A000D12;
|
|
//
|
|
SharedMemoryPool();
|
|
~SharedMemoryPool();
|
|
static SharedMemoryPool* Instance();
|
|
//
|
|
const DWORD instanced_tag_;
|
|
void* inter_block_;
|
|
//
|
|
static int referenced_counter_s;
|
|
friend class SharedMemoryRouter;
|
|
friend BOOL TraceShareMemoryLeak(const char* const path_file_name);
|
|
friend void TestUnit_UsedLogOutput();
|
|
__DISABLE_COPY(SharedMemoryPool);
|
|
};
|
|
|
|
#define DOWNCASTER_SELECT ::util::downcaster_select
|
|
//#ifdef _DEBUG
|
|
// #define DOWNCASTER_SELECT dynamic_cast
|
|
//#else
|
|
// #define DOWNCASTER_SELECT static_cast
|
|
//#endif
|
|
|
|
template< typename _TYPE >
|
|
struct sun_type_info
|
|
{
|
|
typedef _TYPE value_type;
|
|
typedef value_type* pointer;
|
|
typedef value_type* const pointer_r;
|
|
typedef const value_type* const_pointer;
|
|
typedef value_type& reference;
|
|
};
|
|
|
|
//==================================================================================================
|
|
|
|
#if SUN_CODE_BACKUP
|
|
//==================================================================================================
|
|
// CHANGES: f110318.3L, reserved deletion
|
|
|
|
template< typename _TYPE >
|
|
struct TAllocator : sun_type_info< _TYPE >
|
|
{
|
|
typedef TAllocator<value_type> allocator_type;
|
|
static pointer Allocate()
|
|
{
|
|
#if defined(_SERVER)
|
|
return SharedMemoryPool::InstanceOf<value_type>();
|
|
#else
|
|
return new value_type();
|
|
#endif
|
|
}
|
|
|
|
template< typename _DTYPE >
|
|
static void DeAllocate( _DTYPE* ptr )
|
|
{
|
|
// compile-time check routine
|
|
static_cast<_DTYPE*>( reinterpret_cast<value_type*>(1) );
|
|
|
|
#if defined(_SERVER)
|
|
SharedMemoryPool::DeleteOf< _DTYPE >( ptr ) ;
|
|
#else
|
|
delete ptr;
|
|
#endif
|
|
}
|
|
|
|
static void DeAllocate( pointer ptr )
|
|
{
|
|
#if defined(_SERVER)
|
|
SharedMemoryPool::DeleteOf<value_type>( ptr );
|
|
#else
|
|
delete ptr;
|
|
#endif
|
|
}
|
|
};
|
|
#endif // SUN_CODE_BACKUP
|
|
|
|
//==================================================================================================
|
|
|
|
#define USING_SUN_SHARED_POOL (1)
|
|
#if !defined(_MOLA_LIB)
|
|
#define USING_SUN_SHARED_POOL_EXCEPT_MALLOC
|
|
#endif
|
|
|
|
#if defined(_SERVER) || !defined(_SUNGAME_VER)
|
|
#define USING_SUN_SHARED_POOL_REPORT (1)
|
|
#else
|
|
#define USING_SUN_SHARED_POOL_REPORT (0)
|
|
#endif
|
|
|
|
//==================================================================================================
|
|
|
|
// CHANGES: f110318.3L, interfaces (like a TAllocNew, TAllocDelete) showing the below codes is made
|
|
// to replace 'TAllocator<T>' interface that is manipulated by using shared memory pool.
|
|
// because 'Apply Code Changes' function of the visual studio
|
|
// can't interpret template because of ambigous.
|
|
#if USING_SUN_SHARED_POOL
|
|
|
|
#ifdef USING_SUN_SHARED_POOL_EXCEPT_MALLOC
|
|
|
|
#define TAllocMalloc(_size_) \
|
|
::malloc(_size_)
|
|
|
|
#define TAllocFree(_ptr_) { \
|
|
::free(_ptr_); \
|
|
}
|
|
|
|
#else
|
|
#if USING_SUN_SHARED_POOL_REPORT
|
|
#define TAllocMalloc(_size_) \
|
|
SharedMemoryPool::MemoryAllocate(_size_, __FUNCTION__, __LINE__)
|
|
#else
|
|
#define TAllocMalloc(_size_) \
|
|
SharedMemoryPool::MemoryAllocate(_size_, NULL, 0)
|
|
#endif
|
|
#define TAllocFree(_ptr_) { \
|
|
SharedMemoryPool::MemoryDeAllocate(_ptr_); \
|
|
}
|
|
#endif //USING_SUN_SHARED_POOL_ONLY_TALLOCNEW
|
|
|
|
//#ifdef USE_FIXED_SIZE_MEMORY_POOL
|
|
//
|
|
// #define TAllocNew(OBJECT_T_) \
|
|
// new (FixedSizeMemoryPool<##OBJECT_T_>::Instance().Malloc())##OBJECT_T_
|
|
//
|
|
// #define TAllocDelete(OBJECT_T_, INSTANCE_) { \
|
|
// typedef sun_type_info<##OBJECT_T_>::value_type InstanceType; \
|
|
// BOOST_STATIC_ASSERT((boost::is_same<InstanceType, ##OBJECT_T_ >::value)); \
|
|
// static_cast<##OBJECT_T_*>(INSTANCE_)->InstanceType::~InstanceType(); \
|
|
// FixedSizeMemoryPool<##OBJECT_T_>::Instance().Free(##INSTANCE_); }
|
|
//
|
|
//#else // USE_FIXED_SIZE_MEMORY_POOL
|
|
|
|
#if USING_SUN_SHARED_POOL_REPORT
|
|
#define TAllocNew(_type_) \
|
|
new (SharedMemoryPool::MemoryAllocate(sizeof(sun_type_info<##_type_>::value_type), \
|
|
__FUNCTION__, __LINE__)) ##_type_
|
|
#else
|
|
#define TAllocNew(_type_) \
|
|
new (SharedMemoryPool::MemoryAllocate(sizeof(sun_type_info<##_type_>::value_type), \
|
|
NULL, 0)) ##_type_
|
|
#endif
|
|
#define TAllocDelete(_type_, _instance_) { \
|
|
typedef sun_type_info<##_type_>::value_type _typeof_instance_; \
|
|
BOOST_STATIC_ASSERT((boost::is_same<_typeof_instance_, ##_type_ >::value));\
|
|
static_cast<##_type_*>(_instance_)->_typeof_instance_::~_typeof_instance_(); \
|
|
SharedMemoryPool::MemoryDeAllocate(_instance_); }
|
|
|
|
//#endif // USE_FIXED_SIZE_MEMORY_POOL
|
|
|
|
#else // USING_SUN_SHARED_POOL
|
|
|
|
#define TAllocMalloc(_size_) \
|
|
::malloc(_size_)
|
|
|
|
#define TAllocFree(_ptr_) { \
|
|
::free(_ptr_); \
|
|
}
|
|
|
|
#define TAllocNew(_type_) \
|
|
new sun_type_info<##_type_>::value_type
|
|
|
|
#define TAllocDelete(_type_, _instance_) \
|
|
{ static_cast<##_type_*>(_instance_); \
|
|
typedef sun_type_info<##_type_>::value_type _typeof_instance_t; \
|
|
delete (_instance_); }
|
|
|
|
#endif // USING_SUN_SHARED_POOL
|
|
|
|
//==================================================================================================
|