Buffered_FIFO.h

Go to the documentation of this file.

/* ############################ MALP License ############################## */
/* # Fri Jan 18 14:00:00 CET 2013                                         # */
/* # Copyright or (C) or Copr. Commissariat a l'Energie Atomique          # */
/* #                                                                      # */
/* # This software is governed by the CeCILL-C license under French law   # */
/* # and abiding by the rules of distribution of free software.  You can  # */
/* # use, modify and/ or redistribute the software under the terms of     # */
/* # the CeCILL-C license as circulated by CEA, CNRS and INRIA at the     # */
/* # following URL http://www.cecill.info.                                # */
/* #                                                                      # */
/* # The fact that you are presently reading this means that you have     # */
/* # had knowledge of the CeCILL-C license and that you accept its        # */
/* # terms.                                                               # */
/* #                                                                      # */
/* # Authors:                                                             # */
/* #   - BESNARD Jean-Baptiste jean-baptiste.besnard@cea.fr               # */
/* #                                                                      # */
/* ######################################################################## */

#ifndef BUFFERED_FIFO_H
#define BUFFERED_FIFO_H


#ifdef __cplusplus
  extern "C"
  {
#endif



#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

#include "Spinlock.h"

struct Buffered_FIFO_chunk {
        MALP_Spinlock lock;                 
        char *payload;                      
        uint64_t chunk_size;                
        size_t elem_size;                   
        uint64_t start_offset;              
        uint64_t end_offset;                
        struct Buffered_FIFO_chunk *prev;   
};

void Buffered_FIFO_chunk_init( struct Buffered_FIFO_chunk *ch, 
                                                                uint64_t chunk_size, size_t elem_size );

struct Buffered_FIFO_chunk * Buffered_FIFO_chunk_new( uint64_t chunk_size, uint64_t elem_size );

void Buffered_FIFO_chunk_release( struct Buffered_FIFO_chunk *ch );

void * Buffered_FIFO_chunk_push( struct Buffered_FIFO_chunk *ch, void *elem );

void * Buffered_FIFO_chunk_pop( struct Buffered_FIFO_chunk *ch, void *dest );

static inline void Buffered_FIFO_chunk_ctx_prev( struct Buffered_FIFO_chunk *ch, struct Buffered_FIFO_chunk *prev)
{
                MALP_Spinlock_lock( &ch->lock );
                ch->prev = prev;
                MALP_Spinlock_unlock( &ch->lock );
}

static inline struct Buffered_FIFO_chunk * Buffered_FIFO_chunk_prev( struct Buffered_FIFO_chunk *ch )
{
        struct Buffered_FIFO_chunk *ret;
        MALP_Spinlock_lock( &ch->lock );
        ret =ch->prev;
        MALP_Spinlock_unlock( &ch->lock );

        return ret;
}

struct Buffered_FIFO {
        MALP_Spinlock head_lock;            
        struct Buffered_FIFO_chunk *head;   
        MALP_Spinlock tail_lock;            
        struct Buffered_FIFO_chunk *tail;   
        uint64_t chunk_size;                
        size_t elem_size;                   
        MALP_Spinlock lock;                 
        uint64_t elem_count;                
};

void Buffered_FIFO_init(struct Buffered_FIFO *fifo, uint64_t chunk_size, size_t elem_size);

void Buffered_FIFO_release(struct Buffered_FIFO *fifo, void (*free_func) (void *));

void *Buffered_FIFO_push(struct Buffered_FIFO *fifo, void *elem);

void *Buffered_FIFO_pop(struct Buffered_FIFO *fifo, void *dest);

uint64_t Buffered_FIFO_count(struct Buffered_FIFO *fifo);

#ifdef __cplusplus
  }
#endif


#endif /* BUFFERED_FIFO_H  */