memory.c

自己开发基于P2P通讯的网络服务器

/*********************************************************************
 * 模块名称:memory
 * 说明:内存管理模块
 * 其它说明: 
 * 作者: 刘青山 
 * 时间 : 2004-09-22 21:13:30 
*********************************************************************/
#include "natsvr.h"
#include "netcomm.h"
#include "memory.h"

#define		MEM_BLOCK_NUM	16	// 定义每个内存链表的正常个数

typedef struct tagMEMBLOCK
{
	struct list_head	listItem ;
	bool				bIsUsed ;
	void				*pbuf ;
}MEMBLOCK,*LPMEMBLOCK ;

typedef struct tagMEMINDEX
{
	struct list_head	listBusy ;	// 被占用的内存链表
	struct list_head	listFree ;	// 空闲的内存链表
	WORD				wBlocks ;	// 初始内存块数量
	WORD				wUsed ;		// 已经使用个数
	WORD				wSize ;		// 内存大小
	pthread_mutex_t		mtAddress;	// 内存互斥锁
}MEMINDEX,*LPMEMINDEX ;

static MEMINDEX   m_memIndex[M_END] = 
{
	{{NULL,NULL},{NULL,NULL},2000,0,sizeof(REQ_PACKET),PTHREAD_MUTEX_INITIALIZER },
	{{NULL,NULL},{NULL,NULL},2000,0,sizeof(P2P_USER),PTHREAD_MUTEX_INITIALIZER },
	{{NULL,NULL},{NULL,NULL},2000,0,sizeof(ANS_PACKET),PTHREAD_MUTEX_INITIALIZER },
};


void InitMemIndex()
{
/*
	int i,j ;
	for( i= 0; i< M_END; i++ )
	{
		INIT_LIST_HEAD( &m_memIndex[i].listBusy ) ;
		INIT_LIST_HEAD( &m_memIndex[i].listFree ) ;
		m_memIndex[i].wUsed = m_memIndex[i].wBlocks ;
		pthread_mutex_init(&m_memIndex[i].mtAddress, NULL);
		for( j=0 ;j< m_memIndex[i].wBlocks ; j++ )
		{
			LPMEMBLOCK	pBlock = (LPMEMBLOCK)malloc( sizeof(MEMBLOCK) );
			pBlock->bIsUsed = false; 
			pBlock->pbuf = malloc( m_memIndex[i].wSize );
			memset( pBlock->pbuf,0,m_memIndex[i].wSize );

			list_add( &pBlock->listItem,&m_memIndex[i].listFree ) ;
		}
	}
*/
}
void DestroyMem()
{
/*
	int i;
	struct list_head *pos ;

	for( i= 0; i< M_END; i++ )
	{
		pthread_mutex_lock(&m_memIndex[i].mtAddress );
		for( pos = m_memIndex[i].listFree.next ;pos != &m_memIndex[i].listFree; )
		{
			LPMEMBLOCK	pBlock = LIST_ENTRY( pos,MEMBLOCK,listItem) ;
			pos = pos->next ;
			free( pBlock->pbuf ) ;
			free( pBlock ) ;
		}
		list_empty(&m_memIndex[i].listFree);
		pthread_mutex_unlock(&m_memIndex[i].mtAddress);

		pthread_mutex_destroy(&m_memIndex[i].mtAddress);
	}
*/	
}

// clear the extra occupy memory
static void ClearExtraBlock( WORD wIndex )
{
/*
	LPMEMINDEX	pIndex ;
	struct list_head *pos ;
	
	pIndex = &m_memIndex[wIndex];
	for( pos = pIndex->listFree.next ;pos != &pIndex->listFree; )
	{
		LPMEMBLOCK	pBlock = LIST_ENTRY( pos,MEMBLOCK,listItem) ;
//		LogOut(KLOG_DEBUG, "ClearExtraBlock(),[%d]Free mem:0x%08x",wIndex,(void*)pBlock );
		pos = pos->next ;
		list_del( &pBlock->listItem );
		free( pBlock->pbuf ) ;
		free( pBlock ) ;
		pIndex->wUsed-- ;
		if ( pIndex->wUsed <= pIndex->wBlocks )
		{
			break;
		}
	}
*/
}

