bheap_new.c

深圳市微逻辑电子有限公司 巨果&#8226 Kingmos&reg 系统核心

				lpbh->nFreeBlockCount = nRealCount;
			}

			InitializeCriticalSection( &lpbh->cs );
			return lpbh->hThis;	
		}
		else
		{
			HeapFree( hProcessHeap, 0, lpbh );
		}
	}
	return NULL;
}

BOOL WINAPI BlockHeap_Destroy( HANDLE handle )
{
	LPBLOCK_HEAP lpbh = (LPBLOCK_HEAP)HANDLE_TO_PTR( handle );
	BOOL bRetv = FALSE;

	if( lpbh && lpbh->hThis == handle )
	{
//		LPUINT lpList; 
		HANDLE hProcessHeap;

		EnterCriticalSection( &lpbh->cs );

#ifdef __DEBUG
		// check
		{
			int i;
			LPBLOCK_DATA lpblk = lpbh->lpBlock;
		    for( i = 0; i < lpbh->nAllocBlockCount; i++, lpblk++ )
			{
				WARNMSG( lpblk->nCount, ( "error in BlockHeap_Destroy: not all block(%d) is freed, block size(%d).\r\n", lpblk->nCount, lpblk->wBlockSize ) );
			}
		}
#endif
		hProcessHeap = lpbh->hProcessHeap;

	//	lpList = lpbh->lpAllocList; 
	//	while( lpList )
	//	{
	//		LPUINT lpNext = *(LPUINT*)lpList;
	//		HeapFree( hProcessHeap, 0, lpList );
	//		lpList = lpNext;
	//	}
		lpbh->hThis = NULL;
		HeapFree( hProcessHeap, 0, lpbh->lpBlock );
		HeapFree( hProcessHeap, 0, lpbh );
		//return TRUE;
		bRetv = TRUE;

	    LeaveCriticalSection( &lpbh->cs );
	    DeleteCriticalSection( &lpbh->cs );
	}

	return FALSE;
}

static LPVOID DoBlockHeapAlloc( HANDLE handle, UINT uiFlags, UINT uiSize )
{
	LPBLOCK_HEAP lpbh = (LPBLOCK_HEAP)HANDLE_TO_PTR( handle );
	void * lpRet = NULL;


    uiSize = ALIGN_SIZE( uiSize );
	if( lpbh && lpbh->hThis == handle )
	{
		LPBLOCK_DATA lpblk;

		if( !(uiFlags & BLOCKHEAP_NO_SERIALIZE) )
		{
			EnterCriticalSection( &lpbh->cs );
		}

		
		lpblk = BlockHeap_GetPtr( lpbh, uiSize );

		ASSERT( lpblk );
		//INTR_OFF();
		if( lpblk )
		{

			REMOVE_FREE_BLOCK( lpblk, lpRet );

			if( lpRet == NULL )
			{
				if( (lpRet = BlockHeap_Increase( lpbh, uiFlags, lpblk->wBlockSize )) )
				{
					;//KL_InterlockedIncrement( &lpHeap->iMaxBlocks );
				}
				else
				{	//失败
					goto _ret;//return NULL;
				}
			}
			//KL_InterlockedIncrement( &lpHeap->iUsed );//2003-06-04, DEL
			
			if( uiFlags & BLOCKHEAP_ZERO_MEMORY )
				memset( lpRet, 0, uiSize );
			else
			{

#ifdef __DEBUG
				memset( lpRet, 0xCCCCCCCC, uiSize );
#endif
			}
#ifdef __DEBUG
			lpblk->nCount++;
#endif
			
		}
_ret:		
		if( !(uiFlags & BLOCKHEAP_NO_SERIALIZE) )
		{
			LeaveCriticalSection( &lpbh->cs );
		}
		
		//INTR_ON();
	}

	return lpRet;
	
}

LPVOID WINAPI BlockHeap_Alloc( HANDLE handle, UINT uiFlags, UINT uiSize )
{
	LPBYTE lpui;

	if( uiFlags & BLOCKHEAP_RESIZABLE )
	    uiSize += 4;
	lpui = DoBlockHeapAlloc( handle, uiFlags, uiSize );
	if( lpui )
	{
		if( uiFlags & BLOCKHEAP_RESIZABLE )
		{
		    *( (LPUINT)lpui ) = uiSize;
		    lpui += 4;
		}
	}
	else
	{
		RETAILMSG( 1, ( "error in BlockHeap_Alloc: not alloc a block, handle(0x%x),uiFlags(0x%x),uiSize(%d)", handle,uiFlags,uiSize ) );
	}
	return lpui;
}

static BOOL DoBlockHeapFree( HANDLE handle, UINT uiFlags, LPVOID lpvBlock, UINT uiSize )
{
	LPBLOCK_HEAP lpbh = (LPBLOCK_HEAP)HANDLE_TO_PTR( handle );
	BOOL bRetv = FALSE;
	
    uiSize = ALIGN_SIZE( uiSize );
	if( lpbh && lpbh->hThis == handle && lpvBlock )
	{	
		LPBLOCK_DATA lpblk;
		if( !(uiFlags & BLOCKHEAP_NO_SERIALIZE) )
		{
			EnterCriticalSection( &lpbh->cs );
		}

		lpblk = BlockHeap_GetPtr( lpbh, uiSize );
		ASSERT( lpblk );
		if( lpblk )
		{
			
			INSERT_FREE_BLOCK( lpblk, lpvBlock );
			
			
#ifdef __DEBUG
			// test code
			if( lpblk->nCount <= 0 )
			{
				lpblk->nCount = lpblk->nCount;
			}
			//
			ASSERT( lpblk->nCount > 0 );
		    lpblk->nCount--;
#endif
			bRetv = TRUE;
			//return TRUE;
		}
		if( !(uiFlags & BLOCKHEAP_NO_SERIALIZE) )
		{
			LeaveCriticalSection( &lpbh->cs );
		}
	}
	return bRetv;
}

