BufferManager.hpp

Go to the documentation of this file.

// ====================================================================== 
// \title  BufferManager.hpp
// \author bocchino
// \brief  hpp file for BufferManager component implementation class
//
// \copyright
// Copyright 2015-2017, by the California Institute of Technology.
// ALL RIGHTS RESERVED.  United States Government Sponsorship
// acknowledged.
// 
// ====================================================================== 
 
#ifndef BufferManager_HPP
#define BufferManager_HPP
 
#include "Svc/BufferManager/BufferManagerComponentAc.hpp"
 
namespace Svc {
 
  class BufferManager :
    public BufferManagerComponentBase
  {
 
    PRIVATE:
 
      // ---------------------------------------------------------------------- 
      // Warnings
      // ---------------------------------------------------------------------- 
 
      class Warnings {
 
        public:
 
          struct Status {
 
            typedef enum {
              SUCCESS,
              STORE_SIZE_EXCEEDED,
              TOO_MANY_BUFFERS,
            } t;
 
          };
 
        PRIVATE:
 
          struct State {
 
            State(void);
 
            bool storeSizeExceeded;
 
            bool tooManyBuffers;
 
          };
 
        public:
 
          Warnings(
              BufferManager& bufferManager 
          );
 
        public:
 
          void update(
              const Status::t status 
          );
 
        PRIVATE:
 
          BufferManager& bufferManager;
 
          State state;
 
      };
 
    PRIVATE:
 
      // ----------------------------------------------------------------------
      // The store 
      // ----------------------------------------------------------------------
 
      class Store {
 
        public:
 
          // ----------------------------------------------------------------------
          // Construction and destruction 
          // ----------------------------------------------------------------------
 
          // Construct a Store
          Store(
              const U32 size
          );
 
          // Destroy a Store
          ~Store(void);
 
        public:
 
          // ----------------------------------------------------------------------
          // Types 
          // ----------------------------------------------------------------------
 
          typedef enum { SUCCESS, FAILURE } Status;
 
        public:
 
          // ----------------------------------------------------------------------
          // Methods 
          // ----------------------------------------------------------------------
 
          // Get the number of bytes currently allocated
          U32 getAllocatedSize(void) const;
 
          // Allocate n bytes on the store
          Status allocate(
              const U32 n,
              U8* &result
          );
 
          // Free bytes from the store
          void free(
              const U32 size, 
              U8 *const address 
          );
 
        PRIVATE:
 
          // ----------------------------------------------------------------------
          // Constants
          // ----------------------------------------------------------------------
 
          // The size of the store
          const U32 totalSize;
 
          // Pointer to the base of the store memory
          U8 *const memoryBase;
 
          // ----------------------------------------------------------------------
          // Variables
          // ----------------------------------------------------------------------
         
          U32 freeIndex;
 
          U32 padSize;
 
          U32 allocatedSize;
 
      };
 
    PRIVATE:
 
      // ---------------------------------------------------------------------- 
      // The allocation queue
      // ---------------------------------------------------------------------- 
 
      class AllocationQueue {
 
        public:
 
          // ----------------------------------------------------------------------
          // Construction and destruction 
          // ----------------------------------------------------------------------
 
          // Construct an AllocationQueue
          AllocationQueue(const U32 size);
 
          // Destroy an AllocationQueue
          ~AllocationQueue(void);
 
        public:
 
          // ----------------------------------------------------------------------
          // Types 
          // ----------------------------------------------------------------------
 
          // Allocation status
          struct Allocate {
 
            typedef enum {
              SUCCESS, // Allocation OK
              FULL // No more room
            } Status;
 
          };
 
          // Free status
          struct Free {
 
            typedef enum {
              SUCCESS, // Free OK
              EMPTY, // Nothing to free
              ID_MISMATCH // ID supplied was not at head of queue
            } Status;
 
          };
 
          // An entry in the queue
          typedef struct {
            U32 id;
            U32 size;
          } Entry;
 
        public:
 
          // ----------------------------------------------------------------------
          // Public methods
          // ----------------------------------------------------------------------
 
          // Get the number of buffers currently allocated
          U32 getAllocationSize(void) const;
        
          // Record an allocation of size 'size' and generate a new id
          Allocate::Status allocate(
              const U32 size,
              U32& id
          );
 
          // Record a deallocation
          Free::Status free(
              const U32 expectedId,
              U32& sawId,
              U32& size
          );
 
        PRIVATE:
 
          // ----------------------------------------------------------------------
          // Private methods
          // ----------------------------------------------------------------------
        
          // Get the next ID
          U32 getNextId(void);
 
          // Update a circular index
          U32 getNextIndex(const U32 index);
 
        PRIVATE:
 
          // ----------------------------------------------------------------------
          // Constants
          // ---------------------------------------------------------------------- 
 
          // The queue size
          const U32 totalSize;
 
          // Pointer to the queue data
          Entry *const data;
 
        PRIVATE:
 
          // ----------------------------------------------------------------------
          // Variables
          // ---------------------------------------------------------------------- 
 
          // The next id
          U32 nextId;
 
          // Index into the allocation end of the queue
          U32 allocateIndex;
 
          // Index into the free end of the queue
          U32 freeIndex;
 
          // Number of elements allocated
          U32 allocationSize;
 
      };
 
    public:
 
      // ----------------------------------------------------------------------
      // Construction, initialization, and destruction
      // ----------------------------------------------------------------------
 
      BufferManager(
          const char *const compName, 
          const U32 storeSize,
          const U32 maxNumBuffers
      );
 
      void init(
          const NATIVE_INT_TYPE instance 
      );
 
      ~BufferManager(void);
 
    PRIVATE:
 
      // ----------------------------------------------------------------------
      // Handler implementations for user-defined typed input ports
      // ----------------------------------------------------------------------
 
      //
      Fw::Buffer bufferGetCallee_handler(
          NATIVE_INT_TYPE portNum, 
          U32 size 
      );
 
      void bufferSendIn_handler(
          const NATIVE_INT_TYPE portNum, 
          Fw::Buffer &buffer
      );
 
    PRIVATE:
 
      // ----------------------------------------------------------------------
      // Variables 
      // ----------------------------------------------------------------------
 
      Warnings warnings;
 
      Store store;
 
      AllocationQueue allocationQueue;
 
    };
 
}
 
#endif