src/core/buffer.c

Go to the documentation of this file.

#include <misc/result.h>
#include <misc/malloc.h>
#include <misc/pool.h>
#include <misc/debug.h>
#include <core/buffer.h>

struct txc_buffermgr_s {
        txc_pool_t *pool_buffer_circular; 
        txc_pool_t *pool_buffer_linear;   
};


txc_buffermgr_t *txc_g_buffermgr;


static
void
circular_buffer_constructor(void *obj)
{
        txc_buffer_circular_t *buffer;
        buffer  = (txc_buffer_circular_t *) obj;
        buffer->size_max = TXC_BUFFER_CIRCULAR_SIZE;
        buffer->buf = (char *) (((char *) obj) + sizeof (txc_buffer_circular_t));
}


static
void
linear_buffer_constructor(void *obj)
{
        txc_buffer_linear_t *buffer;

        buffer  = (txc_buffer_linear_t *) obj;
        buffer->size_max = TXC_BUFFER_LINEAR_SIZE;
        buffer->buf = (char *) (((char *) obj) + sizeof (txc_buffer_linear_t));
}


txc_result_t
txc_buffermgr_create(txc_buffermgr_t **buffermgrp) 
{
        txc_result_t result;

        *buffermgrp = (txc_buffermgr_t *) MALLOC(sizeof(txc_buffermgr_t));
        if (*buffermgrp == NULL) {
                return TXC_R_NOMEMORY;
        }

        if ((result = txc_pool_create(&((*buffermgrp)->pool_buffer_circular), 
                                      TXC_BUFFER_CIRCULAR_SIZE +
                                    sizeof(txc_buffer_circular_t),
                                      TXC_BUFFER_CIRCULAR_NUM, 
                                  circular_buffer_constructor)) != TXC_R_SUCCESS) 
        {
                FREE(*buffermgrp);
                return result;
        }       

        if ((result = txc_pool_create(&((*buffermgrp)->pool_buffer_linear), 
                                      TXC_BUFFER_LINEAR_SIZE + 
                                    sizeof(txc_buffer_linear_t),
                                      TXC_BUFFER_LINEAR_NUM, 
                                  linear_buffer_constructor)) != TXC_R_SUCCESS) 
        {
                txc_pool_destroy(&((*buffermgrp)->pool_buffer_circular));
                FREE(*buffermgrp);
                return result;
        }       

        return TXC_R_SUCCESS;
}


void
txc_buffermgr_destroy(txc_buffermgr_t **buffermgrp)
{
        txc_pool_destroy(&((*buffermgrp)->pool_buffer_circular));
        txc_pool_destroy(&((*buffermgrp)->pool_buffer_linear));
        FREE(*buffermgrp);
        *buffermgrp = NULL;
}


/*
 *****************************************************************************
 ***                    CIRCULAR BUFFER IMPLEMENTATION                     ***  
 *****************************************************************************
 */

txc_result_t 
txc_buffer_circular_init(txc_buffer_circular_t *buffer)
{

        buffer->primary_head = 0;
        buffer->primary_tail = 0;
        buffer->secondary_head = 0;
        buffer->secondary_tail = 0;
        buffer->state = TXC_BUFFER_STATE_NON_SPECULATIVE;

        return TXC_R_SUCCESS;
}

txc_result_t 
txc_buffer_circular_create(txc_buffermgr_t *buffermgr, 
                           txc_buffer_circular_t **bufferp)
{
        txc_result_t result;
        txc_buffer_circular_t *buffer;

        if ((result = txc_pool_object_alloc(buffermgr->pool_buffer_circular,
                                            (void **) &(buffer), 1)) 
            != TXC_R_SUCCESS) 
        {
                TXC_INTERNALERROR("Could not create buffer object\n");
                return result;
        }

        buffer->manager = buffermgr;
        txc_buffer_circular_init(buffer);
        *bufferp = buffer;

        return TXC_R_SUCCESS;
}


void 
txc_buffer_circular_destroy(txc_buffer_circular_t **bufferp)
{
        txc_buffermgr_t *buffermgr = (*bufferp)->manager;

        txc_pool_object_free(buffermgr->pool_buffer_circular, (void **) bufferp, 1); 
        *bufferp = NULL;
}


/*
 *****************************************************************************
 ***                     LINEAR BUFFER IMPLEMENTATION                      *** 
 *****************************************************************************
 */


txc_result_t 
txc_buffer_linear_init(txc_buffer_linear_t *buffer)
{
        buffer->state = TXC_BUFFER_STATE_NON_SPECULATIVE;
        buffer->cur_len = 0;

        return TXC_R_SUCCESS;
}


txc_result_t 
txc_buffer_linear_create(txc_buffermgr_t *buffermgr, 
                         txc_buffer_linear_t **bufferp)
{
        txc_result_t result;
        txc_buffer_linear_t *buffer;

        if ((result = txc_pool_object_alloc(buffermgr->pool_buffer_linear,
                                            (void **) &(buffer), 1)) 
            != TXC_R_SUCCESS) 
        {
                TXC_INTERNALERROR("Could not create buffer object\n");
                return result;
        }

        buffer->manager = buffermgr;
        txc_buffer_linear_init(buffer);
        *bufferp = buffer;

        return TXC_R_SUCCESS;
}


void 
txc_buffer_linear_destroy(txc_buffer_linear_t **bufferp)
{
        txc_buffermgr_t *buffermgr = (*bufferp)->manager;

        txc_pool_object_free(buffermgr->pool_buffer_linear, (void **) bufferp, 1); 
        *bufferp = NULL;
}


void *
txc_buffer_linear_malloc(txc_buffer_linear_t *buffer, unsigned int size)
{
        void *ptr;

        if (buffer->cur_len + size > buffer->size_max) {
                ptr = NULL;     
        } else {
                ptr = (void *) &buffer->buf[buffer->cur_len];
                buffer->cur_len += size;
        }
        return ptr;
}


void
txc_buffer_linear_free(txc_buffer_linear_t *buffer, unsigned int size)
{
        buffer->cur_len -= size;
}

---