GmManagedArrayRingBuffer.hpp

#ifndef GMMANAGEDARRAYRINGBUFFER_HPP_
#define GMMANAGEDARRAYRINGBUFFER_HPP_
 
#ifdef acs
#include <ti/sysbios/knl/Semaphore.h>
#endif
 
#include "GmArrayRingBuffer.hpp"
#ifdef linux
#include <pthread.h>
#endif
 
#include <array>
 
namespace Geometrics
{
   // This is just a buffer with some synchronization.
   template <typename T, int C>
   class GmManagedArrayRingBuffer : public GmArrayRingBuffer<T,C>
   {
   public:
      // Statically defined buffer...
       GmManagedArrayRingBuffer (Semaphore_Handle  hasItemsSemaphore,
                                Bool              bOkToOverrun,
                                Bool              bNotices);
      ~GmManagedArrayRingBuffer    () /*override*/;
      int  WriteRecord       (T          *pcSource) /*override*/;
      int ReadRecord         (T          *pcDestination) /*override*/;
 
   #ifdef linux
   private:
     pthread_mutex_t m_mutex;
   #endif
 
   public:
     Semaphore_Handle mHasItemsSemaphore;
   };
 
}
 
 
#ifndef _GEO_APPDEFS_HPP
#include <GeoAppDefs.hpp>
#endif
 
#include "string.h"
 
#ifdef linux
#include <stdint.h>
#include <pthread.h>
#endif
 
#ifdef acs
#include <xdc/std.h>
#include <xdc/cfg/global.h>
#include <xdc/runtime/Error.h>
#include <xdc/runtime/System.h>
#include <xdc/runtime/Memory.h>
#include <ti/sysbios/knl/Swi.h>
#endif
#include "geotypes.hpp"
 
#include "GmRingBuffer.hpp"
#include "GmArrayRingBuffer.hpp"
//#include "GmManagedArrayRingBuffer.hpp"
 
using namespace Geometrics;
 
//#define DEBUGGING_COMPILE_ISSUES
#ifdef DEBUGGING_COMPILE_ISSUES
GmManagedArrayRingBuffer<uint32_t,20> theArray(0,true,true);
#endif
 
 
template <typename T, int C>
GmManagedArrayRingBuffer<T,C>::GmManagedArrayRingBuffer (Semaphore_Handle  hasItemsSemaphore,
                                        Bool              bOkToOverrun,
                                        Bool              bNotices)
   :  GmArrayRingBuffer<T,C>(bOkToOverrun, bNotices),
      mHasItemsSemaphore (hasItemsSemaphore)
{
  #ifdef linux
  int status = pthread_mutex_init (&m_mutex, NULL);
  #endif
#ifdef DEBUGGING_COMPILE_ISSUES
  T aTestItem;
  WriteRecord (&aTestItem);
  ReadRecord  (&aTestItem);
#endif
}
 
template <typename T, int C>
GmManagedArrayRingBuffer<T,C>::~GmManagedArrayRingBuffer ()
{
  #ifdef linux
  pthread_mutex_destroy (&m_mutex);
  #endif
}
 
// ===============================================================
// Destructive read - fetch the data and advance the read pointer.
//    The record is no longer available for reading.
// ===============================================================
template <typename T, int C>
int GmManagedArrayRingBuffer<T,C>::ReadRecord (T*   pcDestination)
{
   int                iReadBuffer;
 
   #ifdef acs
   UInt gateKey;
   gateKey = Swi_disable();
   #endif
   #ifdef linux
   pthread_mutex_lock (&m_mutex);
   #endif
 
   if (this->IsEmpty ())
   {
 
#ifdef acs
     Swi_restore (gateKey);
#endif
#ifdef linux
     pthread_mutex_unlock (&m_mutex);
#endif
      return GM_RING_BUFFER_EMPTY;
   }
 
   // Prep to read the buffer.  Don't yet mark it as having been read.
   iReadBuffer = this->m_iLastBufferRead + 1;
 
   if (iReadBuffer == this->MaxSize())
     iReadBuffer = 0;
 
   if (pcDestination != nullptr)
   {
       *pcDestination = this->GetBuffer (iReadBuffer);
   }
 
   // A data read always unsets the overrun flag.
   this->m_bNextWriteWouldOverrun = FALSE;
 
   // We are done with this buffer.  Advance the counter.
   this->m_iLastBufferRead = iReadBuffer;
//   ToggleDebug ();
 
 
#ifdef acs
   Swi_restore (gateKey);
#endif
#ifdef linux
   pthread_mutex_unlock (&m_mutex);
#endif
 
   if (pcDestination == nullptr)
      return GM_RING_BUFFER_NULL_DESTINATION;
   else
      return GM_RING_BUFFER_OK;
}
 
 
template <typename T, int C>
int GmManagedArrayRingBuffer<T,C>::WriteRecord (T*   pcSource)
{
   int iTest;
//   iTest = CheckToWrite ( iSize);
//   if (iTest == GM_RING_BUFFER_OK)
   {
       /********************************************************
        * Need to serialize access to writes.  This can get writes
        * from multiple threads, interrupts, etc.
       *********************************************************/
#ifdef acs
     UInt gateKey;
     gateKey = Swi_disable();
#endif
#ifdef linux
     pthread_mutex_lock (&m_mutex);
#endif
      iTest   = InternalWriteRecord (pcSource);
#ifdef acs
      /* Release the write lock. */
      Swi_restore (gateKey);
 
      /******************************************************
       *  Let the de-queuing logic, which is in a task, know
       * that data is available.
      ******************************************************/
      Semaphore_post (mHasItemsSemaphore);
#endif
#ifdef linux
      pthread_mutex_unlock (&m_mutex);
#endif
   }
   return iTest;
}
 
 
#endif /* GMRINGBUFFER_HPP_ */