Re: [avr-gcc-list] Re: Device fuses

[Dave Hylands]

> WOW. I will definitely study your message. It will take time to all of us.
> But my scepticism was not about templates but about writing embedded code in
> C++ instead of C/Assembler/InlineAssembler. Interesting what would you get
> if you would write one more example in plain good C.

I pasted some circular buffer code that I did. In C & C++, I used
macros in C, and in C++ I used a template.

I did a bunch of analysis, and the C++ is very close in size to the C
one. The biggest size differences are all related to how unit8_t's get
promoted to ints.

The C++ version is also missing a bit of functionality but it would be
easy to add. I think at the time I didn't fully appreciate what was
affecting the size and could probably get the C++ one to be as small
as the C one now that I understand whats going on.

--
Dave Hylands
Vancouver, BC, Canada
http://www.DaveHylands.com/

/****************************************************************************
*
*   Since this code originated from code which is public domain, I
*   hereby declare this code to be public domain as well.
*
****************************************************************************/
/**
*
*   @file   CBUF.h
*
*   @brief  This file contains global definitions for circular buffer
*           manipulation.
*
*   These macros implement a circular buffer which employs get and put
*   pointers, in such a way that mutual exclusion is not required
*   (assumes one reader & one writer).
*
*   It requires that the circular buffer size be a power of two, and the
*   size of the buffer needs to smaller than the index. So an 8 bit index
*   supports a circular buffer upto ( 1 << 7 ) = 128 entries, and a 16 bit index
*   supports a circular buffer upto ( 1 << 15 ) = 32768 entries.
*
*   The basis for these routines came from an article in Jack Ganssle's
*   Embedded Muse: http://www.ganssle.com/tem/tem110.pdf
*
*   In order to offer the most amount of flexibility for embedded environments
*   you need to define a macro for the size.
*
*   First, you need to name your circular buffer. For this example, we'll
*   call it myQ.
*
*   The size macro that needs to be defined will be the name of the
*   circular buffer followed by _SIZE. The size must be a power of two
*   and it needs to fit in the get/put indicies. i.e. if you use an
*   8 bit index, then the maximum supported size would be 128.
*
*   The structure which defines the circular buffer needs to have 3 members
*   m_getIdx, m_putIdx, and m_entry.
*
*   m_getIdx and m_putIdx need to be unsigned integers of the same size.
*
*   m_entry needs to be an array of xxx_SIZE entries, or a pointer to an
*   array of xxx_SIZE entries. The type of each entry is entirely up to the
*   caller.
*
*   #define myQ_SIZE    64
*
*   volatile struct
*   {
*       uint8_t     m_getIdx;
*       uint8_t     m_putIdx;
*       uint8_t     m_entry[ myQ_SIZE ];
*
*   } myQ;
*
*   You could then use
*
*       CBUF_Push( myQ, 'x' );
*
*   to add a character to the circular buffer, or
*
*       ch = CBUF_Pop( myQ );
*
*   to retrieve an element from the buffer.
*
*   If you happen to prefer to use C++ instead, there is a templatized
*   version which requires no macros. You just declare 3 template parameters:
*
*       - The type that should be used for the index
*       - The size of the circular buffer
*       - The type that should be used for the entry
*
*   For example:
*
*       CBUF< uint8_t, 64, char >   myQ;
*
****************************************************************************/

#if !defined( CBUF_H )
#define CBUF_H       /**< Include Guard                          */

/* ---- Include Files ---------------------------------------------------- */

/* ---- Constants and Types ---------------------------------------------- */

/**
*   Initializes the circular buffer for use.
*/

#define CBUF_Init( cbuf )       cbuf.m_getIdx = cbuf.m_putIdx = 0

/**
*   Returns the number of elements which are currently contained in the
*  circular buffer.
*/

#define CBUF_Len( cbuf )        ((typeof( cbuf.m_putIdx ))((
cbuf.m_putIdx ) - ( cbuf.m_getIdx )))

/**
*   Appends an element to the end of the circular buffer
*/

#define CBUF_Push( cbuf, elem ) (cbuf.m_entry)[ cbuf.m_putIdx++ & ((
cbuf##_SIZE ) - 1 )] = (elem)

/**
*   Returns a pointer to the last spot that was pushed.
*/

#define CBUF_GetLastEntryPtr( cbuf ) &(cbuf.m_entry)[ ( cbuf.m_putIdx
- 1 ) & (( cbuf##_SIZE ) - 1 )]

/**
*   Returns a pointer to the next spot to push.
*/

#define CBUF_GetPushEntryPtr( cbuf ) &(cbuf.m_entry)[ cbuf.m_putIdx &
(( cbuf##_SIZE ) - 1 )]

/**
*   Advances the put index.
*/

#define CBUF_AdvancePushIdx( cbuf )  cbuf.m_putIdx++

/**
*   Retrieves an element from the beginning of the circular buffer
*/

#define CBUF_Pop( cbuf )        (cbuf.m_entry)[ cbuf.m_getIdx++ & ((
cbuf##_SIZE ) - 1 )]

/**
*   Retrieves the i'th element from the beginning of the circular buffer
*/

#define CBUF_Get( cbuf, idx )        (cbuf.m_entry)[( cbuf.m_getIdx +
idx ) & (( cbuf##_SIZE ) - 1 )]

/**
*   Retrieves the i'th element from the end of the circular buffer
*/

#define CBUF_GetEnd( cbuf, idx )        (cbuf.m_entry)[( cbuf.m_putIdx
- idx - 1 ) & (( cbuf##_SIZE ) - 1 )]

/**
*   Returns a pointer to the next spot to push.
*/

#define CBUF_GetPopEntryPtr( cbuf ) &(cbuf.m_entry)[ cbuf.m_getIdx &
(( cbuf##_SIZE ) - 1 )]

/**
*   Advances the put index.
*/

#define CBUF_AdvancePopIdx( cbuf )  cbuf.m_getIdx++

/**
*   Determines if the circular buffer is empty
*/

#define CBUF_IsEmpty( cbuf )    ( CBUF_Len( cbuf ) == 0 )

/**
*   Determines if the circular buffer is full.
*/

#define CBUF_IsFull( cbuf )     ( CBUF_Len( cbuf ) == ( cbuf##_SIZE ))

/**
*   Determines if the circular buffer is currenly overflowed or underflowed.
*/

#define CBUF_Error( cbuf )      ( CBUF_Len( cbuf ) > cbuf##_SIZE )

#if defined( __cplusplus )

template < class IndexType, unsigned Size, class EntryType >
class CBUF
{
public:

   CBUF()
   {
       m_getIdx = m_putIdx = 0;
   }

   IndexType Len() const   { return m_putIdx - m_getIdx; }

   bool IsEmpty() const    { return Len() == 0; }
   bool IsFull() const     { return Len() == Size; }
   bool Error() const      { return Len() > Size; }

   void Push( EntryType val )
   {
       m_entry[ m_putIdx++ & ( Size - 1 )] = val;
   }

   EntryType Pop()
   {
       return m_entry[ m_getIdx++ & ( Size - 1 )];
   }

private:

   volatile IndexType  m_getIdx;
   volatile IndexType  m_putIdx;
   EntryType           m_entry[ Size ];

};

#endif  // __cplusplus

/* ---- Variable Externs ------------------------------------------------- */
/* ---- Function Prototypes ---------------------------------------------- */

/** @} */

#endif // CBUF_H

CBUF.h
Description: Text Data