ringbuff.c

Go to the documentation of this file.

#include "ctl/ctldef.h"
#include "ctl/debug.h"
#include "ctl/ctlnew.h"
#include "ctl/ringbuff.h"

#ifndef CTL_UNIT

void RingBuff_Init( RingBuff* self, void* buff, size_t size )
{
    assertobjptr(self);
    assertptr(buff,size);
    self->buff = (const uint8*)buff;
    self->end = self->buff + size;
    self->head = self->tail = (uint8*)self->buff;
}

bool RingBuff_Space( RingBuff* self, uint8** buff, size_t count )
{
    assertobjconst(self);
    assert( self->head <= self->tail );
    if( self->tail + count <= self->end )
    {
        *buff = (uint8*)self->tail;
        return true;
    }
    else if( self->head > self->buff && (count <= RingBuff_Free(self) ) )
    {
        size_t used = self->tail - self->head;
        memmove( (uint8*)self->buff, self->head, used );
        self->head = (uint8*)self->buff;
        self->tail = (uint8*)self->buff + used;
        *buff = (uint8*)self->tail;
        return true;
    }
    *buff = NULL;
    return false;
}

bool RingBuff_Peek( RingBuff* self, const uint8** buff, size_t count )
{
    assertobjptr(self);
    assert( self->tail >= self->head );
    if( self->head + count > self->tail )
    {   /* Not enough data left */
        return false;
    }
    *buff = self->head;
    return true;
}

bool RingBuff_Consume( RingBuff* self, size_t count )
{
    assertobjptr(self);
    assert( self->tail >= self->head );
    if( self->head + count > self->tail )
    {
        return false;
    }
    self->head += count;
    if( self->head == self->tail )
    {   // Reset if we use up the data
        RingBuff_Reset(self);
    }
    return true;
}

bool RingBuff_Add( RingBuff* self, uint8** buff, size_t count )
{
    if( RingBuff_Space( self, buff, count ) )
    {   // Consume free space
        self->tail += count;
        return true;
    }
    return false;
}

bool RingBuff_Pop( RingBuff* self, const uint8** buff, size_t count )
{
    if( RingBuff_Peek( self, buff, count ) )
    {   // Consume data
        self->head += count;
        if( self->head == self->tail )
        {   // Reset if we use up the data
            RingBuff_Reset(self);
        }
        return true;
    }
    /* Not enough data left */
    return false;
}

bool RingBuff_CopyTo( RingBuff* self, const void* buff, size_t count )
{
    uint8* space;
    if( RingBuff_Space( self, &space, count ) )
    {   // Consume free space
        memcpy(space,buff,count);
        self->tail += count;
        return true;
    }
    return false;
}

bool RingBuff_CopyFrom( RingBuff* self, void* buff, size_t count )
{
    const uint8* data;
    if( RingBuff_Peek( self, &data, count ) )
    {   // Consume data
        memcpy(buff,data,count);
        self->head += count;
        return true;
    }
    return false;
}

bool RingBuff_AddSerial( RingBuff* self, ctl_serial* serial, size_t reserve )
{
    uint8* space;
    uint16 size = 2 + reserve;
    if( RingBuff_Add( self, &space, size ) )
    {
        ctl_serial_init( serial, space, space + size );
        uint16_serial_write(&size, serial );
        return true;
    }
    return false;
}

bool RingBuff_PeekSerial( RingBuff* self, ctl_serial* serial )
{
    const uint8* data;
    if( RingBuff_Peek( self, &data, 2 ) )
    {
        ctl_serial_init( serial, (uint8*)data, data+2 );
        uint16 size;
        uint16_serial_read(&size, serial );
        ctl_serial_init( serial, data, data + size );
        return true;
    }
    return false;
}

bool RingBuff_PopSerial( RingBuff* self, ctl_serial* serial )
{
    const uint8* data;
    if( RingBuff_Peek( self, &data, 2 ) )
    {
        uint16 size;
        ctl_serial_init( serial, data, data+2 );
        uint16_serial_read(&size, serial );
        /* Pop the packet off, once it's available */
        if( RingBuff_Pop( self, &data, size ) )
        {
            ctl_serial_init( serial, data, data + size );
            /* Parse past length; it can be had by rewinding, but in most cases app won't want it. */
            serial->curr += 2;
            return true;
        }
    }
    return false;
}


#else /* CTL_UNIT */

#include "unit/unit.h"

void Test_RingBuff1(void);
void Test_RingBuff2(void);
void Test_RingBuff3(void);
void Test_RingBuff4(void);
void Test_RingBuff5(void);

void Test_RingBuff(void)
{
    /* Don't spew stuff on screen */
    Test_RingBuff1();
    Test_RingBuff2();
    Test_RingBuff3();
    Test_RingBuff4();
    Test_RingBuff5();
}

/*
 * Do basic unit testing on ring buffer
 */
