Projects/Benito/Lib/LightweightRingBuff.h

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 /** \file
  32  *
  33  *  Ultra lightweight ring buffer, for fast insertion/deletion.
  34  */
  35
  36 #ifndef _ULW_RING_BUFF_H_
  37 #define _ULW_RING_BUFF_H_
  38
  39         /* Includes: */
  40                 #include <util/atomic.h>
  41
  42                 #include <stdint.h>
  43                 #include <stdbool.h>
  44
  45         /* Defines: */
  46                 /** Size of each ring buffer, in data elements - must be between 1 and 255. */
  47                 #define BUFFER_SIZE         255
  48
  49                 /** Type of data to store into the buffer. */
  50                 #define RingBuff_Data_t     uint8_t
  51
  52                 /** Datatype which may be used to store the count of data stored in a buffer, retrieved
  53                  *  via a call to \ref RingBuffer_GetCount().
  54                  */
  55                 #if (BUFFER_SIZE <= 0xFF)
  56                         #define RingBuff_Count_t   uint8_t
  57                 #else
  58                         #define RingBuff_Count_t   uint16_t
  59                 #endif
  60
  61         /* Type Defines: */
  62                 /** Type define for a new ring buffer object. Buffers should be initialized via a call to
  63                  *  \ref RingBuffer_InitBuffer() before use.
  64                  */
  65                 typedef struct
  66                 {
  67                         RingBuff_Data_t  Buffer[BUFFER_SIZE]; /**< Internal ring buffer data, referenced by the buffer pointers. */
  68                         RingBuff_Data_t* In; /**< Current storage location in the circular buffer */
  69                         RingBuff_Data_t* Out; /**< Current retrieval location in the circular buffer */
  70                         RingBuff_Count_t Count;
  71                 } RingBuff_t;
  72
  73         /* Inline Functions: */
  74                 /** Initializes a ring buffer ready for use. Buffers must be initialized via this function
  75                  *  before any operations are called upon them. Already initialized buffers may be reset
  76                  *  by re-initializing them using this function.
  77                  *
  78                  *  \param[out] Buffer  Pointer to a ring buffer structure to initialize
  79                  */
  80                 static inline void RingBuffer_InitBuffer(RingBuff_t* const Buffer)
  81                 {
  82                         ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
  83                         {
  84                                 Buffer->In  = Buffer->Buffer;
  85                                 Buffer->Out = Buffer->Buffer;
  86                         }
  87                 }
  88
  89                 /** Retrieves the minimum number of bytes stored in a particular buffer. This value is computed
  90                  *  by entering an atomic lock on the buffer while the IN and OUT locations are fetched, so that
  91                  *  the buffer cannot be modified while the computation takes place. This value should be cached
  92                  *  when reading out the contents of the buffer, so that as small a time as possible is spent
  93                  *  in an atomic lock.
  94                  *
  95                  *  \note The value returned by this function is guaranteed to only be the minimum number of bytes
  96                  *        stored in the given buffer; this value may change as other threads write new data and so
  97                  *        the returned number should be used only to determine how many successive reads may safely
  98                  *        be performed on the buffer.
  99                  *
 100                  *  \param[in] Buffer  Pointer to a ring buffer structure whose count is to be computed
 101                  */
 102                 static inline RingBuff_Count_t RingBuffer_GetCount(RingBuff_t* const Buffer)
 103                 {
 104                         RingBuff_Count_t Count;
 105
 106                         ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
 107                         {
 108                                 Count = Buffer->Count;
 109                         }
 110
 111                         return Count;
 112                 }
 113
 114                 /** Atomically determines if the specified ring buffer contains any free space. This should
 115                  *  be tested before storing data to the buffer, to ensure that no data is lost due to a
 116                  *  buffer overrun.
 117                  *
 118                  *  \param[in,out] Buffer  Pointer to a ring buffer structure to insert into
 119                  *
 120                  *  \return Boolean true if the buffer contains no free space, false otherwise
 121                  */
 122                 static inline bool RingBuffer_IsFull(RingBuff_t* const Buffer)
 123                 {
 124                         return (RingBuffer_GetCount(Buffer) == BUFFER_SIZE);
 125                 }
 126
 127                 /** Atomically determines if the specified ring buffer contains any data. This should
 128                  *  be tested before removing data from the buffer, to ensure that the buffer does not
 129                  *  underflow.
 130                  *
 131                  *  If the data is to be removed in a loop, store the total number of bytes stored in the
 132                  *  buffer (via a call to the \ref RingBuffer_GetCount() function) in a temporary variable
 133                  *  to reduce the time spent in atomicity locks.
 134                  *
 135                  *  \param[in,out] Buffer  Pointer to a ring buffer structure to insert into
 136                  *
 137                  *  \return Boolean true if the buffer contains no free space, false otherwise
 138                  */
 139                 static inline bool RingBuffer_IsEmpty(RingBuff_t* const Buffer)
 140                 {
 141                         return (RingBuffer_GetCount(Buffer) == 0);
 142                 }
 143
 144                 /** Inserts an element into the ring buffer.
 145                  *
 146                  *  \note Only one execution thread (main program thread or an ISR) may insert into a single buffer
 147                  *        otherwise data corruption may occur. Insertion and removal may occur from different execution
 148                  *        threads.
 149                  *
 150                  *  \param[in,out] Buffer  Pointer to a ring buffer structure to insert into
 151                  *  \param[in]     Data    Data element to insert into the buffer
 152                  */
 153                 static inline void RingBuffer_Insert(RingBuff_t* const Buffer,
 154                                                      const RingBuff_Data_t Data)
 155                 {
 156                         *Buffer->In = Data;
 157
 158                         if (++Buffer->In == &Buffer->Buffer[BUFFER_SIZE])
 159                           Buffer->In = Buffer->Buffer;
 160
 161                         ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
 162                         {
 163                                 Buffer->Count++;
 164                         }
 165                 }
 166
 167                 /** Removes an element from the ring buffer.
 168                  *
 169                  *  \note Only one execution thread (main program thread or an ISR) may remove from a single buffer
 170                  *        otherwise data corruption may occur. Insertion and removal may occur from different execution
 171                  *        threads.
 172                  *
 173                  *  \param[in,out] Buffer  Pointer to a ring buffer structure to retrieve from
 174                  *
 175                  *  \return Next data element stored in the buffer
 176                  */
 177                 static inline RingBuff_Data_t RingBuffer_Remove(RingBuff_t* const Buffer)
 178                 {
 179                         RingBuff_Data_t Data = *Buffer->Out;
 180
 181                         if (++Buffer->Out == &Buffer->Buffer[BUFFER_SIZE])
 182                           Buffer->Out = Buffer->Buffer;
 183
 184                         ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
 185                         {
 186                                 Buffer->Count--;
 187                         }
 188
 189                         return Data;
 190                 }
 191
 192 #endif