Memory Pools V1.2

// MemPoolCore.cpp #include <stdio.h> #include <stdlib.h> #include <string.h> #include <new> #include <errno.h> #include <pthread.h> #include <semaphore.h> #include <time.h> #include <limits.h> #include <unistd.h> #include <sys/prctl.h> #include "MemPoolCore.hpp" #define M_8_BYTE_COUNT (1024*32) #define M_16_BYTE_COUNT (1024*32) #define M_32_BYTE_COUNT (1024*32) #define M_64_BYTE_COUNT (1024*32) #define M_128_BYTE_COUNT (1024*32) #define M_256_BYTE_COUNT (1024*16) #define M_512_BYTE_COUNT (1024*32) #define M_1024_BYTE_COUNT (1024*32) #define M_2048_BYTE_COUNT (1024*32) #define M_4096_BYTE_COUNT (1024*16) typedef struct { void * pAddr; int isUsed; void * pNext; } MPC_MemBlock_t; #define MGR_8_BYTE_TOTAL_SIZE ( M_8_BYTE_COUNT * sizeof(MPC_MemBlock_t) ) #define MGR_16_BYTE_TOTAL_SIZE ( M_16_BYTE_COUNT * sizeof(MPC_MemBlock_t) ) #define MGR_32_BYTE_TOTAL_SIZE ( M_32_BYTE_COUNT * sizeof(MPC_MemBlock_t) ) #define MGR_64_BYTE_TOTAL_SIZE ( M_64_BYTE_COUNT * sizeof(MPC_MemBlock_t) ) #define MGR_128_BYTE_TOTAL_SIZE ( M_128_BYTE_COUNT * sizeof(MPC_MemBlock_t) ) #define MGR_256_BYTE_TOTAL_SIZE ( M_256_BYTE_COUNT * sizeof(MPC_MemBlock_t) ) #define MGR_512_BYTE_TOTAL_SIZE ( M_512_BYTE_COUNT * sizeof(MPC_MemBlock_t) ) #define MGR_1024_BYTE_TOTAL_SIZE ( M_1024_BYTE_COUNT * sizeof(MPC_MemBlock_t) ) #define MGR_2048_BYTE_TOTAL_SIZE ( M_2048_BYTE_COUNT * sizeof(MPC_MemBlock_t) ) #define MGR_4096_BYTE_TOTAL_SIZE ( M_4096_BYTE_COUNT * sizeof(MPC_MemBlock_t) ) #define MEM_8_BYTE_TOTAL_SIZE ( M_8_BYTE_COUNT * 8 ) #define MEM_16_BYTE_TOTAL_SIZE ( M_16_BYTE_COUNT * 16 ) #define MEM_32_BYTE_TOTAL_SIZE ( M_32_BYTE_COUNT * 32 ) #define MEM_64_BYTE_TOTAL_SIZE ( M_64_BYTE_COUNT * 64 ) #define MEM_128_BYTE_TOTAL_SIZE ( M_128_BYTE_COUNT * 128 ) #define MEM_256_BYTE_TOTAL_SIZE ( M_256_BYTE_COUNT * 256 ) #define MEM_512_BYTE_TOTAL_SIZE ( M_512_BYTE_COUNT * 512 ) #define MEM_1024_BYTE_TOTAL_SIZE ( M_1024_BYTE_COUNT * 1024 ) #define MEM_2048_BYTE_TOTAL_SIZE ( M_2048_BYTE_COUNT * 2048 ) #define MEM_4096_BYTE_TOTAL_SIZE ( M_4096_BYTE_COUNT * 4096 ) MPC_MemBlock_t * p_8_BYTE_mgr_table; MPC_MemBlock_t * p_16_BYTE_mgr_table; MPC_MemBlock_t * p_32_BYTE_mgr_table; MPC_MemBlock_t * p_64_BYTE_mgr_table; MPC_MemBlock_t * p_128_BYTE_mgr_table; MPC_MemBlock_t * p_256_BYTE_mgr_table; MPC_MemBlock_t * p_512_BYTE_mgr_table; MPC_MemBlock_t * p_1024_BYTE_mgr_table; MPC_MemBlock_t * p_2048_BYTE_mgr_table; MPC_MemBlock_t * p_4096_BYTE_mgr_table; char * p_8_BYTE_mem_table; char * p_16_BYTE_mem_table; char * p_32_BYTE_mem_table; char * p_64_BYTE_mem_table; char * p_128_BYTE_mem_table; char * p_256_BYTE_mem_table; char * p_512_BYTE_mem_table; char * p_1024_BYTE_mem_table; char * p_2048_BYTE_mem_table; char * p_4096_BYTE_mem_table; // mgr table typedef struct { int id; int fragmentSize; void * startAddr; void * endAddr; void * BlockAddr; int BlockSize; int BlockCount; void * pNext; } MPC_MgrBlock_t; #define MPC_MGRBLOCK_COUNT (32) static MPC_MgrBlock_t * g_MPC_MgrBlock_Head = NULL; #define G_GLOBAL_MEMORY_BLOCK_MAX_SIZE (256 * 1024 * 1024) static void * g_pGlobalMem = NULL; // Add by wangyl #define INFINITE_WAIT 0xFFFFFFFF #define LOCK_OBJ pthread_mutex_t #define LOCK_ATT pthread_mutexattr_t #define NOTIFY_OBJ sem_t #define NOTIFY_TYPE sem_t * typedef struct { unsigned long long threadID; char threadName[16]; unsigned long long mallocCount; // total count. unsigned long long mallocSize; // total size. // unsigned long long mallocUsedSize; // no free size. } HoldThreadInfo_t; // add by wangyl #define DEF_HOLD_THREAD_TABLE_LOCK static LOCK_OBJ *hHoldThreadTableLock; \ static LOCK_OBJ HoldThreadTableLock; \ static LOCK_ATT HoldThreadTableLock_att #define CRE_HOLD_THREAD_TABLE_LOCK() hHoldThreadTableLock = &HoldThreadTableLock; \ pthread_mutexattr_init( &HoldThreadTableLock_att ); \ pthread_mutexattr_settype( &HoldThreadTableLock_att, PTHREAD_MUTEX_RECURSIVE_NP ); \ pthread_mutex_init( hHoldThreadTableLock, &HoldThreadTableLock_att ) #define DEL_HOLD_THREAD_TABLE_LOCK() pthread_mutex_destroy( hHoldThreadTableLock ); \ hHoldThreadTableLock = NULL #define LOCK_HOLD_THREAD_INFO() pthread_mutex_lock( hHoldThreadTableLock ) #define FREE_HOLD_THREAD_INFO() pthread_mutex_unlock( hHoldThreadTableLock ) #define OWN_THREAD_ID pthread_self() #define SELF_THREAD_ID() pthread_self() #define HOLD_THREAD_INFO_NUM (128) #define TaskNameSize (16) //Max size of thread name is 16 byte. DEF_HOLD_THREAD_TABLE_LOCK; static HoldThreadInfo_t HoldThreadInfo[HOLD_THREAD_INFO_NUM]; static int LoaderRecordStatus = 0; static long long HoldThreadInfoCount = 0; #define INIT_MGRBLK_TABLE(cur, pre) \ do { \ p_##cur##_BYTE_mgr_table = \ (MPC_MemBlock_t *)((char *)p_##pre##_BYTE_mgr_table + \ MGR_##pre##_BYTE_TOTAL_SIZE + \ MEM_##pre##_BYTE_TOTAL_SIZE); \ p_##cur##_BYTE_mem_table = \ (char *)(p_##cur##_BYTE_mgr_table + \ M_##cur##_BYTE_COUNT); \ MPC_MemBlock_t * p = p_##cur##_BYTE_mgr_table; \ char * p_m = p_##cur##_BYTE_mem_table; \ int i=0; \ for (i=0; i<M_##cur##_BYTE_COUNT; i++) \ { \ p->pAddr = p_m; \ p->isUsed = 0; \ p++; \ p_m += cur; \ } \ } while(0) #define INIT_MGRBLK_HEAD(idx, cur) \ do { \ g_MPC_MgrBlock_Head[idx].id = idx; \ g_MPC_MgrBlock_Head[idx].fragmentSize = cur; \ g_MPC_MgrBlock_Head[idx].startAddr = p_##cur##_BYTE_mem_table; \ g_MPC_MgrBlock_Head[idx].endAddr = \ p_##cur##_BYTE_mem_table + \ MEM_##cur##_BYTE_TOTAL_SIZE; \ g_MPC_MgrBlock_Head[idx].BlockAddr = p_##cur##_BYTE_mgr_table; \ g_MPC_MgrBlock_Head[idx].BlockSize = sizeof(MPC_MemBlock_t); \ g_MPC_MgrBlock_Head[idx].BlockCount = M_##cur##_BYTE_COUNT; \ g_MPC_MgrBlock_Head[idx].pNext = NULL; \ } while(0) void *MP_Core_malloc_impl(size_t c) { void * result = NULL; // return __real_malloc( c ); MPC_MgrBlock_t * pMgr = g_MPC_MgrBlock_Head; MPC_MemBlock_t * pBlockMgr = NULL; int i=0; for (i=0; i<10; i++) { if ( c <= pMgr[i].fragmentSize ) { pBlockMgr = (MPC_MemBlock_t *)pMgr[i].BlockAddr; break; } } int j=0; if ( pBlockMgr ) { for (j=0; j<pMgr[i].BlockCount; j++) { if ( pBlockMgr[j].isUsed == 0 ) { pBlockMgr[j].isUsed = 1; result = pBlockMgr[j].pAddr; break; } } } //printf(" addr : [0x%lx][%ld].\n", result, c); return result; } void MP_Core_free_impl( void * memblock ) { // __real_free( memblock ); //printf("free addr : [0x%lx].\n", memblock); MPC_MgrBlock_t * pMgr = g_MPC_MgrBlock_Head; MPC_MemBlock_t * pBlockMgr = NULL; int i=0; for (i=0; i<10; i++) { if ( pMgr[i].startAddr <= memblock && memblock <= pMgr[i].endAddr) { pBlockMgr = (MPC_MemBlock_t *)pMgr[i].BlockAddr; break; } } int j=0; if ( pBlockMgr ) { for (j=0; j<pMgr[i].BlockCount; j++) { if ( pBlockMgr[j].pAddr == memblock ) { pBlockMgr[j].isUsed = 0; break; } } } } extern "C" { void *__real_malloc(size_t); void __real_free( void * memblock ); void *MP_Core_malloc(size_t c) { return MP_Core_malloc_impl( c ); } void MP_Core_free( void * memblock ) { MP_Core_free_impl( memblock ); } void __attribute__((constructor)) MP_Core_init() { //printf("call my MP_Core_init[13:58].\n"); #if 1 // alloc g_pGlobalMem; g_pGlobalMem = __real_malloc( G_GLOBAL_MEMORY_BLOCK_MAX_SIZE ); if ( g_pGlobalMem == NULL ) { printf("g_pGlobalMem alloc NG.\n"); return ; } printf("g_pGlobalMem alloc OK[14:13].\n"); // init 8 byte table. { // MPC_MemBlock_t * p_8_BYTE_mgr_table; // [M_8_BYTE_COUNT]; p_8_BYTE_mgr_table = (MPC_MemBlock_t *)((char *)g_pGlobalMem + sizeof(MPC_MgrBlock_t) * MPC_MGRBLOCK_COUNT); p_8_BYTE_mem_table = (char *)(p_8_BYTE_mgr_table + M_8_BYTE_COUNT