arwinmemorypool_t.cpp

wangchuanDll.rar 网络传输的DLL 源代码

// ArWinMemoryPool_T.cpp: implementation of the ArWinMemoryPool_T class.
//
//////////////////////////////////////////////////////////////////////

#include "ArWinMemoryPool_T.h"
#include <stdio.h>
#include <process.h>

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

//---------------------------------------------------------------------

ArWinMemoryPool_T::ArWinMemoryPool_T(int iListNum ):m_iListNum(iListNum)
{
	m_MemSet[0].iInitialNum = 200;
    m_MemSet[0].iMemSize = 32;
	
    m_MemSet[1].iInitialNum = 200;
    m_MemSet[1].iMemSize = 64;
	
    m_MemSet[2].iInitialNum = 100;
    m_MemSet[2].iMemSize = 256;
	
    m_MemSet[3].iInitialNum = 50;
    m_MemSet[3].iMemSize = 4096;
	
    m_MemSet[4].iInitialNum = 20;
    m_MemSet[4].iMemSize = 300 * 1024;

	for(int i = 0; i < m_iListNum; i++)
	{
	    m_MemList[i] = new ArMemoryList_T(m_MemSet[i].iMemSize, m_MemSet[i].iInitialNum);

        ArBlockInfo_T Info;
        bool bResult = m_MemList[i]->FirstBlockInfo(Info);
        while(bResult)
        {
            m_MemTable.insert(std::make_pair(Info.pData, Info));
            bResult = m_MemList[i]->NextBlockInfo(Info);
        }
	}
    m_Event = ::CreateEvent(NULL, true, false, "Event_ArWinMemoryPool");

    ::InitializeCriticalSection(&m_csPoolAllocate);
	::InitializeCriticalSection(&m_csPoolFree);

}
//---------------------------------------------------------------------

ArWinMemoryPool_T::~ArWinMemoryPool_T()
{
	for(int i = 0; i < m_iListNum; i++)
	{
		delete m_MemList[i]; 
	}
    
    ::SetEvent(m_Event);
    ::CloseHandle(m_Event);

    ::DeleteCriticalSection(&m_csPoolAllocate);
	::DeleteCriticalSection(&m_csPoolFree);
}
//---------------------------------------------------------------------

bool    __stdcall ArWinMemoryPool_T::Destroy()
{
    unsigned int uiThreadID;
    _beginthreadex(NULL, 0, DestroyObj,(void*)this, 0, &uiThreadID);
    return true;
}

//---------------------------------------------------------------------------

unsigned int  __stdcall ArWinMemoryPool_T::DestroyObj(void* pParent)
{
     ArWinMemoryPool_T* pMemoryPool = (ArWinMemoryPool_T*)pParent;
     while(pMemoryPool->IsAllMemoryFree() == false)
     {
        Sleep(500);
     }
     delete pMemoryPool;
     return 0;
}

//---------------------------------------------------------------------

void*   __stdcall ArWinMemoryPool_T::Allocate(int iSize)
{
    int iIndex;

    EnterCriticalSection(&m_csPoolAllocate);
	if(FindRange(iSize, iIndex))
	{
        void* pAddress = m_MemList[iIndex]->Allocate();
        LeaveCriticalSection(&m_csPoolAllocate);
		return(pAddress);
	}
    LeaveCriticalSection(&m_csPoolAllocate);
	return NULL;
}
//---------------------------------------------------------------------

bool   __stdcall ArWinMemoryPool_T::Free(void* pData)
{
    std::map<void*, ArBlockInfo_T>::iterator MemPos;

    EnterCriticalSection(&m_csPoolFree);
    MemPos = m_MemTable.find(pData);
    if(MemPos == m_MemTable.end())
    {
        LeaveCriticalSection(&m_csPoolFree);
        return false;
    }

    ArMemoryBlock_T* pBock = MemPos->second.pBlockAddr;
    ArMemoryList_T* pList = MemPos->second.pList;
    pList->Free(pBock);
    LeaveCriticalSection(&m_csPoolFree);
	return true;
}
//---------------------------------------------------------------------

bool ArWinMemoryPool_T::FindRange(int iSize, int& index)
{
	for(int i = 0; i < m_iListNum; i++)
	{
		if(m_MemSet[i].iMemSize >= iSize)
		{
			index =  i;
			return true;
		}
	}
    return false;
}
//---------------------------------------------------------------------

bool    __stdcall ArWinMemoryPool_T::GetPoolInfo(ArMemoryPoolInfo_T& Info)
{
    Info.iMemoryListNum = m_iListNum;
    for(int i = 0; i < Info.iMemoryListNum; i++)
    {
        Info.ListInfo[i].iTotalNum = m_MemSet[i].iInitialNum;
        Info.ListInfo[i].iBlockSize = m_MemSet[i].iMemSize;
        Info.ListInfo[i].iUsedNum = m_MemList[i]->GetUsedNum();
        Info.ListInfo[i].iLeftNum = m_MemList[i]->GetLeftNum();   
        Info.ListInfo[i].iExpandTimes = m_MemList[i]->GetExpandTimes();
    }
    return true;
}
//---------------------------------------------------------------------

bool ArWinMemoryPool_T::IsAllMemoryFree(void)
{
    for(int i = 0; i < m_iListNum; i++)
    {
        int iTotalNum = m_MemList[i]->GetUsedNum() + m_MemList[i]->GetLeftNum();
        int iPermitNum = iTotalNum * 0.3;
        if(m_MemList[i]->GetUsedNum() > iPermitNum)
        {
            return false;
        }
    }
    return true;
}