void Test_RingBuff1(void)
{
    RingBuff rb;
    uint8 buffer[16];
#define RINGBUFF_AVAIL  sizeof(buffer)
    const uint8* read;
    uint8* write;
    uint8* scratch = buffer;
    RingBuff_Init(&rb,buffer,sizeof(buffer));

    /* Work through the macros - empty, unused buffer */
    Test_Error( RINGBUFF_AVAIL == RingBuff_Total(&rb) );
    Test_Error( RINGBUFF_AVAIL == RingBuff_Free(&rb) );
    Test_Error( 0 == RingBuff_Remain(&rb) );

    /* Now add some data */
    Test_Error( RingBuff_Add( &rb, &write, 2 ) );
    Test_Error( scratch == buffer );
    Test_Error( buffer == write );
    memcpy(write,"HI",2);
    Test_Error( RINGBUFF_AVAIL-2 == RingBuff_Free(&rb) );
    Test_Error( 2 == RingBuff_Remain(&rb) );

    /* See that it makes an error. */
    Test_Error( !RingBuff_Peek( &rb, &read, 3 ) );

    /* Now pop that data */
    Test_Error( RingBuff_Peek( &rb, &read, 2 ) );
    Test_Error( 0 == memcmp(read,"HI",2) );
    Test_Error( RingBuff_Pop( &rb, &read, 2 ) );
    Test_Error( 0 == memcmp(read,"HI",2) );
    Test_Error( RINGBUFF_AVAIL == RingBuff_Free(&rb) );
    Test_Error( 0 == RingBuff_Remain(&rb) );

    /* Now add some more data */
    Test_Error( RingBuff_Add( &rb, &write, 5 ) );
    memcpy(write,"12345",5);
    Test_Error( RINGBUFF_AVAIL-5 == RingBuff_Free(&rb) );
    Test_Error( 5 == RingBuff_Remain(&rb) );
    Test_Error( RingBuff_Add( &rb, &write, 5 ) );
    memcpy(write,"ABCDE",5);
    Test_Error( RINGBUFF_AVAIL-10 == RingBuff_Free(&rb) );
    Test_Error( 10 == RingBuff_Remain(&rb) );
    
    /* Cause exception; ensure it's still kosher */
    Test_Error( !RingBuff_Add( &rb, &write, 7 ) );
    Test_Error( NULL == write );
    Test_Error( RINGBUFF_AVAIL-10 == RingBuff_Free(&rb) );
    Test_Error( 10 == RingBuff_Remain(&rb) );
    
    /* Fill it up */
    Test_Error( RingBuff_Add( &rb, &write, 6 ) );
    memcpy(write,"654321",6);
    Test_Error( 0 == RingBuff_Free(&rb) );
    Test_Error( 16 == RingBuff_Remain(&rb) );
    
    /* Pop initial block off */
    Test_Error( RingBuff_Pop( &rb, &read, 5 ) );
    Test_Error( 0 == memcmp(read,"12345",5) );
    Test_Error( RINGBUFF_AVAIL-11 == RingBuff_Free(&rb) );
    Test_Error( 11 == RingBuff_Remain(&rb) );

    /* See that we can't read more than there is */
    Test_Error( !RingBuff_Peek( &rb, &read, 12 ) );
    Test_Error( !RingBuff_Pop( &rb, &read, 12 ) );
    
    /* Force data to move around and add data and fill it back up */
    Test_Error( RingBuff_Add( &rb, &write, 5 ) );
    memcpy(write,"ZYXWV",5);
    Test_Error( 0 == RingBuff_Free(&rb) );
    Test_Error( RINGBUFF_AVAIL == RingBuff_Remain(&rb) );

    /* Pop second block off */
    Test_Error( RingBuff_Pop( &rb, &read, 5 ) );
    Test_Error( 0 == memcmp(read,"ABCDE",5) );
    Test_Error( 5 == RingBuff_Free(&rb) );
    Test_Error( 11 == RingBuff_Remain(&rb) );

    /* Cause exception */
    Test_Error( !RingBuff_Add( &rb, &write, 11 ) );
    Test_Error( 5 == RingBuff_Free(&rb) );
    Test_Error( 11 == RingBuff_Remain(&rb) );

    /* Fill it again */
    Test_Error( RingBuff_Add( &rb, &write, 5 ) );
    memcpy(write,"!@#$%^",5);
    Test_Error( 0 == RingBuff_Free(&rb) );
    Test_Error( 16 == RingBuff_Remain(&rb) );

    /* Pop everything off and see that it wraps */
    RingBuff_Pop( &rb, &read, 10 );
    Test_Error( 0 == memcmp(read,"654321ZYXWV",10) );
    Test_Error( 6 == RingBuff_Remain(&rb) );
    Test_Error( 10 == RingBuff_Free(&rb) );
    RingBuff_Add( &rb, &write, 3 );
    memcpy(write,"123",3);
    Test_Error( 7 == RingBuff_Free(&rb) );
    Test_Error( 9 == RingBuff_Remain(&rb) );

}

