内存检测与缓存，C语言

#include <malloc.h>
#include "stdlib.h"


#define memory_monitor 1
#if memory_monitor
#define memory_monitor_size 160*1024*1024
#define memory_array_length 1000
typedef struct _memory_link{
void *p;
int s;
struct _memory_link *prev;
struct _memory_link *next;
}memory_link;


int gArraySize;
typedef struct _memory_link_arr{
memory_link arr[memory_array_length];
struct _memory_link_arr *next;
}memory_link_arr;


memory_link_arr *pmaHead=0;
memory_link *pmHead=0, *pmTail=0, *pmPrev=0, *pmNode=0, *pmNext=0;
memory_link *ptHead=0;
int gmSize=0;




#define printf_t(format, ...) {printf("%d, %s\n", __LINE__, __FILE__); printf(format, ## __VA_ARGS__); printf("\n");}
memory_link *GetMemoryNode()
{
memory_link *p=0;


if (ptHead)
{
p=ptHead;
ptHead=ptHead->next;
}
else
{
memory_link_arr *pNode=malloc(sizeof(memory_link_arr));
gArraySize+=sizeof(memory_link_arr);
if (pNode)
{
int i=0;


ptHead=&pNode->arr[i];
for (; i<memory_array_length-1; i++)
{
pNode->arr[i].next=&pNode->arr[i+1];
}
pNode->arr[i+1].next=0;
pNode->next=pmaHead;
pmaHead=pNode;
p=ptHead;
ptHead=ptHead->next;
}
else
{
printf_t("error");
}
}
return p;
}


void AddMemoryNode(memory_link *pNode)
{
pNode->next=ptHead;
ptHead=pNode;
}


void DeleteMemoryNode()
{
memory_link_arr *p=pmaHead;


while(p)
{
pmaHead=pmaHead->next;
free(p);
p=pmaHead;
}
ptHead=0;
}
#endif


void * DMC_malloc(int s)
{
void * lp=0;


#if memory_monitor
if (gmSize+s>memory_monitor_size)
{
printf_t("%d", s);
return 0;
}
#endif


if(s<1)
{
return 0;
printf_t("%d", s);
}


lp = malloc(s);
if (!lp)
{
printf_t("%d", s);
}
#if memory_monitor
else
{
pmNode=GetMemoryNode();
memset(pmNode, 0, sizeof(memory_link));
pmNode->p=lp;
pmNode->s=s;
gmSize+=s;
if (pmTail)
{
pmNode->prev=pmTail;
pmTail->next=pmNode;
pmTail=pmNode;
}
else
{
pmHead=pmNode;
pmTail=pmNode;
}
}
#endif

return lp;
}


void  DMC_free(void * lp)
{


if(lp)
{
#if memory_monitor
pmNode=pmTail;
while(pmNode)
{
if (lp==pmNode->p)
{
gmSize-=pmNode->s;
pmPrev=pmNode->prev;
pmNext=pmNode->next;
if (pmPrev)
{
if (pmNext)
{
pmPrev->next=pmNext;
pmNext->prev=pmPrev;
}
else
{
pmPrev->next=0;
pmTail=pmPrev;
}
}
else
{
if (pmNext)
{
pmNext->prev=0;
pmHead=pmNext;
}
else
{
pmHead=0;
pmTail=0;
}
}
AddMemoryNode(pmNode);
break;
}
pmNode=pmNode->prev;

}
#endif
free(lp);
}
}


void * DMC_realloc(void * lp, int s)
{
#if memory_monitor
if (gmSize+s>memory_monitor_size)
{
printf_t("%d", s);
return 0;
}
#endif
if(s<1)
{
return 0;
printf_t("%d", s);
}
if (lp==0)
{
lp = malloc(s);
}
else
{
#if memory_monitor
pmNode=pmTail;
while(pmNode)
{
if (lp==pmNode->p)
{
gmSize-=pmNode->s;
pmPrev=pmNode->prev;
pmNext=pmNode->next;
if (pmPrev)
{
if (pmNext)
{
pmPrev->next=pmNext;
pmNext->prev=pmPrev;
}
else
{
pmPrev->next=0;
pmTail=pmPrev;
}
}
else
{
if (pmNext)
{
pmNext->prev=0;
pmHead=pmNext;
}
else
{
pmHead=0;
pmTail=0;
}
}
AddMemoryNode(pmNode);
break;
}
pmNode=pmNode->prev;


}
#endif
lp = realloc(lp, s);
}
if (!lp)
{
printf_t("%d", s);
}
#if memory_monitor
else
{
pmNode=GetMemoryNode();
memset(pmNode, 0, sizeof(memory_link));
pmNode->p=lp;
pmNode->s=s;
gmSize+=s;
if (pmTail)
{
pmNode->prev=pmTail;
pmTail->next=pmNode;
pmTail=pmNode;
}
else
{
pmHead=pmNode;
pmTail=pmNode;
}
}
#endif
return lp;
}


void * DMC_calloc(int n, int s)
{


void * lp=0;
if(s<1 || n<1)
{
return 0;
printf_t("%d", s);
}
#if memory_monitor
if (gmSize+s>memory_monitor_size)
{
printf_t("%d", s);
return 0;
}
#endif
lp = calloc(n, s);


if (!lp)
{
printf_t("%d", s*n);
}
#if memory_monitor
else
{
pmNode=GetMemoryNode();
memset(pmNode, 0, sizeof(memory_link));
pmNode->p=lp;
pmNode->s=s*n;
gmSize+=s*n;
if (pmTail)
{
pmNode->prev=pmTail;
pmTail->next=pmNode;
pmTail=pmNode;
}
else
{
pmHead=pmNode;
pmTail=pmNode;
}
}
#endif
return lp;
}