一个c++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。 可能的问题在于支持的线程是有上线的。 欢迎你的建议。

#include 
#include 
#include 

#include “NonLockingBuffer.h“

#define  PORT_NUMBER 9998

#define GROUP_ITEM_COUNT 128
#define THREAD_RUN_LOOP_TIMES 60
#define MAX_THREAD_COUNT_NUMBER 40


class CThreadTime
{
public:    
    void    BeginGetElapsedTime（）;
    __int64 EndGetElapsedTime（）;

private:
    __int64 FileTimeToQuadWord（PFILETIME pft）;

private:
    FILETIME ftKernelTimeStart;
    FILETIME ftKernelTimeEnd;
    FILETIME ftUserTimeStart;
    FILETIME ftUserTimeEnd;
    FILETIME ftDummy;
};

// Get the time elapsed since the thread start
inline void CThreadTime::BeginGetElapsedTime（）
{
    GetThreadTimes（GetCurrentThread（） &ftDummy &ftDummy &ftKernelTimeStart &ftUserTimeStart）;
}

// Calculate the time elapsed 
inline __int64 CThreadTime::EndGetElapsedTime（）
{
    GetThreadTimes（GetCurrentThread（） &ftDummy &ftDummy &ftKernelTimeEnd &ftUserTimeEnd）;

    __int64 qwKernelTimeElapsed = FileTimeToQuadWord（&ftKernelTimeEnd） - FileTimeToQuadWord（&ftKernelTimeStart）;
    __int64 qwUserTimeElapsed = FileTimeToQuadWord（&ftUserTimeEnd） - FileTimeToQuadWord（&ftUserTimeStart）;

    // Get total time duration by adding the kernel and user times.
    // the default is 100ns so we convert it to ms
    //return （qwKernelTimeElapsed + qwUserTimeElapsed） / 10000;

    return （qwKernelTimeElapsed + qwUserTimeElapsed） / 10;
}

inline __int64 CThreadTime::FileTimeToQuadWord（PFILETIME pft） 
{
    return （Int64ShllMod32（pft->dwHighDateTime 32） | pft->dwLowDateTime）;
}


class CStopwatch 
{
public:
    CStopwatch（） 
    { 
        QueryPerformanceFrequency（&m_liPerfFreq）;
        Start（）;
    }

    void Start（） 
    { 
        QueryPerformanceCounter（&m_liPerfStart）;
    }

    __int64 Now（） const 
    {
        //Returns # of milliseconds since
        //Start was called

        LARGE_INTEGER liPerfNow;
        QueryPerformanceCounter（&liPerfNow）;

        return （（（liPerfNow.QuadPart - 
            m_liPerfStart.QuadPart） * 1000）/
            m_liPerfFreq.QuadPart）;
    }

private:

    //Counts per second
    LARGE_INTEGER m_liPerfFreq;   

    //Starting count
    LARGE_INTEGER m_liPerfStart;  
};

// 2
//CThreadTime ElapsedTime;
//ElapsedTime.BeginGetElapsedTime（）;

// 4
//CStopwatch spWatch;

// do ................

//2
//int iElapse = ElapsedTime.EndGetElapsedTime（）;

//4
//__int64 iElapse = spWatch.Now（）;


class WriteLogToFile
{
public:
    WriteLogToFile（）
        : outfile（“d:\\log\\log.txt“ std::ofstream::binary | std::ofstream::app）
    {

    }

    virtual void Handle（Item* entry）
    {
        outfile.write （entry->GetItemPointer（） entry->GetDataLen（））;
        outfile.flush（）;
        entry->SetDataSign（false）;

        //printf（“entry size %d\n“entry->Size（））;
    }

    ~WriteLogToFile（）
    {
        outfile.close（）;
    }
private:
    std::ofstream outfile;
};

class 

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----
     文件        2422  2013-12-25 14:00  Common.h
     文件       12743  2013-12-25 16:11  NonLockingBuffer.cpp
     文件       13666  2013-12-25 14:46  NonLockingBuffer.h
     文件        4128  2013-12-23 11:21  NonLockingBuffer.vcproj
     文件        1369  2013-12-23 10:32  SpinLock - 副本.h