update ringbuf and test case

guowenxue

2024-08-19 b78fa65e73b7e1ebc668fb70dc532e85dc47e312

update ringbuf and test case

 booster/ringbuf.c

@@ -15,17 +15,40 @@
#include <assert.h>
#include "ringbuf.h"

void rb_init (struct ring_buffer *ring, unsigned char* buff, int size)
void rb_init(struct ring_buffer *rb, unsigned char *buf, int size)
{
    memset (ring, 0, sizeof (struct ring_buffer));
    ring->rd_pointer = 0;
    ring->wr_pointer = 0;
    ring->buffer= buff;
    ring->size = size;
    memset(rb, 0, sizeof (struct ring_buffer));
    rb->rd_pointer = 0;
    rb->wr_pointer = 0;
    rb->buffer= buf;
    rb->size = size;
}

void rb_clear(struct ring_buffer *rb)
{
    memset(rb->buffer, 0, rb->size);
    rb->rd_pointer=0;
    rb->wr_pointer=0;
}

int rb_write (struct ring_buffer *rb, unsigned char * buf, int len)
int rb_data_size(struct ring_buffer *rb)
{
    return ((rb->wr_pointer - rb->rd_pointer) & (rb->size-1));
}

int rb_free_size(struct ring_buffer *rb)
{
    return (rb->size - 1 - rb_data_size(rb));
}

unsigned char rb_peek(struct ring_buffer *rb, int index)
{
    assert(index < rb_data_size(rb));

    return rb->buffer[((rb->rd_pointer + index) % rb->size)];
}

int rb_write(struct ring_buffer *rb, unsigned char *buf, int len)
{
    int                  total;
    int                  i;
@@ -51,57 +74,52 @@
    return total;
}


int rb_free_size (struct ring_buffer *rb)
{
    return (rb->size - 1 - rb_data_size(rb));
}


int rb_read (struct ring_buffer *rb, unsigned char * buf, int max)
int rb_read(struct ring_buffer *rb, unsigned char *buf, int bytes)
{
    int                  total;
    int                  i;

    /* total = len = min(used, len) */
    total = rb_data_size(rb);

    if(max > total)
        max = total;
    else
        total = max;

    if(bytes > total)
        bytes = total;

    i = rb->rd_pointer;
    if(i + max > rb->size)
    if(i + bytes > rb->size)
    {
        memcpy(buf, rb->buffer + i, rb->size - i);
        buf += rb->size - i;
        max -= rb->size - i;
        bytes -= rb->size - i;
        i = 0;
    }

    memcpy(buf, rb->buffer + i, max);
    rb->rd_pointer = i + max;
    memcpy(buf, rb->buffer + i, bytes);
    rb->rd_pointer = i + bytes;

    return total;
}

int rb_data_size (struct ring_buffer *rb)
int rb_copy(struct ring_buffer *rb, unsigned char *buf, int bytes)
{
    return ((rb->wr_pointer - rb->rd_pointer) & (rb->size-1));
    int                  total;
    int                  i;

    total = rb_data_size(rb);

    if(bytes > total)
        bytes = total;

    i = rb->rd_pointer;
    if(i + bytes > rb->size)
    {
        memcpy(buf, rb->buffer + i, rb->size - i);
        buf += rb->size - i;
        bytes -= rb->size - i;
        i = 0;
    }

    memcpy(buf, rb->buffer + i, bytes);

    return total;
}

void rb_clear (struct ring_buffer *rb)
{
    memset(rb->buffer,0,rb->size);
    rb->rd_pointer=0;
    rb->wr_pointer=0;
}

unsigned char rb_peek(struct ring_buffer* rb, int index)
{
    assert(index < rb_data_size(rb));

    return rb->buffer[((rb->rd_pointer + index) % rb->size)];
}

 booster/ringbuf.h

@@ -24,34 +24,31 @@