BOOL WINAPI BlockHeap_Free( HANDLE handle, UINT uiFlags, LPVOID lpvBlock, UINT uiSize  )
{
	if( lpvBlock )
	{
		if( uiFlags & BLOCKHEAP_RESIZABLE )
		{	        
		    lpvBlock = (LPBYTE)lpvBlock - 4;
		    uiSize = *((LPUINT)lpvBlock); 
		}
	    return DoBlockHeapFree( handle, uiFlags, lpvBlock, uiSize );
	}
	else
	{
		WARNMSG( 1, ( "error in BlockHeap_Free: null ptr.\r\n" ) );
		return FALSE;
	}
}

static HANDLE hDefBlockHeap = NULL;
//BOOL WINAPI BLK_Create( VOID )
//{
//	if( hDefBlockHeap == NULL )
//	    hDefBlockHeap = BlockHeap_Create( NULL, NULL );
//	return (hDefBlockHeap != NULL);
//}

//初始化/创建块堆
BOOL WINAPI BLK_Create( VOID )
{
	if( hDefBlockHeap == NULL )
		hDefBlockHeap = BlockHeap_Create( NULL, NULL );
	return hDefBlockHeap != 0;
}

//破坏/释放块堆
BOOL WINAPI BLK_Destroy( VOID )
{
	if( hDefBlockHeap )
	{
		BlockHeap_Destroy( hDefBlockHeap );
		hDefBlockHeap = NULL;
	}
	return TRUE;
}

//从块堆分配一个块
LPVOID WINAPI BLK_Alloc( UINT uiFlags, UINT uiSize )
{
	//if( hDefBlockHeap == NULL )
//		hDefBlockHeap = BlockHeap_Create( NULL, NULL );

	if( hDefBlockHeap )
		return BlockHeap_Alloc( hDefBlockHeap, uiFlags, uiSize );
	else
		return NULL;
}

//释放一个块
BOOL WINAPI BLK_Free( UINT uiFlags, LPVOID lpvBlock, UINT uiSize )
{
	if( hDefBlockHeap )
		return BlockHeap_Free( hDefBlockHeap, uiFlags, lpvBlock, uiSize );
	else
		return FALSE;
}


/*
LPVOID WINAPI BlockHeap_AllocString( HANDLE handle, UINT uiFlags, UINT uiSize )
{
    UINT * p;

	uiSize += sizeof( UINT );
	
	p = (UINT*)DoBlockHeapAlloc( handle, uiFlags, uiSize );
	if( p )
	{
		*p = uiSize;
		p++;
	}
	return p;
}

BOOL WINAPI BlockHeap_FreeString( HANDLE handle, UINT uiFlags, LPVOID lpv )
{
	if( lpv )
	{
		UINT * p = (UINT*)lpv - 1;
		if( *p )
		{
			return DoBlockHeapFree( handle, uiFlags, p, *p );
		}
	}
	return FALSE;
}
*/



// 这是一个测试函数
#ifdef TEST_BLOCKHEAP
void TestBlockHeap( void )
{
	int bContinue = 1;
	int nsocket;

	int nFreeCount = 0;
	int nAllocCount = 0;
	int i;


	LPBYTE lpv[20];
	UINT   id[20];
    HANDLE hHeap;
	UINT uiSize[] = { 64, 12, 5, 15, 18, 34, 78, 280, 320, 5, 400 }; 
	
	i = 0;
	
//    KHeap_InitBlockHeap();
	memset( id, 0xffffffff, sizeof( id ) );
	
	hHeap = BlockHeap_Create( uiSize, sizeof(uiSize) / sizeof( UINT ) );

	while( bContinue )
	{
		if( (rand() % 20) <= 9 )
		{   //alloc
			nsocket = rand() % 20;

			if( id[nsocket] == -1 )
			{
				int size = rand() % 500;

				lpv[nsocket] = BlockHeap_Alloc( hHeap, 0, size );
				
			    id[nsocket] = size;
			    if( lpv[nsocket] )
				    memset( lpv[nsocket], nsocket, size );
				nAllocCount++;				
			}
		}
		else
		{   // free
			if( rand() % 500 == 0 )
			{  // free all
				int n;
				for( n = 0; n < 20; n++ )
				{
					if( id[n] != -1 )
					{
						BlockHeap_Free( hHeap, 0, lpv[n], id[n] );
						id[n] = -1;
					}
				}
			}
			else
			{
				nsocket = rand() % 20;
				if( id[nsocket] != -1 )
				{
					BlockHeap_Free( hHeap, 0, lpv[nsocket], id[nsocket] );
					id[nsocket] = -1;
					nFreeCount++;
				}
			}
		}
		i++;
	}
	BlockHeap_Destroy( hHeap );

}
#endif