一个可以复用的memory buffer 的设计和实现

本文意图在于设计一个高效的内存缓冲，可以复用，使用与高效日志系统，支持多线程并且不使用用户级别的锁即传说中的无锁编程。

基本想法：

方法1：

1、使用默认缓存5M

2、默认线程使用的内存为128K，即最多默认支持40个线程

3、初始化申请一块5M内存，然后进行分割，线程使用的定义为GROUP，没一条日志使用的为ITEM

4、运行过程中进行动态管理，内存用完后申请新的空间，一次为5M

5、线程使用完一个group后可以在使用其他的group，且不限在相同的原子buffer。

可能的问题在于，多次申请的问题，经过测试基本可以用。

方法2：

1、使用默认缓存5M

2、默认线程使用的内存为128K，即最多默认支持40个线程

3、初始化申请一块5M内存，然后进行分割，线程使用的定义为GROUP，没一条日志使用的为ITEM

4、运行过程中进行动态管理，内存用完后丢失

5、线程使用完一个group后可以在使用其他的group，且不限在相同的原子buffer。

可能的问题在于支持的线程是有上线的。

欢迎你的建议。下面是代码：

http://download.youkuaiyun.com/detail/flyingleo1981/6768083

common.h:

#include <Windows.h>
#include <intrin.h>


void>        {
            //_mm_pause(); // 这里可以优化以适应比较激烈的场合
            ::Sleep(1);
        }
    }


   >       >         {
           >   >        >        //printf("Group get read item will use the id %d.**************************\n", iTemp);
       >    }
   >    }
   >        {
           >       >         
       >        {
            Group *pGroup =>            {
               >           >             {
               >       >         {
            Item *ptmp =>            {
               >       >         
       >           >             return false;


       >         return true;
    }
    Item* GetWriteItem(unsigned>         if (-1 == iret)
        {
           >             it!=m_listAtomicBuffer.end(); it++)
        {
            Item *pit = (*it)->GetWriteItem(iThreadid);
           >             {
               >         if (NULL != pAtoBuf)
        {
           >             it!=m_listAtomicBuffer.end(); it++)
        {
           >             listGpPointers.push_back(pMapGp);
        }
       >         if (NULL == pAtoBuf)
        {
           >     {
       >         if (!Reserve(iSize))
        {
           >         {
           >        >

       >         for (int i=0; i<gpInAll; i++)
        {
           >             {
                Group *pGroup =>                 {
                   >                 iIDGroup++;
            }
           >         m_bIsBufWorking = true;
       >         //    return NULL;
       >         if (icount>0)
        {
            //printf("Thread %d>             for(IIT i=pairres.first; i!=pairres.second; i++)
            {
               >        >         {
            Item *ptmp =>             {
               >        >        >             m_mapGroup[iCurGp]->SetUsing(true);
           >             return m_mapGroup[iCurGp]->GetWriteItem();
        }

else
        {
           >                 return m_mapGroup[iCurGp]->GetWriteItem();
            }
           >     {
       >     }


   >             if (NULL != m_pBuffer)
            {
               >             }
           >             }


           >             {
               >             m_iCurrentBufferSize = iSize;
        }


       >     __int64 qwUserTimeElapsed = FileTimeToQuadWord(&ftUserTimeEnd) - FileTimeToQuadWord(&ftUserTimeStart);


    // Get>         //printf("Sned len = %d, \n",ilen);
       >         if (0 != WSAStartup(dwSockVersion,&wSaData)) //协商版本号   
        {  
           >         if (INVALID_SOCKET == nSocket)
        {  
           >         sa.sin_addr.s_addr = inet_addr("127.0.0.1");  
       >         if ( 0 != connect( nSocket,( const SOCKADDR * )&sa, sizeof(sa) ) )  
           >         char tmp[MAX_BUF_SIZE] = {0};  
       >         nRecv = recv(nSocket, buf, MAX_BUF_SIZE, 0);  
       > int g_icount = 0;


int MakeData(char *pch)
{
   >     memset(pch, 'w', iLen);
   >         std::list< std::map<unsigned int, Group*>* >::iterator it = ltGpPointers.begin();
       >         {
           >             {
               >                 for (; iit!=(*it)->end(); iit++)

{
                    //printf("Thr>                     Item *pit = iit->second->GetReadItem();
                   >         unsigned int iMaxUsingID = g_atoRealloctionBug.GetMaxUnsingGroupID();
       >         if (NULL == ltGpPointers)
        {
           >         for (; iit!=ltGpPointers->end(); iit++)

{
            //printf("Thr>             Item *pit = iit->second->GetReadItem();
           >

   >     int ik = 0;
   >     {
       >         {
            CThreadTime ElapsedTime;
            ElapsedTime.BeginGetElapsedTime();
            Item *pIm =>                 char *pch = pIm->GetItemPointer();
               >                     ik++;
                }
               >             if (iElapse>10)
            {
               >

   >     int ik = 0;
   >     {
       >         {
            CThreadTime ElapsedTime;
            ElapsedTime.BeginGetElapsedTime();
            Item *pIm =>                 char *pch = pIm->GetItemPointer();
               >                     ik++;
                }
               >             if (iElapse>10)
            {
               >         //{
        //    CThreadTime ElapsedTime;
        //    ElapsedTime.BeginGetElapsedTime();
        //    int>         //    //char *pcharbig = new char[iData];
        //    char*>         //    int iElapse = ElapsedTime.EndGetElapsedTime();
        //    printf("new 100M>     if(!bSet) printf("Set priority class called failed.\n");


   >     if (b_using_nonbocking_buffer)
    {
       >         if (!bret)
        {
           >         unsigned   threadID = 0;
        //   Create  >         //    ::Sleep(3000);


       >         {
            HANDLE  >             unsigned   threadID = 0;
            //   Create  >         }
    }

 else
    {
        if (!g_atoRealloctionBug.InitBuffer())
        {
            printf("Init alloction buf failed.\n");
        }
        
        HANDLE  >         unsigned   threadID = 0;
        //   Create  >         //    ::Sleep(3000);


       >         {
            HANDLE  >             unsigned   threadID = 0;
            //   Create  >         }
    }

 printf("init>         {
            ::Sleep(5000);
           >             break;
        }
        ::Sleep(1000);
    }


    printf("runing over will exit.\n");
    system("pause");


}