/*********************************************************************
 * 函数名称:Alloc
 * 说明:从内存链表里取得一个内存结点
 * 入口参数:
 *  WORD wIndex  -- 索引
 * 返回值:
 * void * -- 内存指针
 * 被本函数调用的函数清单: 
 * 调用本函数的函数清单: 
 * 其它说明: 
 * 作者: 刘青山 
 * 时间 : 2004-09-25 22:06:01 
*********************************************************************/
void *Alloc( WORD wIndex )
{
	void		*pAlloc = NULL ;

	LPMEMINDEX	pIndex;

//	struct list_head *pos ;
	
	if ( wIndex >= M_END )
	{
		DisplayInfo( "Alloc(), memory index error!!!!" );
		return NULL ;
	}
	pIndex = &m_memIndex[wIndex];

	pAlloc = malloc(pIndex->wSize);
	if (!pAlloc)
	{
		return NULL ;
	}
	memset(pAlloc, 0, pIndex->wSize);
	return pAlloc;
/*
	pthread_mutex_lock(&pIndex->mtAddress );
	if ( !list_empty( &pIndex->listFree ) )
	{
		pos = pIndex->listFree.next ; 
		LPMEMBLOCK	pBlock = LIST_ENTRY( pos,MEMBLOCK,listItem) ;
		pBlock->bIsUsed = true; 
		pAlloc = pBlock->pbuf ;
		memset( pBlock->pbuf,0,pIndex->wSize );
		list_del( &pBlock->listItem );
		list_add( &pBlock->listItem,&pIndex->listBusy ) ;
	}
	else
	{
		LPMEMBLOCK	pBlock = (LPMEMBLOCK)malloc( sizeof(MEMBLOCK) );
		if ( !pBlock )
		{
			pthread_mutex_unlock(&pIndex->mtAddress);
			return NULL ;
		}
		pBlock->pbuf = malloc( pIndex->wSize );
		if ( !pBlock->pbuf )
		{
			free( pBlock );
			pthread_mutex_unlock(&pIndex->mtAddress);
			return NULL ;
		}
		pBlock->bIsUsed = true; 

		memset( pBlock->pbuf,0,pIndex->wSize );
		list_add( &pBlock->listItem,&pIndex->listBusy ) ;
		
		pIndex->wUsed++ ; 
		pAlloc = pBlock->pbuf;
		LogOut(KLOG_DEBUG, "[%d]No enough memory list,allocate mem:0x%08x",wIndex,(void*)pBlock );
	}
	pthread_mutex_unlock(&pIndex->mtAddress);

//	LogOut(KLOG_DEBUG, "Alloc() ,mem:%08x",pAlloc);

	return pAlloc;*/
}
/*********************************************************************
 * 函数名称:Free
 * 说明:释放内存，这个函数把不使用的内存放回到内存链表，对超过预定值的内存结点释放内存
 * 入口参数:
 *  void *p -- 释放内存指针
 * WORD wIndex  -- 索引
 * 返回值:
 * void  -- 
 * 被本函数调用的函数清单: 
 * 调用本函数的函数清单: 
 * 其它说明: 
 * 作者: 刘青山 
 * 时间 : 2004-09-25 22:07:18 
*********************************************************************/
void Free( void *p,WORD wIndex )
{
	free(p);
/*
	LPMEMINDEX	pIndex ;
	struct list_head *pos ;
	
	if ( wIndex >= M_END )
	{
		DisplayInfo( "Free(), memory index error!!!!" );
		return ;
	}
	pIndex = &m_memIndex[wIndex];
	pthread_mutex_lock(&pIndex->mtAddress );
	LIST_FOR_EACH(pos,&pIndex->listBusy )
	{
		LPMEMBLOCK	pBlock = LIST_ENTRY( pos,MEMBLOCK,listItem) ;
		if ( p == pBlock->pbuf && pBlock->bIsUsed )
		{
//			LogOut(KLOG_DEBUG, "Free() ,mem:%08x",p );
			pBlock->bIsUsed = false ;
			
			list_del( &pBlock->listItem );
			list_add( &pBlock->listItem,&pIndex->listFree ) ;
			break;
		}
	}
	if ( pIndex->wUsed > pIndex->wBlocks )
	{
		ClearExtraBlock( wIndex );
	}
	pthread_mutex_unlock(&pIndex->mtAddress);
*/
}