简单之内存管理

/******************************************************************/


//内存管理
/******************************************************************/
enum _mem_atb {
_F,
_T
};


#pragma pack(1)


struct _mem_data {
union _ma {
struct _attribute {
unsigned char umZR : 4; //终止0
unsigned char umCA : 1; //是否变动
unsigned char umEN : 1;  //结束尾
unsigned char umON : 1; //被使用
unsigned char umOF : 1; //未使用
}ATB;
unsigned char _AT;
}MA;
size_t umSize;
_mem_data * sutNext;
};


struct _mem_area {
size_t umSize; //总大小
size_t umRize; //剩余大小 
_mem_data * umPoint; //当前位置
_mem_data * umLoint; //至低位位置
_mem_data * umBoint; //指向内存截止位置
_mem_data * umBacker; //尾部
_mem_data * umHeader; //头部
unsigned char * umBuffer; //内存池
unsigned short umDataSize; //_mem_data 大小
};


#pragma pack()


/******************************************************************/
//初始化固定既够用内存大小
void __fastcall _mem_init(size_t uLen,size_t uMaxSize);
//删除初始化内存大小
void __fastcall _mem_dele(void);
/******************************************************************/
//分配一块内存空间
void * __fastcall _mem_alloc(size_t umSize);
//释放一块内存空间
void __fastcall _mem_free(void * umAddr);
/******************************************************************/
bool __fastcall _mem_set(void * umAddr,int uVal);
bool __fastcall _mem_cpy(void * dmAddr,const void * smAddr);
bool __fastcall _mem_cmp(const void * dmAddr,const void * smAddr);
bool __fastcall _mem_xch(void * dmAddr,void * smAddr);
/******************************************************************/

//extern _mem_area MEM_AREA;












#include "stdafx.h"
#include "memgr.h"
#include "almem.h"


static _mem_area MEM_AREA = {sizeof(_mem_data),0U,0U,0U,0U,0U,0U,0U};


/******************************************************************/
void __fastcall _mem_init(size_t uLen,size_t uMaxSize)
{
register size_t _MaxSize = (uMaxSize * uLen) + (sizeof(_mem_data) * uMaxSize);


//_MaxSize = _MaxSize & 0x03;
MEM_AREA.umBuffer = (unsigned char *)malloc(_MaxSize);


if (MEM_AREA.umBuffer != NULL) {
_mem_data _mData = {0U};


_memset(MEM_AREA.umBuffer,0,_MaxSize);


MEM_AREA.umSize = _MaxSize;
MEM_AREA.umLoint = (_mem_data *)MEM_AREA.umBuffer;
MEM_AREA.umPoint = (_mem_data *)MEM_AREA.umBuffer;
MEM_AREA.umRize = _MaxSize - sizeof(_mem_data) * 2U;
MEM_AREA.umBoint = (_mem_data *)(MEM_AREA.umBuffer + _MaxSize - sizeof(_mem_data));


_mData.MA.ATB.umOF = _T;
_mData.umSize = MEM_AREA.umRize;
_mData.sutNext = MEM_AREA.umBoint;


_memcpy(MEM_AREA.umLoint,&_mData,sizeof(_mem_data));
MEM_AREA.umHeader = MEM_AREA.umLoint;


_mData.MA.ATB.umEN = _T;
_mData.MA.ATB.umOF = _F;
_mData.umSize = 0U;
_mData.sutNext = MEM_AREA.umLoint;


_memcpy(MEM_AREA.umBoint,&_mData,sizeof(_mem_data));
MEM_AREA.umBacker = MEM_AREA.umBoint;
}
}
/******************************************************************/
 void __fastcall _mem_dele(void)
{
if (MEM_AREA.umBuffer != NULL) {
free(MEM_AREA.umBuffer);
}
_memset(&MEM_AREA,0,sizeof(_mem_area));
}
/******************************************************************/
 void * __fastcall _mem_alloc(size_t umSize)
 {
_mem_data * _lpMd = MEM_AREA.umPoint;


for (register unsigned short i = 0; i < 2U; ++i) {
while (_lpMd != MEM_AREA.umBacker) {
if (_T == _lpMd->MA.ATB.umOF) {
if (_lpMd->umSize > umSize && (_lpMd->umSize - umSize) >= sizeof(_mem_data)) {
_mem_data *_lptMd = (_mem_data *)((unsigned char*)_lpMd + (umSize + sizeof(_mem_data)));
_memset(_lptMd,0,sizeof(_mem_data));
_lptMd->MA.ATB.umOF = _T;
_lptMd->sutNext = _lpMd->sutNext;
_lptMd->umSize = _lpMd->umSize - (umSize + sizeof(_mem_data));
_lpMd->MA.ATB.umOF = _F;
_lpMd->MA.ATB.umON = _T;
_lpMd->MA.ATB.umCA = _T;
_lpMd->umSize = umSize;
_lpMd->sutNext = _lptMd;
MEM_AREA.umPoint = _lptMd;
MEM_AREA.umRize -= umSize + sizeof(_mem_data);
return ((unsigned char *)_lpMd + sizeof(_mem_data));
} else if (umSize == _lpMd->umSize) {
_lpMd->MA.ATB.umCA = _F;
_lpMd->MA.ATB.umOF = _F;
_lpMd->MA.ATB.umON = _T;
MEM_AREA.umPoint = _lpMd->sutNext;
MEM_AREA.umRize -= umSize;
return ((unsigned char *)_lpMd + sizeof(_mem_data));
} else if (_lpMd->umSize < umSize) {
register size_t _nCount = _lpMd->umSize;
_mem_data *_lpMds = _lpMd->sutNext;
while (_lpMds != MEM_AREA.umBacker) {
if (_T == _lpMds->MA.ATB.umOF) {
_nCount += _lpMds->umSize;
if (_nCount > umSize && (_nCount - umSize) >= sizeof(_mem_data)) {
_mem_data *_lptMd = (_mem_data *)((unsigned char*)_lpMd + (umSize + sizeof(_mem_data)));
_lpMds = _lpMds->sutNext;
while (_lptMd > _lpMds) { _lpMds = _lpMds->sutNext; }
_memset(_lptMd,0,sizeof(_mem_data));
_lptMd->MA.ATB.umOF = _T;
_lptMd->sutNext = _lpMds;
_lptMd->umSize = _nCount - (umSize + sizeof(_mem_data));
_lpMd->MA.ATB.umOF = _F;
_lpMd->MA.ATB.umON = _T;
_lpMd->MA.ATB.umCA = _T;
_lpMd->umSize = umSize;
_lpMd->sutNext = _lptMd;
MEM_AREA.umPoint = _lptMd;
MEM_AREA.umRize -= umSize + sizeof(_mem_data);
return ((unsigned char *)_lpMd + sizeof(_mem_data));
} 
} else { 
_lpMd = _lpMds->sutNext;
break;
}
_lpMds = _lpMds->sutNext;
continue;
} 
break;
} else {
_lpMd = _lpMd->sutNext;
continue;
}
} else {
_lpMd = _lpMd->sutNext;
continue;
}
}
_lpMd = MEM_AREA.umLoint;
continue;
}
return NULL;
}
/******************************************************************/
 void __fastcall _mem_free(void * umAddr)
 {
if (umAddr != NULL) {
_mem_data * _lpMd = (_mem_data *)((unsigned char *)umAddr - sizeof(_mem_data));


if (_T == _lpMd->MA.ATB.umON) {
_lpMd->MA.ATB.umOF = _T;
_lpMd->MA.ATB.umON = _F;


if (_lpMd->MA.ATB.umCA = _T) {
MEM_AREA.umRize += _lpMd->umSize + sizeof(_mem_data);
} else {
MEM_AREA.umRize += _lpMd->umSize;
}
}
}
 }
