CircleBuf

 

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include "Semaphore.h"
#include "Mutex.h"

class CCircleBuf
{
public:
CCircleBuf()
{
m_state = false;
}
~CCircleBuf()
{

}
public:
int    Initial(int size)
{
if (m_state == true)
{
printf("it's already initial!\n");
return -1;
}    
if(size & (size -1))
{
printf("buffer size must be 2 Power\n");
return -1;
}
m_size = size;
m_in = m_out = 0;
m_buf = new unsigned char[size];
memset(m_buf, 0 , sizeof(size));
m_mutex.Create();
m_state = true;
return 0;
}
int Destroy()
{
return 0;
}
unsigned short fifo_read(char *buf,unsigned short len)
{
m_mutex.lock();
unsigned short node_len = 0;
if (0 == GetUsedlen())
{
printf("********** there is no data to read!\r\n");
m_mutex.unlock();
}
//读取数据长度
if (0 == Read((char*)&node_len, sizeof(node_len)))
{
printf("********** get node_len faild!\r\n");
m_mutex.unlock();
return 0;
}    
//读取数据内容
if (len < node_len)
{
printf("********** buf size is small!\r\n");
m_mutex.unlock();
return 0;
}

if (0 == Read( buf, node_len))
{
printf("********** get node_content faild!\r\n");
m_mutex.unlock();
return 0;
}    
//优化，如果数据读取完毕则重置m_in，m_out
if (0 == GetUsedlen())
{
m_in = m_out = 0;
}    
m_mutex.unlock();
return len; 
}
unsigned short fifo_write(char *buf,unsigned short len)
{
m_mutex.lock();
if (GetUsedlen() + sizeof(len) + len > m_size)
{
printf("********** the room of buf is full!\r\n");
m_mutex.unlock();
return 0;
}    
//写入文件长度
Write((char*)&len,sizeof(len));
//写入数据内容
Write(buf,len);
m_mutex.unlock();
return len;
}
protected:
unsigned short Read(char *buf,unsigned short len)
{
//获取使用空间大小    
unsigned short used_size = GetUsedlen();
len = min(len,used_size);
unsigned short lelf = min(len,m_size - m_out &(m_size -1));
memcpy(buf,m_buf + (m_out & (m_size -1)),lelf);
memcpy(buf + lelf ,m_buf, len - lelf);
m_out += len;
return len; 
}
unsigned short Write(char *buf,unsigned short len)
{
//获取使用空间大小    
unsigned short used_size = GetUsedlen();
len = min(len , m_size - used_size);
unsigned short lelf = min(len, m_size - (m_in &(m_size - 1)));
memcpy(m_buf + (m_in &(m_size - 1)), buf, lelf);
memcpy(m_buf, buf + lelf, len -lelf);
m_in += len;
return len;
}
unsigned short GetUsedlen()
{
return m_in - m_out;
}
private:
bool    m_state;
unsigned char    *m_buf;
unsigned short    m_size;
unsigned short    m_in;
unsigned short    m_out;
Tools::Mutex    m_mutex;
};


DWORD WINAPI ThreadRead(LPVOID lparam)
{
char temp[1024] = {'\0'};
char buf[128] = {'\0'};
while(1)
{
memset(temp, 0 , sizeof(temp));
memset(buf, 0 , sizeof(buf));
if (gCircleBuf.fifo_read(buf,sizeof(buf)) > 0 )
{
sprintf(temp,"read data:%s\r\n",buf);
OutputDebugString(temp);
}
Sleep(1*1000);
}
return 0;
}


DWORD WINAPI ThreadWrite(LPVOID lparam)
{
srand(time(NULL));
while (1)
{
char buf[128] = {'\0'};
sprintf(buf,"(%d)",rand());
gCircleBuf.fifo_write(buf,strlen(buf));
Sleep(1*1000);
}
return 0;
}

 