/*
 * Do extended testing on ring buffer
 * Feeds contents of one to another, expects both to remain in sync.
 */
void Test_RingBuff2(void)
{
    RingBuff rb1;
    uint8 buffer1[64];
    RingBuff rb2;
    uint8 buffer2[64];
    RingBuff_Init(&rb1,buffer1,sizeof(buffer1));
    RingBuff_Init(&rb2,buffer2,sizeof(buffer2));

    /*
     * Fill first ring buffer with junk
     */
    while( 3 < RingBuff_Free(&rb1) )
    {
        uint8* p;
        Test_Error( RingBuff_Add( &rb1, &p, 1 ) );
        *p = uint8_rand();
    }
    Test_Error( 3 == RingBuff_Free(&rb1) );
    Test_Error( 61 == RingBuff_Remain(&rb1) );
    {
        uint8* write;
        const uint8* read;
        Test_Error( RingBuff_Add( &rb2, &write, 5 ) );
        Test_Error( RingBuff_CopyFrom( &rb1, write, 5 ) );
        Test_Error( 8 == RingBuff_Free(&rb1) );
        Test_Error( 56 == RingBuff_Remain(&rb1) );
        Test_Error( 59 == RingBuff_Free(&rb2) );
        Test_Error( 5 == RingBuff_Remain(&rb2) );
        
        Test_Error(RingBuff_Pop( &rb2, &read, 5 ));
        Test_Error( RingBuff_CopyTo( &rb1, read, 5 ) );
        /* 3 would be available, but head==tail = 0 bytes */
        Test_Error( 3 == RingBuff_Free(&rb1) );
        Test_Error( 61 == RingBuff_Remain(&rb1) );
        Test_Error( RingBuff_IsEmpty( &rb2 ) );
    }
}

struct test
{
    int32 a, b, c;
};
/*
 * Do serialization testing
 */
void Test_RingBuff3(void)
{
    struct test test1, test2;
    RingBuff rb;
    uint8 buffer[64];
    ctl_serial serial;
    RingBuff_Init(&rb,buffer,sizeof(buffer));
    test1.a = rand();
    test1.b = rand();
    test1.c = rand();
    Test_Error( RingBuff_AddSerial( &rb, &serial, 12 ) );
    int32_serial_write( &test1.a, &serial );
    int32_serial_write( &test1.b, &serial );
    int32_serial_write( &test1.c, &serial );
    Test_Error( RingBuff_PopSerial( &rb, &serial ) );
    int32_serial_read( &test2.a, &serial );
    int32_serial_read( &test2.b, &serial );
    int32_serial_read( &test2.c, &serial );
    Test_Error( test1.a == test2.a && test1.b == test2.b && test1.c == test2.c );
}

#define RAND_TEST_ITERATIONS 1000

/*
 * Throw data into it and take data out of it randomly lots of times
 * Attempt to brute-force break it.
 * Uses sequential bytes and checks for non-sequential values
 */
void Test_RingBuff4(void)
{
    int times = RAND_TEST_ITERATIONS;
    RingBuff rb;
    uint8 buffer[64];
    uint8 seq = 0;
    uint8 seqpop = 0;
    RingBuff_Init(&rb,buffer,sizeof(buffer));
    while( times-- )
    {
        size_t size = RingBuff_Free( &rb );
        size_t todo = size * rand() / RAND_MAX;
        const uint8* popped;
        uint8* pcurr;
        if( !RingBuff_Add( &rb, &pcurr, todo ) )
        {
            size = RingBuff_Free( &rb );
            todo = size * rand() / RAND_MAX;
            Test_Error(RingBuff_Add( &rb, &pcurr, todo ));
        }
        while( todo-- )
        {
            *pcurr++ = seq++;
        }
        size = RingBuff_Remain( &rb );
        todo = size * rand() / RAND_MAX;
        Test_Error(RingBuff_Pop( &rb, &popped, todo ));
        while( todo-- )
        {
            Test_Error( *popped++ == seqpop++ );
        }
    }
}

/*
 * Throw data into it by packet and take data out of it randomly lots of times
 * Attempt to brute-force break it.
 * Uses sequential bytes and checks for non-sequential values
 */
void Test_RingBuff5(void)
{
    int times = RAND_TEST_ITERATIONS;
    RingBuff rb;
    uint8 buffer[64];
    uint8 seq = 0;
    uint8 seqpop = 0;
    RingBuff_Init(&rb,buffer,sizeof(buffer));
    while( times-- )
    {
        size_t size = RingBuff_Free( &rb )-2;
        size_t todo = size * rand() / RAND_MAX;
        ctl_serial serial;
        Test_Error(RingBuff_AddSerial( &rb, &serial, todo ));
        while( serial.curr < serial.end )
        {
            *serial.curr++ = seq++;
        }
        Test_Error(RingBuff_PopSerial( &rb, &serial ));
        while( serial.curr < serial.end )
        {
            Test_Error( *serial.curr++ == seqpop++ );
        }
    }
}


#endif /* CTL_UNIT */