Buffered_LIFO.c

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               # */
/* #                                                                      # */
/* ######################################################################## */
#include "Buffered_LIFO.h"

#include <string.h>

struct Buffered_LIFO_chunk * Buffered_LIFO_chunk_new( size_t sizeof_payload, uint64_t chunk_size, struct Buffered_LIFO_chunk * prev )
{
        struct Buffered_LIFO_chunk * ret = malloc( sizeof( struct Buffered_LIFO_chunk ) + sizeof_payload * chunk_size );
        
        if( !ret )
        {
                perror( "malloc" );
                abort();
        }
        
        ret->offset = 0;
        ret->next = prev;
        
        return ret;
}

void Buffered_LIFO_chunk_release( struct Buffered_LIFO_chunk * chunk, size_t sizeof_payload, void (*free_func)( void *) )
{
        if( !chunk )
        {
                return;
        }
        
        int i;
        
        if( free_func )
        {
                for( i = 0 ; i < chunk->offset ; i++ )
                {
                        free_func(chunk->elems + i * sizeof_payload);
                }
        }
        
        chunk->offset = 0;
        chunk->next = NULL;
        
        free( chunk );
}

struct Buffered_LIFO_chunk *  Buffered_LIFO_chunk_push( struct Buffered_LIFO_chunk *  chunk, 
                                                                                                                   void * elem,  size_t sizeof_payload, uint64_t chunk_size )
{
        struct Buffered_LIFO_chunk * ret = chunk;

        if( !ret )
        {
                /* There is no previous chunk so create it */
                ret = Buffered_LIFO_chunk_new( sizeof_payload, chunk_size, ret );
        }
        else
        {
                if( ret->offset == chunk_size )
                {
                                /* Current chunk is full so we need a new one */
                                ret = Buffered_LIFO_chunk_new( sizeof_payload, chunk_size, ret );
                }
        }
        
        /* We can now push a new entry */
        memcpy( ret->elems + ret->offset * sizeof_payload , elem, sizeof_payload );
        ret->offset++;
        
        return ret;
}

struct Buffered_LIFO_chunk * Buffered_LIFO_chunk_pop(  struct Buffered_LIFO_chunk * chunk, 
                                                                                                                 size_t sizeof_payload, uint64_t chunk_size,
                                                                                                                 void * elem, int *did_ret )
{
        if( !chunk )
        {
                *did_ret = 0;
                return chunk;
        }
        
        if( chunk->offset == 0 )
        {
                /* Move to previous chunk */
                struct Buffered_LIFO_chunk * next = chunk->next;
                
                /* Here no free func as the chunk is empty */
                Buffered_LIFO_chunk_release( chunk, 0,  NULL );

                return  Buffered_LIFO_chunk_pop(  next, sizeof_payload, chunk_size, elem, did_ret );;
        }
        
        /* Pop from chunk in the chunk */
        memcpy( elem, chunk->elems + (chunk->offset - 1) * sizeof_payload , sizeof_payload );
        *did_ret = 1;
        chunk->offset--;
        
        return chunk;
}

void * Buffered_LIFO_chunk_head( struct Buffered_LIFO_chunk * chunk,  size_t sizeof_payload )
{
        if( !chunk )
        {
                return NULL;
        }
        
        if( chunk->offset == 0 )
        {
                return Buffered_LIFO_chunk_head( chunk->next, sizeof_payload );
        }
        
        return  chunk->elems + sizeof_payload * (chunk->offset - 1 );
}

void Buffered_LIFO_init( struct Buffered_LIFO *lifo, size_t sizeof_payload, uint64_t chunk_size )
{
        lifo->sizeof_payload = sizeof_payload;
        lifo->chunk_size = chunk_size;
        
        lifo->lock = 0;
        lifo->head = NULL;
}

void Buffered_LIFO_release( struct Buffered_LIFO *lifo, void (*free_func)( void *) )
{
        lifo->sizeof_payload = 0;
        lifo->chunk_size = 0;
        
        struct Buffered_LIFO_chunk * tmp;
        struct Buffered_LIFO_chunk * to_free;
        
        tmp = lifo->head;
        
        while( tmp )
        {
                to_free = tmp;
                tmp = tmp->next;

                
                Buffered_LIFO_chunk_release( to_free, lifo->sizeof_payload,  free_func);
        }
        
        lifo->lock = 0;
        lifo->head = NULL;
}

void Buffered_LIFO_push( struct Buffered_LIFO *lifo, void * elem )
{
        MALP_Spinlock_lock( &lifo->lock );
        lifo->head = Buffered_LIFO_chunk_push( lifo->head, elem,  lifo->sizeof_payload, lifo->chunk_size );
        MALP_Spinlock_unlock( &lifo->lock );
}

void * Buffered_LIFO_pop( struct Buffered_LIFO *lifo, void * elem )
{
        int did_ret = 0;
        MALP_Spinlock_lock( &lifo->lock );
        lifo->head = Buffered_LIFO_chunk_pop( lifo->head, lifo->sizeof_payload, lifo->chunk_size, elem, &did_ret );
        MALP_Spinlock_unlock( &lifo->lock );
        
        if( !did_ret )
        {
                return NULL;
        }
        else
        {
                return elem;
        }
}

void * Buffered_LIFO_head( struct Buffered_LIFO *lifo )
{
        
        MALP_Spinlock_lock( &lifo->lock );
        void * ret = Buffered_LIFO_chunk_head( lifo->head, lifo->sizeof_payload );
        MALP_Spinlock_unlock( &lifo->lock );
        
        return ret;
}

void * Buffered_LIFO_head_locked( struct Buffered_LIFO *lifo )
{
        MALP_Spinlock_lock( &lifo->lock );
        return Buffered_LIFO_chunk_head( lifo->head, lifo->sizeof_payload );
}

void Buffered_LIFO_head_unlock( struct Buffered_LIFO *lifo )
{
        MALP_Spinlock_unlock( &lifo->lock );
}