int main()
{

gCircleBuf.Initial(1024);
char *temp = new char[128];
unsigned short tt = 65535*2;
unsigned short t1 = 65527;
unsigned short t2 = 915;
unsigned short t3 = 11;
unsigned short t = min(t3,(t2-t1));
unsigned short offset = t2 - t1;
HANDLE hTread1 = ::CreateThread(NULL, 0 , ThreadRead, NULL, 0 , NULL);
HANDLE hTread2 = ::CreateThread(NULL, 0 , ThreadWrite, NULL, 0 , NULL);
CloseHandle(hTread1);
CloseHandle(hTread2);
system("Pause");
return 0;
}

#pragma once
#include <windows.h>
namespace Tools
{

    class Semaphore
    {
    public:
        HANDLE    m_handle; 
        bool    m_state;
    public:
        Semaphore():m_state(false),m_handle(NULL){}
        ~Semaphore(){
            Destroy();
        }
        int Create(unsigned short nInitialCount = 0, unsigned short nMaximumCount = 0xffff)
        {
            if (!m_state)
            {
                m_state = true;

                if (nInitialCount > nMaximumCount)
                {
                    printf("param error!\r\n");
                    return -1;
                }
                m_handle = CreateSemaphore(NULL, nInitialCount, nMaximumCount, NULL );
                if (NULL == m_handle)
                {
                    printf("[%s %d] GetLastError:%d\r\n",__FUNCTION__,__LINE__,GetLastError());
                    return -1;
                }
                return 0;
            }
            return -1;
        }
        int Destroy()
        {
            if (m_state)
            {
                CloseHandle(m_handle);
                m_handle = NULL;
                m_state = false;
                return 0;
            }
            return -1;
        }
        int Signal()
        {
            if (m_state)
            {
                if (NULL == ReleaseSemaphore(m_handle,1,NULL))
                {
                    printf("[%s %d] GetLastError:%d\r\n",__FUNCTION__,__LINE__,GetLastError());
                    return -1;
                }
                return 0;
            }
            return -1;
        }
        int Wait()
        {
            if (m_state)
            {
                return Wait(INFINITE);
            }
            return -1;
        }
        int Wait(DWORD dwTime)
        {
            if (m_state)
            {
                int ret = WaitForSingleObject(m_handle,dwTime);
                if (WAIT_TIMEOUT == ret)
                {
                    return -1;
                }
                else if (WAIT_OBJECT_0 == ret)
                {
                    return 0;
                }
                else
                {
                    printf("[%s %d] GetLastError:%d,ret:%d\r\n",__FUNCTION__,__LINE__,GetLastError(),ret);
                }
            }
            return -1;
        }
    };
}

#pragma once
#include <windows.h>
namespace Tools
{

    class Mutex
    {
    public:
        HANDLE    m_handle; 
        bool    m_state;
    public:
        Mutex():m_state(false),m_handle(NULL){}
        ~Mutex(){
            Destroy();
        }
        int Create()
        {
            if (!m_state)
            {
                m_handle = CreateMutex(NULL, FALSE, NULL);
                if (NULL == m_handle)
                {
                    return -1;
                }
            }
            m_state = true;
            return 0;
        }
        int Destroy()
        {
            if (m_state)
            {
                CloseHandle(m_handle);
                m_handle = NULL;
                m_state = false;
                return 0;
            }
            return -1;
        }
        int unlock()
        {
            if (m_state)
            {
                if (NULL == ReleaseMutex(m_handle))
                {
                    return -1;
                }
                return 0;
            }
            return -1;
        }
        int lock()
        {
            if (m_state)
            {
                int ret = WaitForSingleObject(m_handle,INFINITE);
                if (WAIT_TIMEOUT == ret)
                {
                    return -1;
                }
                else if (WAIT_OBJECT_0 == ret)
                {
                    return 0;
                }
            }
            return -1;
        }
        int lock(DWORD dwTime)
        {
            if (m_state)
            {
                int ret = WaitForSingleObject(m_handle,dwTime);
                if (WAIT_TIMEOUT == ret)
                {
                    return -1;
                }
                else if (WAIT_OBJECT_0 == ret)
                {
                    return 0;
                }
            }
            return -1;
        }
    };
}