先进先出队列 FIFO

fifo.h

---------------------------------------------------------------------------------------------------------

#ifndef FIFO_H
#define FIFO_H

#include <pthread.h>

#ifdef __cplusplus
extern "C" {
#endif

#pragma pack(1)

typedef struct{
    char* buffer;
    int buffer_size;
    int count;
    int write_ptr;
    int read_ptr;
    pthread_mutex_t mutex;
}tFifo,*pFifo;

#pragma pack()

int fifo_init(pFifo pfifo);
void fifo_uninit(pFifo pfifo);

int fifo_into(pFifo pfifo,char* buffer,int buffer_size);

char *fifo_get(pFifo pfifo,int* out_len);
int fifo_remove(pFifo pfifo);

#ifdef __cplusplus
}
#endif

#endif

 

fifo.c

---------------------------------------------------------------------------------------------------------

 

#include "fifo.h"
#include "../debug/debug.h"

#if 0
#define _debug_fifo
#endif

#ifdef _debug_fifo
#define debug_fifo(fmt,...) debug(fmt,##__VA_ARGS__)
#else
#define debug_fifo(fmt,...)
#endif

#if 1
#define FIFO_USE_MUTEX
#endif

#define FIFO_NODE_INVALID               0xFF
#define FIFO_NODE_VALID                 0x00

#pragma pack(1)

typedef struct{
    char flag;
    int len;
}tNodeHead,*pNodeHead;

#pragma pack()

int fifo_init(pFifo pfifo)
{
    debug_fifo("/n");

    if(pfifo==NULL){
        return -1;
    }

    pfifo->count     = 0;
    pfifo->read_ptr  = 0;
    pfifo->write_ptr = 0;

    return 0;
}

void fifo_uninit(pFifo pfifo)
{
    debug_fifo("/n");
    return;
}

static int fifo_check_spare(pFifo pfifo,int need_len)
{
    debug_fifo("/n");

    int spare = 0;
    if(pfifo->write_ptr >= pfifo->read_ptr)
    {
        spare = pfifo->buffer_size - pfifo->write_ptr;
        if(need_len > spare)
        {
            if(pfifo->read_ptr > need_len){
                if(spare>0){
                    pfifo->buffer[pfifo->write_ptr] = FIFO_NODE_INVALID;
                }
                spare = pfifo->read_ptr;
            }else
                spare = -1;
        }
     }else
     {
         spare = pfifo->read_ptr - pfifo->write_ptr;
     }

    if( spare == 0 )
        return pfifo->buffer_size;
    else if( spare >= need_len )
        return spare;
    return -1;
}

#define check_write_ptr(){/
    if(pfifo->write_ptr>=pfifo->buffer_size || pfifo->buffer[pfifo->write_ptr]==FIFO_NODE_INVALID){/
            debug_fifo("reset write_ptr=0/n");/
            pfifo->write_ptr = 0;/
    }/
}

int fifo_into(pFifo pfifo,char* buffer,int buffer_size)
{
    debug_fifo("/n");

    int retval = -1;

#ifdef FIFO_USE_MUTEX
    pthread_mutex_lock(&(pfifo->mutex));
#endif

    if(buffer==0||buffer_size<=0){
        debug_warning("buffer is null/n");
        goto error;
    }

    debug_fifo("begin read_ptr=%d,write_ptr=%d/n",pfifo->read_ptr,pfifo->write_ptr);

    int node_head_len = sizeof(tNodeHead);
    int need_size = node_head_len + buffer_size;

    int spare=fifo_check_spare(pfifo,need_size);
    debug_fifo("spare=%d/n",spare);

    if(spare < 0)
    {
        debug_error("task buffer so busy,spare=%d,node head len=%d,need_len=%d/n",spare,node_head_len,need_size);
        goto error;
    }

    check_write_ptr();

    pNodeHead pHead = pfifo->buffer + pfifo->write_ptr;

    pHead->flag = FIFO_NODE_VALID;
    pHead->len  = need_size;

    char* pdata = ((char*)pHead) + node_head_len;

    memcpy(pdata,buffer,buffer_size);
    pfifo->write_ptr += need_size;

    debug_fifo("end read_ptr=%d,write_ptr=%d/n",pfifo->read_ptr,pfifo->write_ptr);

    pfifo->count++;

    retval=pfifo->count;

    debug_fifo("task post ok,read_ptr=%d,write_ptr=%d,write len=%d,count=%d/n",pfifo->read_ptr,pfifo->write_ptr,need_size,pfifo->count);

#if 0
    int i;
    debug("data=");
    for(i=0;i<need_size+0x10;i++)
    {
        debugf("0x%02x ",((char*)pHead)[i]);
        if(i==need_size-1)
            debugf(" ~ ");
    }
    debugf("/n");
#endif

error:
#ifdef FIFO_USE_MUTEX
    pthread_mutex_unlock(&(pfifo->mutex));
#endif
    return retval;
}

static int fifo_is_empty(pFifo pfifo)
{
    debug_fifo("/n");
    int retval=0;
    if(pfifo->write_ptr==pfifo->read_ptr)
        retval=1;
    return retval;
}

#define check_read_ptr(){/
    if(pfifo->read_ptr>=pfifo->buffer_size || pfifo->buffer[pfifo->read_ptr]==FIFO_NODE_INVALID){/
            debug_fifo("reset read_ptr=0/n");/
            pfifo->read_ptr = 0;/
    }/
}

char* fifo_get(pFifo pfifo,int* out_len)
{
    debug_fifo("/n");

#ifdef FIFO_USE_MUTEX
    pthread_mutex_lock(&(pfifo->mutex));
#endif

    char* retval = NULL;

    if(!fifo_is_empty(pfifo))
    {
        check_read_ptr();

        int node_head_len = sizeof(tNodeHead);
        pNodeHead pHead = (pNodeHead)(pfifo->buffer + pfifo->read_ptr);
        retval = ((char*)pHead) + node_head_len;

        int outlen = pHead->len - node_head_len;

        if(out_len!=NULL){
            *out_len = outlen;
        }
#if 1
        debug_fifo("task get ok,read_ptr=%d,write_ptr=%d,read len=%d,out len=%d,count=%d/n",pfifo->read_ptr,pfifo->write_ptr,pHead->len,outlen,pfifo->count);
#endif
    }

#ifdef FIFO_USE_MUTEX
    pthread_mutex_unlock(&(pfifo->mutex));
#endif
    return retval;
}

int fifo_remove(pFifo pfifo)
{
    debug_fifo("/n");
    int retval = -1;

#ifdef FIFO_USE_MUTEX
    pthread_mutex_lock(&(pfifo->mutex));
#endif

    if(!fifo_is_empty(pfifo))
    {
        debug_fifo("task remove begin,read_ptr=%d,write_ptr=%d,count=%d/n",pfifo->read_ptr,pfifo->write_ptr,pfifo->count);

        check_read_ptr();

        pNodeHead pHead = (pNodeHead)(pfifo->buffer + pfifo->read_ptr);

        int node_size = pHead->len;
        pfifo->read_ptr += node_size;

        pfifo->count--;

        retval = pfifo->count;
#if 1
        debug_fifo("task remove ok,read_ptr=%d,write_ptr=%d,remove len=%d,count=%d/n",pfifo->read_ptr,pfifo->write_ptr,node_size,pfifo->count);
#endif
    }

#ifdef FIFO_USE_MUTEX
    pthread_mutex_unlock(&(pfifo->mutex));
#endif
    return retval;
}