#define MEM_BLOCK_ITEM_64_BLOCK_NUM 2048
#define MEM_BLOCK_ITEM_128_BLOCK_NUM 512
#define MEM_BLOCK_ITEM_256_BLOCK_NUM 128
#define BLOCK_SIZE_64 64
#define BLOCK_SIZE_128 128
#define BLOCK_SIZE_256 256
#define MAX_BLOCKS_NUM 3
#define MAX_BLOCK_SIZE 256
typedef struct MEMBLOCKITEM64{
struct MEMBLOCKITEM64 *pNext;
int nBlockSize;
int flag; // free/use
int memory[32];
}MEM_BLOCK_ITEM_64;
typedef struct MEMBLOCKITEM128{
struct MEMBLOCKITEM128 *pNext;
int nBlockSize;
int flag; // free/use
int memory[128];
}MEM_BLOCK_ITEM_128;
typedef struct MEMBLOCKITEM256 {
struct MEMBLOCKITEM256 *pNext;
int nBlockSize;
int flag; // free/use
int memory[256];
}MEM_BLOCK_ITEM_256;
typedef struct {
int nBlockSize;
int nBlockNum;
MEM_BLOCK_ITEM_64 * pBlockHead64;
char text[16];
}MEM_APP_BLOCK_64;
typedef struct {
int nBlockSize;
int nBlockNum;
MEM_BLOCK_ITEM_128 * pBlockHead64;
char text[16];
}MEM_APP_BLOCK_128;
/*
typedef struct {
int nBlockSize;
int nBlockNum;
MEM_BLOCK_ITEM_256 * pBlockHead64;
char text[16];
}MEM_APP_BLOCK_256;
*/
typedef struct {
int nBlockSize;
int nBlockNum;
union {
MEM_BLOCK_ITEM_64 * pBlockHead64;
MEM_BLOCK_ITEM_128 * pBlockHead128;
MEM_BLOCK_ITEM_256 * pBlockHead256;
} MEM_BLOCK_ITEM;
char text[16];
}MEM_APP_BLOCK;
/*
typedef struct {
int nBlockSize; //每个内存块的大小
int nBlocksNum; //内存池中内存块的个数
MEM_BLOCK_ITEM_64 * pBlockHead64;
char text[16];
}MEM_APP_BLOCK_64;
typedef struct {
int nBlockSize;
int nBlockNum;
MEM_BLOCK_ITEM_128 * pBlockHead128;
char text[16];
}MEM_APP_BLOCK_128;
typedef struct {
int nBlockSize;
int nBlockNum;
MEM_BLOCK_ITEM_256 *pBlockHead256;
char text[16];
}MEM_APP_BLOCK_256;
*/
/*
typedef struct MEM_BLOCK_POOL {
MEM_APP_BLOCK_64 *memAppBlock64; // 采用指针，便于后面的赋值，否则后面由于只能通过赋值的方式给结构体赋值，将会造成很大的空间浪费
MEM_APP_BLOCK_128 *memAppBlock128;
MEM_APP_BLOCK_256 *memAppBlock256;
}MEMBLOCKPOOL;
MEMBLOCKPOOL memBlockPool;
*/
typedef struct MEM_BLOCK_POOL {
MEM_APP_BLOCK *pMemAppBlock[3];
}MEMBLOCKPOOL;
MEMBLOCKPOOL memBlockPool;
/////////////////////
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#include "mem_block.h"
void mem_block_init();
int * mem_block_alloc();
void mem_block_free();
void mem_block_uninit();
void main()
{
int *pMemBlockAddr = NULL;
mem_block_init();
pMemBlockAddr =mem_block_alloc(5 * sizeof(int));
memset(pMemBlockAddr,5,5*sizeof(int));
//printf("%s/n",memBlockPool.pMemAppBlock[0]->text);
printf("%d/n",memBlockPool.pMemAppBlock[0]->MEM_BLOCK_ITEM.pBlockHead64->memory[0]);
}
void mem_block_init()
{
/***************************************************************************
分配得到2048个64 byte大小的内存块， 512 * 128 byte 大小的内存块 128 * 256
byte的心的内存块
****************************************************************************/
int i = 0;
MEM_BLOCK_ITEM_64 *pMemBlockItem64;
MEM_BLOCK_ITEM_64 *pTempMemBlockItem64;
MEM_BLOCK_ITEM_128 *pMemBlockItem128;
MEM_BLOCK_ITEM_128 *pTempMemBlockItem128;
MEM_BLOCK_ITEM_256 *pMemBlockItem256;
MEM_BLOCK_ITEM_256 *pTempMemBlockItem256;
/*
MEM_BLOCK_ITEM memAppBlock[3] = {
{64,MEM_BLOCK_ITEM_128_BLOCK_NUM,pMemBlockItem64,"Block Pool 64"},
{128,MEM_BLOCK_ITEM_128_BLOCK_NUM,pMemBlockItem128,"Block Pool 128"},
{256,MEM_BLOCK_ITEM_256_BLOCK_NUM,pMemBlockItem256,"Block Pool 256"}
};
*/
MEM_APP_BLOCK memAppBlock[3] = {
{64,MEM_BLOCK_ITEM_128_BLOCK_NUM,NULL,"Block Pool 64"},
{128,MEM_BLOCK_ITEM_128_BLOCK_NUM,NULL,"Block Pool 128"},
{256,MEM_BLOCK_ITEM_256_BLOCK_NUM,NULL,"Block Pool 256"}
};
/*
MEM_APP_BLOCK_64 memAppBlock64 = {64,MEM_BLOCK_ITEM_128_BLOCK_NUM,pMemBlockItem64,"Block Pool 64"};
MEM_APP_BLOCK_128 memAppBlock128 = {128,MEM_BLOCK_ITEM_128_BLOCK_NUM,pMemBlockItem128,"Block Pool 128"};
MEM_APP_BLOCK_256 memAppBlock256 = {256,MEM_BLOCK_ITEM_256_BLOCK_NUM,pMemBlockItem256,"Block Pool 256"};
*/
pMemBlockItem64 = (MEM_BLOCK_ITEM_64 *)malloc (MEM_BLOCK_ITEM_64_BLOCK_NUM * sizeof(MEM_BLOCK_ITEM_64));
pMemBlockItem128 = (MEM_BLOCK_ITEM_128 *)malloc (MEM_BLOCK_ITEM_128_BLOCK_NUM * sizeof(MEM_BLOCK_ITEM_128));
pMemBlockItem256 = (MEM_BLOCK_ITEM_256 *)malloc (MEM_BLOCK_ITEM_256_BLOCK_NUM * sizeof(MEM_BLOCK_ITEM_256));
memAppBlock[0].MEM_BLOCK_ITEM.pBlockHead64 = pMemBlockItem64;
memAppBlock[1].MEM_BLOCK_ITEM.pBlockHead128 = pMemBlockItem128;
memAppBlock[2].MEM_BLOCK_ITEM.pBlockHead256 = pMemBlockItem256;
/*
memBlockPool.memAppBlock64 = &memAppBlock64; //将数组中的值赋予memBlockPool
memBlockPool.memAppBlock128 = &memAppBlock128;
memBlockPool.memAppBlock256 = &memAppBlock256;
*/
memBlockPool.pMemAppBlock[0] = &memAppBlock[0]; //将数组中的值赋予memBlockPool 但是这些值只是在当前函数内有用，脱离该函数后便失效，因为他说数组
memBlockPool.pMemAppBlock[1] = &memAppBlock[1];
memBlockPool.pMemAppBlock[2] = &memAppBlock[2];
for (i = 0; i < MEM_BLOCK_ITEM_64_BLOCK_NUM - 1; i++)
{
pTempMemBlockItem64 = (MEM_BLOCK_ITEM_64 *) (pMemBlockItem64 + i);
pTempMemBlockItem64->pNext = NULL;
pMemBlockItem64->flag = 0;
pMemBlockItem64->nBlockSize = BLOCK_SIZE_64;
memset(pMemBlockItem64->memory,0,pMemBlockItem64->nBlockSize);
pMemBlockItem64->pNext = pTempMemBlockItem64;
}
/*初始化最后一个块*/
pTempMemBlockItem64->flag = 0;
pTempMemBlockItem64->nBlockSize = BLOCK_SIZE_64;
memset(pTempMemBlockItem64->memory,0,pMemBlockItem64->nBlockSize);
for (i = 0; i < MEM_BLOCK_ITEM_128_BLOCK_NUM-1; i++)
{
pTempMemBlockItem128 = (MEM_BLOCK_ITEM_128 *) (pMemBlockItem128 + i);
pTempMemBlockItem128->pNext = NULL;
pMemBlockItem128->flag = 0;
pMemBlockItem128->nBlockSize = BLOCK_SIZE_128;
memset(pMemBlockItem128->memory,0,pMemBlockItem128->nBlockSize);
pMemBlockItem128->pNext = pTempMemBlockItem128;
}
/*初始化最后一个块*/
pTempMemBlockItem128->flag = 0;
pTempMemBlockItem128->nBlockSize = BLOCK_SIZE_128;
memset(pTempMemBlockItem128->memory,0,pMemBlockItem128->nBlockSize);
for (i = 0; i < MEM_BLOCK_ITEM_256_BLOCK_NUM-1; i++)
{
pTempMemBlockItem256 = (MEM_BLOCK_ITEM_256 *) (pMemBlockItem256 + i);
pTempMemBlockItem256->pNext = NULL;
pMemBlockItem256->flag = 0;
pMemBlockItem256->nBlockSize = BLOCK_SIZE_256;
memset(pMemBlockItem256->memory,0,pMemBlockItem256->nBlockSize);
pMemBlockItem256->pNext = pTempMemBlockItem256;
}
/*初始化最后一个块*/
pTempMemBlockItem256->flag = 0;
pTempMemBlockItem256->nBlockSize = BLOCK_SIZE_256;
memset(pTempMemBlockItem256->memory,0,pMemBlockItem256->nBlockSize);
}
int * mem_block_alloc(int nSize)
{
int i = 0;
int j = 0;
MEM_BLOCK_ITEM_64 * pMemBlockItem64 = NULL;
MEM_BLOCK_ITEM_128 * pMemBlockItem128 = NULL;
MEM_BLOCK_ITEM_256 * pMemBlockItem256 = NULL;
if (nSize <= MAX_BLOCK_SIZE)
{
for (i = 0; i < MAX_BLOCKS_NUM; i++)
{
if (nSize > memBlockPool.pMemAppBlock[i]->nBlockSize)
{
continue;
}
else
{
switch(i)
{
case 0:
pMemBlockItem64 = (MEM_BLOCK_ITEM_64 *)memBlockPool.pMemAppBlock[i]->MEM_BLOCK_ITEM.pBlockHead64; //前面不需要强制类型转换
break;
case 1:
pMemBlockItem128 = (MEM_BLOCK_ITEM_128 *)memBlockPool.pMemAppBlock[i]->MEM_BLOCK_ITEM.pBlockHead128;
break;
case 2:
pMemBlockItem256 = (MEM_BLOCK_ITEM_256 *)memBlockPool.pMemAppBlock[i]->MEM_BLOCK_ITEM.pBlockHead256;
break;
default:
printf("Error: No Blocks already!/n");
return NULL;
}
for (j = 0; j < memBlockPool.pMemAppBlock[i]->nBlockSize; j++)
{
if (0 == i)
{
if (pMemBlockItem64->flag == 0)
{
pMemBlockItem64->flag = 1;
return pMemBlockItem64->memory;
}
else
{
pMemBlockItem64 = pMemBlockItem64->pNext;
continue;
}
}
if (1 == i)
{
if (pMemBlockItem128->flag == 0)
{
pMemBlockItem128->flag = 1;
return pMemBlockItem128->memory;
}
else
{
pMemBlockItem128 = pMemBlockItem128->pNext;
continue;
}
}
if (2 == i)
{
if (pMemBlockItem256->flag == 0)
{
pMemBlockItem256->flag = 1;
return pMemBlockItem256->memory;
}
else
{
pMemBlockItem256 = pMemBlockItem256->pNext;
continue;
}
}
}
}
}
}
else
{
printf("can not alloc memory in Blocks Pool/n");
return NULL;
}
}
/*如何确定其所在结构的类型*/
void mem_block_free(int *p)
{
int nBlockSize = 0;
int flag = 0;
int *pMemBlockAddr = NULL;
int *pMemBlockSize = NULL;
pMemBlockAddr = (int)p - sizeof(int);
*pMemBlockAddr = 1; //这一点移植性不好
pMemBlockSize = (int)p - 2*sizeof(int); //得到结构体成员nBlockSize的值
nBlockSize = *pMemBlockSize;
memset(p,0,nBlockSize);
}
void mem_block_uninit()
{
free(memBlockPool.pMemAppBlock[0]);
free(memBlockPool.pMemAppBlock[1]);
free(memBlockPool.pMemAppBlock[2]);
memBlockPool.pMemAppBlock[0] = NULL;
memBlockPool.pMemAppBlock[1] = NULL;
memBlockPool.pMemAppBlock[2] = NULL;
}
/////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
#include<string.h>
#include "mem_byte.h"
myPOOL pool;
int main()
{
pool = my_mem_init();
}
myPOOL my_mem_init()
{
myPOOL pool;
mySTARTCB *pStartcbFirst;
myENDCB *pEndcbFirst;
pStartcbFirst = (mySTARTCB *)malloc(DEFAULT_MEM_SIZE);
memset((int *)pStartcbFirst,0,DEFAULT_MEM_SIZE);
pStartcbFirst->pStartCbBegin = (int *)pStartcbFirst; /*字节池首地址*/
pStartcbFirst->flag = 0;
pStartcbFirst->nSize = DEFAULT_MEM_SIZE - 28; /*真正内存的大小*/
pStartcbFirst->pFront = NULL;
pStartcbFirst->pNext = NULL;
pEndcbFirst = (myENDCB *)((int *)pStartcbFirst + DEFAULT_MEM_SIZE -20);
pEndcbFirst->nCRC = 0;
pEndcbFirst->pEndCbToMemBegin = (int *)pStartcbFirst + 20;
pStartcbFirst->pEndCb = pEndcbFirst;
pool.pHeapBegin = (int *)pStartcbFirst; /*会不会有问题*/
pool.headPOOL = pStartcbFirst;
pool.nMemSize = DEFAULT_MEM_SIZE;
return pool;
}
int * my_mem_alloc(int nSize)
{
mySTARTCB *pTemp = NULL;
mySTARTCB *pTempSTARTCB;
myENDCB *pTempENDCB;
mySTARTCB *pTempNewSTARTCB;
myENDCB *pTempNewENDCB;
for (pTemp = pool.headPOOL; NULL != pTemp; pTemp = pTemp->pNext)
{
if (nSize > pTemp->nSize) /* 如果申请的内存大于当前字节池的容量，则放弃 */
{
continue;
}
else
{
/*分给它，然后看是否把当前字节池分解为两部分*/
pTemp->flag = 1;
if (pTemp->nSize - nSize > MIN_MEM_SIZE) /* 如果剩余的空间大于最小内存空间则将其进行分解 */
{
/* 为分解得到的段的前一段的末尾字段赋值 */
pTempNewENDCB = (myENDCB *)(pTemp->pStartCbBegin + nSize + 20);
pTempNewENDCB->nCRC = 0;
pTempNewENDCB->pEndCbToMemBegin = pTemp->pStartCbBegin + 20;
/* 为分解得到的段的后一段的首字段赋值 */
pTempNewSTARTCB->flag = 0;
pTempNewSTARTCB->nSize = pTemp->nSize - nSize - 28;
pTempNewSTARTCB->pEndCb = pTemp->pEndCb;
pTempNewSTARTCB->pFront = pTemp;
pTempNewSTARTCB->pNext = pTemp->pNext;
pTempNewSTARTCB->pStartCbBegin = pTemp->pStartCbBegin + nSize + 48;
/* 为分解得到的后一段的末尾字段赋值 */
pTemp->pEndCb->nCRC = 0;
pTemp->pEndCb->pEndCbToMemBegin = pTempNewSTARTCB->pStartCbBegin + 20;
pTemp->pNext = pTempNewSTARTCB;
pTemp->nSize = nSize;
pTemp->pEndCb = pTempNewENDCB;
}
/* 分配内存成功,返回分配内存的首地址 */
return pTemp->pStartCbBegin + 20;
}
/* 找不到合适的内存块，申请内存失败，返回-1 */
if (NULL == pTemp->pNext)
{
return -1;
}
}
}
void my_mem_free(void *p)
{
mySTARTCB * pTemp;
for (pTemp = pool.headPOOL; pTemp != NULL && (int *)p != pTemp->pStartCbBegin + 20; pTemp = pTemp ->pNext)
{
pTemp->flag = 0;
if (pTemp->pFront->flag == 0 && NULL == pTemp->pFront && pTemp->pNext->flag == 0 && NULL !=pTemp->pNext ) /* 如果前后内存均为使用，则合并*/
{
pTemp = pTemp->pFront;
pTemp->nSize = pTemp->nSize + pTemp->pNext->nSize + pTemp->pNext->pNext->nSize;
pTemp->pNext->pNext->pEndCb->nCRC = 0;
pTemp->pNext->pNext->pEndCb->pEndCbToMemBegin = pTemp->pStartCbBegin + 20;
}
else if (pTemp->pNext != NULL && pTemp->pNext->flag == 0)/* 如果后面的内存未使用，则合并 */
{
pTemp->nSize = pTemp->nSize + pTemp->pNext->nSize + 28;
pTemp->pNext = pTemp->pNext->pNext;
pTemp->pNext->pEndCb->pEndCbToMemBegin = pTemp->pStartCbBegin + 20;
pTemp->pEndCb = pTemp->pNext->pEndCb;
}
else if(pTemp->pFront->flag == 0 && pTemp->pFront != NULL)/* 如果前面的内存未使用，则合并 */
{
pTemp = pTemp->pFront;
pTemp->nSize = pTemp->nSize + pTemp->pNext->nSize + 28;
pTemp->pNext = pTemp->pNext->pNext;
pTemp->pNext->pEndCb->pEndCbToMemBegin = pTemp->pStartCbBegin + 20;
pTemp->pEndCb = pTemp->pNext->pEndCb;
}
memset((int *)(pTemp->pStartCbBegin + 20),0,pTemp->nSize);
return 0;
}
if (NULL == pTemp)
{
return -1;
}
}
void my_mem_deinit()
{
free(pool->pHeapBegin);
pool->pHeapBegin = NULL;
}