buffer.c

#include <aura/aura.h>
#include <aura/private.h>

struct aura_buffer *aura_buffer_internal_request(int size);
void aura_buffer_internal_free(struct aura_buffer *buf);

/* Let's see if we have a buffer in our pool here */
static struct aura_buffer *fetch_buffer_from_pool(struct aura_node *nd,
                int size) {
        struct aura_buffer *buf = NULL;
        struct list_head *pos, *tmp;
        list_for_each_safe(pos, tmp, &nd->buffer_pool)
        {
                buf = list_entry(pos, struct aura_buffer, qentry);
                if (buf->size >= size) {
                        list_del(pos);
                        nd->num_buffers_in_pool--;
                        return buf;
                }
        }
        return NULL ;
}


struct aura_buffer *aura_buffer_request(struct aura_node *nd, int size) {
        struct aura_buffer *ret = NULL;
        int act_size = size;
        act_size += nd->tr->buffer_overhead;

#ifdef AURA_USE_BUFFER_POOL
        /* Try buffer pool first */
        ret = fetch_buffer_from_pool(nd, act_size);
        if (ret)
                goto bailout; /* For the sake of readability */
#endif

        /* Fallback to alloc() */
        if (!nd->tr->buffer_request) {
                char *data = malloc(act_size + sizeof(struct aura_buffer));
                ret = (struct aura_buffer *) data;
                if (!ret)
                        BUG(nd, "FATAL: malloc() failed");
                ret->data = &data[sizeof(*ret)];
        } else {
                ret = nd->tr->buffer_request(nd, act_size);
                if (!ret)
                        BUG(nd, "FATAL: buffer allocation by transport failed");
        }
        
bailout:
        ret->magic = AURA_BUFFER_MAGIC_ID;
        ret->size = act_size;
        ret->owner = nd;
        aura_buffer_rewind(ret);
        return ret;
}

void aura_buffer_release(struct aura_buffer *buf) {
        /* Just put the buffer back into the pool at the very start */
#ifdef AURA_USE_BUFFER_POOL
        struct aura_node *nd = buf->owner;
        if (buf->magic != AURA_BUFFER_MAGIC_ID)
        BUG(nd,
                        "FATAL: Attempting to release a buffer with invalid magic OR double free an aura_buffer");

        list_add(&buf->qentry, &nd->buffer_pool);
        nd->num_buffers_in_pool++;
#else
        aura_buffer_destroy(buf);
#endif
}

void aura_buffer_destroy(struct aura_buffer *buf) {
        struct aura_node *nd = buf->owner;
        if (buf->magic != AURA_BUFFER_MAGIC_ID)
                BUG(nd,
                                "FATAL: Attempting to destroy a buffer with invalid magic OR double free an aura_buffer");
        buf->magic = 0;

        if (nd && nd->tr->buffer_release)
                nd->tr->buffer_release(buf);
        else
                free(buf);
}

void aura_bufferpool_gc(struct aura_node *nd, int numdrop, int threshold) {
        struct aura_buffer *pos, *tmp;
        /* We iterate in reverse order, since the least used buffers
         * will naturally end up at the very end of the list
         */
        list_for_each_entry_safe_reverse(pos, tmp, &nd->buffer_pool, qentry)
        {
                if ((numdrop == -1)
                                || (numdrop-- && nd->num_buffers_in_pool > threshold)) {
                        list_del(&pos->qentry);
                        nd->num_buffers_in_pool--;
                        aura_buffer_destroy(pos);
                } else {
                        return; /* Done for now */
                }
        }
}

void aura_bufferpool_preheat(struct aura_node *nd, int size, int count) 
{
        while (count--) {
                struct aura_buffer *buf = aura_buffer_request(nd, size);
                aura_buffer_release(buf);
                slog(0, SLOG_DEBUG, "!");
        }
}

void aura_bufferpool_set_gc_threshold(struct aura_node *nd, int threshold) {
        nd->gc_threshold = threshold;
}