mem_man.c

实现在ARM上的ICP/IP功能的源代码。

#include "debug.h"
#include "true_false.h"
#include "typedef.h"
#include "mem_man.h"
#include "stdlib.h"
static u8_t   TCPIPBuf[TCPIP_BUF_SIZE];
static struct SMemHead    *    MemHeadEnd;	/* end of the chain */
static struct SMemHead    *   MemHeadStart;
static u32_t  FreeSize;	/* free memsize can use */
static u8_t show[]={"-==www.openmcu.com==-"};
void MemInit()   
{
	u32_t i;
	for(i=0;i<TCPIP_BUF_SIZE;++i)
	TCPIPBuf[i]='?';//show[i%sizeof(show)];//('a'+i%26);
	MemHeadEnd = (struct SMemHead   *)(TCPIPBuf + TCPIP_BUF_SIZE);
	MemHeadStart = (struct SMemHead   *)TCPIPBuf;
	/* at inital there is only a buf block. value in
	mem head is as following */
	MemHeadStart->pNext = MemHeadEnd;
	MemHeadStart->pPre  = MemHeadStart;
	MemHeadStart->used = FALSE;
	FreeSize = TCPIP_BUF_SIZE - sizeof(struct SMemHead);
}

/* allocate a buffer size of size, and set pStart to the start of buffer,pEnd
to end of buffer.Also decrease FreeSize. */
struct SMemHead   *MemAllocate(u16_t size) 
/*we first adjust len to 4byte and then we substant it in the MemHead->pEnd 
and store it to MemHead->pad_len for functions of fre  */   
{
	struct SMemHead   *MemHead;
	struct SMemHead   *NewMemHead;
	u32_t pad;
	u16_t MemPlayloadSize;
	pad=4-size%4;
	size+=pad;
	/* search though the mem blocks */
	for(MemHead = MemHeadStart; MemHead != MemHeadEnd; MemHead = MemHead->pNext)
	{
		/* if unused and mem playload size > size, select it. */
		if(MemHead->used == FALSE && 
			(MemPlayloadSize = (u8_t*)(MemHead->pNext) - (u8_t*)MemHead - sizeof(struct SMemHead)) >= size)
		{
			/* if MemPalyloadSize - size > sizeof(struct SMemHead) create
			a new SMemHead at the excess memory leaving for later usage */
			if(MemPlayloadSize - size> sizeof(struct SMemHead))
			{
				NewMemHead = (struct SMemHead   *)((u8_t   *)MemHead + sizeof(struct SMemHead)+ size );

				/* link into link chain */
				NewMemHead->pNext = MemHead->pNext;
				MemHead->pNext    = NewMemHead;
				NewMemHead->pPre  = MemHead;
				if(NewMemHead->pNext != MemHeadEnd)
				{
					NewMemHead->pNext->pPre = NewMemHead;
				}
				
				/* set new mem as unused */
				NewMemHead->used = FALSE;

				/* decrease FreeSize: playload of MemHead and the head of NewMemHead */
				FreeSize -= (u8_t   *)(MemHead->pNext) - (u8_t   *)MemHead;
			}
			else
			{
				/* decrease: playload of MemHead */
				FreeSize -= (u8_t   *)(MemHead->pNext) - (u8_t   *)MemHead - sizeof(struct SMemHead);
			}


			/* set pStart */
			MemHead->pStart = (u8_t   *)MemHead + sizeof(struct SMemHead);

			MemHead->pEnd	= MemHead->pStart + size ;
			
			MemHead->pEnd  -= pad;
			
			MemHead->pad_len=pad;
			/*just as saying before we decline  
			the pEnd and store pad to MemHead->pad_len*/
			/* set as used */
			MemHead->used = TRUE;

			return MemHead;
		}
	}
	return NULL;
}

void MemFree(struct SMemHead   * MemHead)    
{
	struct SMemHead   * MemHeadMergePre;
	struct SMemHead   * MemHeadMergeNext;

	/* set used flag to false */
	MemHead->used = FALSE;
	
	MemHead->pEnd +=MemHead->pad_len;
	/*we first add the adjust len and the function below does not changed!*/

	/* inc FreeSize the size of playload of 'MemHead'*/
	FreeSize += (u8_t   *)(MemHead->pNext) - (u8_t   *)MemHead - sizeof(struct SMemHead);

	/* 
	 * if pNext or pPre is a unused memblock, merge with it 
	 */

	/* find the two MemHead going to merge */
	if(MemHead->pPre->used == FALSE)
	{
		MemHeadMergePre = MemHead->pPre;	/* note: if MemHead == TCPBuf, MemHead->pPre == MemHead, but it is not a problom */
	}
	else
	{
		MemHeadMergePre = MemHead;
	}
	if(MemHead->pNext != MemHeadEnd && MemHead->pNext->used == FALSE)
	{
		MemHeadMergeNext = MemHead->pNext;	

		/* MemHead of 'MemHead->pNext' will be free. Free size inc*/
		FreeSize += sizeof(struct SMemHead);
	}
	else
	{
		MemHeadMergeNext = MemHead;
	}

	/* merge is necessary? */
	if(MemHeadMergePre != MemHeadMergeNext)
	{
		/* merge. that is del MemHeadMergeNext from the chain */
		MemHeadMergePre->pNext = MemHeadMergeNext->pNext;
		if(MemHeadMergeNext->pNext != MemHeadEnd)
			MemHeadMergeNext->pNext->pPre = MemHeadMergePre;

		/* will MemHead of 'MemHead' will be free? */
		if(MemHead != MemHeadMergePre)
			FreeSize += sizeof(struct SMemHead);
		
	}
}

u32_t MemFreeSize()   
{
	return FreeSize;
}