/******************************************************************/
bool __fastcall _mem_set(void * umAddr,int uVal)
{
if (umAddr != NULL) {
_mem_data *_lpMd = (_mem_data *)((unsigned char *)umAddr - sizeof(_mem_data));


if (_T == _lpMd->MA.ATB.umON) {
return _memset(umAddr,uVal,_lpMd->umSize);
}
}
return false;
}
/******************************************************************/
bool __fastcall _mem_cpy(void * dmAddr,const void * smAddr)
{
if (dmAddr != NULL && smAddr != NULL) {
_mem_data *_lpMd = (_mem_data *)((unsigned char *)dmAddr - sizeof(_mem_data));
_mem_data *_lpMs = (_mem_data *)((unsigned char *)smAddr - sizeof(_mem_data));


if (_T == _lpMd->MA.ATB.umON && _T == _lpMs->MA.ATB.umON) {
return _memcpy(dmAddr,smAddr,_lpMd->umSize);
}
}
return false;
}
/******************************************************************/
bool __fastcall _mem_cmp(const void * dmAddr,const void * smAddr)
{
if (dmAddr != NULL && smAddr != NULL) {
_mem_data *_lpMd = (_mem_data *)((unsigned char *)dmAddr - sizeof(_mem_data));
_mem_data *_lpMs = (_mem_data *)((unsigned char *)smAddr - sizeof(_mem_data));


if (_T == _lpMd->MA.ATB.umON && _T == _lpMs->MA.ATB.umON) {
return _memcmp(dmAddr,smAddr,_lpMd->umSize);
}
}
return false;
}
/******************************************************************/
bool __fastcall _mem_xch(void * dmAddr,void * smAddr)
{
if (dmAddr != NULL && smAddr != NULL) {
_mem_data *_lpMd = (_mem_data *)((unsigned char *)dmAddr - sizeof(_mem_data));
_mem_data *_lpMs = (_mem_data *)((unsigned char *)smAddr - sizeof(_mem_data));


if (_T == _lpMd->MA.ATB.umON && _T == _lpMs->MA.ATB.umON) {
return _memxch(dmAddr,smAddr,_lpMd->umSize);
}
}
return false;
}
/******************************************************************/