feat: 命名简化

Author: userpro

README.md

@@ -34,11 +34,11 @@ struct TAT
 };
 
 mem_size_t max_mem = 2*GB + 1000*MB + 1000*KB;
-mem_size_t mem_pool_size = 1*GB + 500*MB + 500*KB;
+mem_size_t mempool_size = 1*GB + 500*MB + 500*KB;
 
 int main()
 {
-    MemoryPool *mp = MemoryPoolInit(max_mem, mem_pool_size);
+    MemoryPool *mp = MemoryPoolInit(max_mem, mempool_size);
     struct TAT *tat = (struct TAT *)MemoryPoolAlloc(mp, sizeof(struct TAT));
     tat->T_T = 2333;
     printf("%d\n", tat->T_T);

example.c

@@ -6,10 +6,10 @@ struct TAT {
 };
 
 mem_size_t max_mem = 2 * GB + 1000 * MB + 1000 * KB;
-mem_size_t mem_pool_size = 1 * GB + 500 * MB + 500 * KB;
+mem_size_t mempool_size = 1 * GB + 500 * MB + 500 * KB;
 
 int main() {
-    MemoryPool* mp = MemoryPoolInit(max_mem, mem_pool_size);
+    MemoryPool* mp = MemoryPoolInit(max_mem, mempool_size);
     struct TAT* tat = (struct TAT*) MemoryPoolAlloc(mp, sizeof(struct TAT));
     tat->T_T = 2333;
     printf("%d\n", tat->T_T);

memorypool.c

@@ -14,14 +14,14 @@
 
 #define MP_ALIGN_SIZE(_n) (_n + sizeof(long) - ((sizeof(long) - 1) & _n))
 
-#define MP_INIT_MEMORY_STRUCT(mm, mem_sz)       \
+#define MP_INIT_MEMORY_STRUCT(mm, mempool_sz)   \
     do {                                        \
-        mm->mem_pool_size = mem_sz;             \
+        mm->mempool_size = mempool_sz;          \
         mm->alloc_mem = 0;                      \
         mm->alloc_prog_mem = 0;                 \
         mm->free_list = (_MP_Chunk*) mm->start; \
         mm->free_list->is_free = 1;             \
-        mm->free_list->alloc_mem = mem_sz;      \
+        mm->free_list->alloc_mem = mempool_sz;  \
         mm->free_list->prev = NULL;             \
         mm->free_list->next = NULL;             \
         mm->alloc_list = NULL;                  \
@@ -92,14 +92,14 @@ int get_memory_id(_MP_Memory* mm) {
     return mm->id;
 }
 
-static _MP_Memory* extend_memory_list(MemoryPool* mp, mem_size_t new_mem_sz) {
-    char* s = (char*) malloc(sizeof(_MP_Memory) + new_mem_sz * sizeof(char));
+static _MP_Memory* extend_memory_list(MemoryPool* mp, mem_size_t new_mempool_sz) {
+    char* s = (char*) malloc(sizeof(_MP_Memory) + new_mempool_sz * sizeof(char));
     if (!s) return NULL;
 
     _MP_Memory* mm = (_MP_Memory*) s;
     mm->start = s + sizeof(_MP_Memory);
 
-    MP_INIT_MEMORY_STRUCT(mm, new_mem_sz);
+    MP_INIT_MEMORY_STRUCT(mm, new_mempool_sz);
     mm->id = mp->last_id++;
     mm->next = mp->mlist;
     mp->mlist = mm;
@@ -110,7 +110,7 @@ static _MP_Memory* find_memory_list(MemoryPool* mp, void* p) {
     _MP_Memory* tmp = mp->mlist;
     while (tmp) {
         if (tmp->start <= (char*) p &&
-            tmp->start + mp->mem_pool_size > (char*) p)
+            tmp->start + mp->mempool_size > (char*) p)
             break;
         tmp = tmp->next;
     }
@@ -127,7 +127,7 @@ static int merge_free_chunk(MemoryPool* mp, _MP_Memory* mm, _MP_Chunk* c) {
     }
 
     p0 = (_MP_Chunk*) ((char*) p1 + p1->alloc_mem);
-    while ((char*) p0 < mm->start + mp->mem_pool_size && p0->is_free) {
+    while ((char*) p0 < mm->start + mp->mempool_size && p0->is_free) {
         MP_DLINKLIST_DEL(mm->free_list, p0);
         p1->alloc_mem += p0->alloc_mem;
         p0 = (_MP_Chunk*) ((char*) p0 + p0->alloc_mem);
@@ -140,8 +140,8 @@ static int merge_free_chunk(MemoryPool* mp, _MP_Memory* mm, _MP_Chunk* c) {
     return 0;
 }
 
-MemoryPool* MemoryPoolInit(mem_size_t maxmempoolsize, mem_size_t mempoolsize) {
-    if (mempoolsize > maxmempoolsize) {
+MemoryPool* MemoryPoolInit(mem_size_t max_mempool_size, mem_size_t mempool_size) {
+    if (mempool_size > max_mempool_size) {
         // printf("[MemoryPool_Init] MemPool Init ERROR! Mempoolsize is too big!
         // \n");
         return NULL;
@@ -151,24 +151,24 @@ MemoryPool* MemoryPoolInit(mem_size_t maxmempoolsize, mem_size_t mempoolsize) {
     if (!mp) return NULL;
 
     mp->last_id = 0;
-    if (mempoolsize < maxmempoolsize) mp->auto_extend = 1;
-    mp->max_mem_pool_size = maxmempoolsize;
-    mp->total_mem_pool_size = mp->mem_pool_size = mempoolsize;
+    if (mempool_size < max_mempool_size) mp->auto_extend = 1;
+    mp->max_mempool_size = max_mempool_size;
+    mp->total_mempool_size = mp->mempool_size = mempool_size;
 
 #ifdef _Z_MEMORYPOOL_THREAD_
     pthread_mutex_init(&mp->lock, NULL);
 #endif
 
     char* s = (char*) malloc(sizeof(_MP_Memory) +
-                             sizeof(char) * mp->mem_pool_size);
+                             sizeof(char) * mp->mempool_size);
     if (!s) {
         free(mp);
         return NULL;
     }
 
     mp->mlist = (_MP_Memory*) s;
     mp->mlist->start = s + sizeof(_MP_Memory);
-    MP_INIT_MEMORY_STRUCT(mp->mlist, mp->mem_pool_size);
+    MP_INIT_MEMORY_STRUCT(mp->mlist, mp->mempool_size);
     mp->mlist->next = NULL;
     mp->mlist->id = mp->last_id++;
 
@@ -179,7 +179,7 @@ void* MemoryPoolAlloc(MemoryPool* mp, mem_size_t wantsize) {
     if (wantsize <= 0) return NULL;
     mem_size_t total_needed_size =
             MP_ALIGN_SIZE(wantsize + MP_CHUNKHEADER + MP_CHUNKEND);
-    if (total_needed_size > mp->mem_pool_size) return NULL;
+    if (total_needed_size > mp->mempool_size) return NULL;
 
     _MP_Memory *mm = NULL, *mm1 = NULL;
     _MP_Chunk *_free = NULL, *_not_free = NULL;
@@ -189,7 +189,7 @@ void* MemoryPoolAlloc(MemoryPool* mp, mem_size_t wantsize) {
 FIND_FREE_CHUNK:
     mm = mp->mlist;
     while (mm) {
-        if (mp->mem_pool_size - mm->alloc_mem < total_needed_size) {
+        if (mp->mempool_size - mm->alloc_mem < total_needed_size) {
             mm = mm->next;
             continue;
         }
@@ -250,17 +250,17 @@ void* MemoryPoolAlloc(MemoryPool* mp, mem_size_t wantsize) {
 
     if (mp->auto_extend) {
         // 超过总内存限制
-        if (mp->total_mem_pool_size >= mp->max_mem_pool_size) {
+        if (mp->total_mempool_size >= mp->max_mempool_size) {
             goto err_out;
         }
-        mem_size_t add_mem_sz = mp->max_mem_pool_size - mp->mem_pool_size;
-        add_mem_sz = add_mem_sz >= mp->mem_pool_size ? mp->mem_pool_size
+        mem_size_t add_mem_sz = mp->max_mempool_size - mp->mempool_size;
+        add_mem_sz = add_mem_sz >= mp->mempool_size ? mp->mempool_size
                                                      : add_mem_sz;
         mm1 = extend_memory_list(mp, add_mem_sz);
         if (!mm1) {
             goto err_out;
         }
-        mp->total_mem_pool_size += add_mem_sz;
+        mp->total_mempool_size += add_mem_sz;
 
         goto FIND_FREE_CHUNK;
     }
@@ -300,7 +300,7 @@ MemoryPool* MemoryPoolClear(MemoryPool* mp) {
 #endif
     _MP_Memory* mm = mp->mlist;
     while (mm) {
-        MP_INIT_MEMORY_STRUCT(mm, mm->mem_pool_size);
+        MP_INIT_MEMORY_STRUCT(mm, mm->mempool_size);
         mm = mm->next;
     }
 #ifdef _Z_MEMORYPOOL_THREAD_
@@ -329,7 +329,7 @@ int MemoryPoolDestroy(MemoryPool* mp) {
 }
 
 mem_size_t GetTotalMemory(MemoryPool* mp) {
-    return mp->total_mem_pool_size;
+    return mp->total_mempool_size;
 }
 
 mem_size_t GetUsedMemory(MemoryPool* mp) {

memorypool.h

@@ -19,21 +19,21 @@ typedef struct _mp_chunk {
     int is_free;
 } _MP_Chunk;
 
-typedef struct _mp_mem_pool_list {
+typedef struct _mp_mempool_list {
     char* start;
     unsigned int id;
-    mem_size_t mem_pool_size;
+    mem_size_t mempool_size;
     mem_size_t alloc_mem;
     mem_size_t alloc_prog_mem;
     _MP_Chunk *free_list, *alloc_list;
-    struct _mp_mem_pool_list* next;
+    struct _mp_mempool_list* next;
 } _MP_Memory;
 
-typedef struct _mp_mem_pool {
+typedef struct _mp_mempool {
     unsigned int last_id;
     int auto_extend;
-    mem_size_t mem_pool_size, total_mem_pool_size, max_mem_pool_size;
-    struct _mp_mem_pool_list* mlist;
+    mem_size_t mempool_size, total_mempool_size, max_mempool_size;
+    struct _mp_mempool_list* mlist;
 #ifdef _Z_MEMORYPOOL_THREAD_
     pthread_mutex_t lock;
 #endif

test.cpp

@@ -12,11 +12,11 @@
 // #define HARD_MODE
 
 /* -------- 测试数据参数 -------- */
-#define MAX_MEM_SIZE (2 * GB)   // 内存池管理的每个内存块大小
-#define MEM_SIZE (0.3 * GB)     // 内存池管理的每个内存块大小
+#define MAX_MEM_SIZE (2 * GB)    // 内存池管理的每个内存块大小
+#define MEM_SIZE (0.3 * GB)      // 内存池管理的每个内存块大小
 #define DATA_N (50000)           // 数据条数
 #define DATA_MAX_SIZE (16 * KB)  // 每条数据最大尺寸
-#define MAX_N (3)               // 总测试次数
+#define MAX_N (3)                // 总测试次数
 /* -------- 测试数据参数 -------- */
 
 #ifdef _Z_MEMORYPOOL_H_
@@ -143,7 +143,7 @@ void* test_fn(void* arg) {
     SHOW("Free After: ", mp);
 #endif
     printf("Memory Pool Size: %.4lf MB\n",
-           (double) mp->total_mem_pool_size / 1024 / 1024);
+           (double) mp->total_mempool_size / 1024 / 1024);
 #endif
     printf("Total Usage Size: %.4lf MB\n", (double) total_size / 1024 / 1024);