Circular buffers?

Hugh

Hi,

Is there a consensus on the best way to use circular buffers? If I want to push a byte received from a serial port through an array of bytes named 'data', is this the way to do it?

repeat         
     bytemove (@data, @data + 1, 10)                                                            
     data[10] := serial.rx

I ask because if I print to the serial terminal any one element of the array (e.g., data[0], data[1], etc.,) individually I can see the data scrolling through. If I print data[0], data[1], data[2] and data[3] as a group there are gaps (some data is missing). Is it not the done thing to use bytemove with the same source and destination?

jazzed

Can you use a buffer with a head and tail?
The FullDuplexSerial object does this for you.

Cluso99

The FDX head and tail idea works extremely well for a lot of buffers. Simplest if you use a 2^n boundary.

MagIO2

Interesting question! In other systems one might want to say that copying the buffer again and again should be avoided because it is to time consuming, but in Propeller world my guess is that bytemove is propably faster than head and tail handling if you do it in SPIN, as bytemove is in PASM

But in your example it would maybe be an option to use the buffer of the serial driver directly, because it is already there, so why add another one?
But maybe I simply did not understand the problem good enough because I did not understand what you wrote after the code example.

Hugh

Thanks. FDX it is...

Dr_Acula

The head and tail concept is (another) one of those clever things I learned from this forum

Draw it on a piece of paper with (say) 16 values in a buffer and two variables, head and tail. Both start at zero. If data comes in, head moves up one. If data goes out, tail moves up one. For 16 values in the buffer, mask the top 28 bits to zero and then both head and tail automatically loop around from 15 to zero (Binary xxxx1111 to xxxx0000). If head = tail, then the buffer is empty. Buffer loop around is easiest if the number of values in the buffer is a multiple of 2, eg 2,4,8,16.

SRLM

As simple as using a buffer sized to a power of two is using a buffer with arbitrary size and using modulo to force the head/tail pointer wrap around:
spin:

head //= BUFFER_SIZE

c/c++

head = head % BUFFER_SIZE;

Duane Degn

SRLM wrote: »

As simple as using a buffer sized to a power of two is using a buffer with arbitrary size and using modulo to force the head/tail pointer wrap around:
spin:

head //= BUFFER_SIZE

c/c++

head = head % BUFFER_SIZE;

And in Tracy Allen's four port serial driver:

cmpsub     tx_tail3,txsize3   wz   ' TTA for individually sized buffers, will zero at rollover
                        wrlong  tx_tail3,tx_tail_ptr3
        if_z            mov     txbuff_tail_ptr3,txbuff_ptr3 'reset tail_ptr if we wrapped
        if_nz           add     txbuff_tail_ptr3,#1   'otherwise add 1

The "cmpsub" statement does for any number what "add" does for powers of two (at least in this application).

While agree non-powers of two are easy to use, I've always used powers of two in my circular buffers (which I also learned about here on the forum).