/* Initial the ring buffer */
void rb_init (struct ring_buffer *ring, unsigned char *buff, int size) ;
void rb_init(struct ring_buffer *rb, unsigned char *buf, int size);

/* Clear the ring buffer data  */
void rb_clear(struct ring_buffer *rb);

/* Get data size in the ring buffer  */
int rb_data_size(struct ring_buffer *rb);

/* Get ring buffer left free size  */
int rb_free_size(struct ring_buffer *rb);

/* Read a specify $index byte data in ring buffer $rb  */
unsigned char rb_peek(struct ring_buffer *rb, int index);

/*  Description: Write $len bytes data in $buf into ring buffer $rb
 * Return Value: The actual written into ring buffer data size, if ring buffer
 * left space size small than $len, then only part of the data be written into.
 */
int rb_write (struct ring_buffer *rb, unsigned char *buf, int len) ;
int rb_write(struct ring_buffer *rb, unsigned char *buf, int len);

/* Read $bytes data from ring buffer $rb to $buf */
int rb_read(struct ring_buffer *rb, unsigned char *buf, int bytes);

/* Get ring buffer left free size  */
int rb_free_size (struct ring_buffer *rb);


/* Read $max bytes data from ring buffer $rb to $buf */
int rb_read (struct ring_buffer *rb, unsigned char *buf, int max);


/* Read a specify $index byte data in ring buffer $rb  */
unsigned char rb_peek(struct ring_buffer *rb, int index);


/* Get data size in the ring buffer  */
int rb_data_size (struct ring_buffer *rb);


/* Clear the ring buffer data  */
void rb_clear (struct ring_buffer *rb) ;
/* Read $bytes data from ring buffer $rb to $buf, but not drain */
int rb_copy(struct ring_buffer *rb, unsigned char *buf, int bytes);

#endif   /* ----- #ifndef _RINGBUF_H_  ----- */


 booster/testcase/ringbuf.c

New file
@@ -0,0 +1,53 @@
/*********************************************************************************
 *      Copyright:  (C) 2024 LingYun IoT System Studio
 *                  All rights reserved.
 *
 *       Filename:  ringbuf.c
 *    Description:  This file is ring buffer test code.
 *
 *        Version:  1.0.0(08/19/2024)
 *         Author:  Guo Wenxue <guowenxue@gmail.com>
 *      ChangeLog:  1, Release initial version on "08/19/2024 05:25:20 PM"
 *
 ********************************************************************************/

#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <libgen.h>
#include "logger.h"
#include "ringbuf.h"

int main (int argc, char **argv)
{
    struct ring_buffer      rb;
    char                    rbuf[256];
    char                    buf[256];

    log_open("console", LOG_LEVEL_DEBUG, 0, LOG_LOCK_DISABLE);

    rb_init(&rb, rbuf, sizeof(rbuf));
    log_info("Initial rb with rbuf size: %d\n", sizeof(rbuf));

    rb_write(&rb, "Hello", strlen("Hello"));
    log_warn("After rb_write() data size: %d free size: %d\n", rb_data_size(&rb), rb_free_size(&rb));

    rb_write(&rb, "World", strlen("World"));
    log_warn("After rb_write() data size: %d free size: %d\n", rb_data_size(&rb), rb_free_size(&rb));

    memset(buf, 0, sizeof(buf));
    rb_copy(&rb, buf, sizeof(buf));
    log_info("rb_copy() out data: %s\n", buf);
    log_warn("After rb_copy() data size: %d free size: %d\n", rb_data_size(&rb), rb_free_size(&rb));

    memset(buf, 0, sizeof(buf));
    rb_read(&rb, buf, sizeof(buf));
    log_info("rb_read() out data: %s\n", buf);
    log_warn("After rb_read() data size: %d free size: %d\n", rb_data_size(&rb), rb_free_size(&rb));

    rb_clear(&rb);

    log_close();
    return 0;
}