FrameSubscriber.h

Go to the documentation of this file.

#ifndef CARMA_MONITOR_FRAME_SUBSCRIBER_H
#define CARMA_MONITOR_FRAME_SUBSCRIBER_H

#include "carma/monitor/MonitorSystem.h"
#include "carma/util/ErrorException.h"
#include "carma/util/PthreadMutex.h"
#include "carma/util/types.h"

#include <map>
#include <vector>

namespace carma {
namespace monitor {


class MonitorSystemQueueEntry;


class NullEventException : public ::carma::util::ErrorException {
  public:
    NullEventException (const ::std::string & message, 
                           const char* fileName, 
                           int lineNo) 
                   : ::carma::util::ErrorException (message, fileName, lineNo)
                   { }

    NullEventException (const ::std::ostringstream & message, 
                           const char* fileName, 
                           int lineNo) 
                   : ::carma::util::ErrorException (message, fileName, lineNo)
                   { }

    NullEventException (const ::carma::util::ErrorException& errorException)
                   : ::carma::util::ErrorException (errorException)
                   { }

    virtual ~NullEventException () throw() { }

};



    class FrameSubscriber
    {
      public:

        FrameSubscriber(double delayInS, bool   rawMode);

        ~FrameSubscriber();

        /*
         * Set scheduled first fire time for call to writeMonitorSystemToIPQ.
         * Should be called once and only once to synchronize internal timing.
         * @param firstFireTimeMJD First fire time as MJD.
         * @pre No collation takes place prior to call. 
         * @throw IllegalStateException if already called.
         * @see writeMonitorSystemToIPQ
         */
        void setFirstFireTime( double firstFireTimeMJD );


        void writeMonitorSystemToIPQ(double currentFireTimeMJD,
                                     double delayInSeconds,
                                                 int    clearDelayInFrames);
        
        void operator()( const carma::monitor::TransportSubsystemFrame & tsf );

      protected:

        void    printTimes (double timestamps[], int numTimes) const;

     private:

        void writeMonitorStatsHoldingMsMapLock( MonitorSystem & ms );
        /*
         * Clears class variables containing subsystem and totals for various
         * error counts, including late, early, and missing frames.
         */
        void clearErrorCounts();
        
        bool rawMode_;

        typedef ::std::map< carma::util::frameType,
                MonitorSystemQueueEntry * > MonitorSystemMap;

        carma::util::PthreadMutex msMapMutex_;
        MonitorSystemMap msMap_;
        bool initialized_;
        carma::util::frameType lastWriteFrame_;

        typedef ::std::map< subsystemIDType, int > SubsystemCountMap;
        typedef ::std::map< subsystemIDType, 
                            carma::util::frameType > SubsystemFrameMap;


        carma::util::PthreadMutex subsystemDataMutex_;
        SubsystemCountMap receivedSubsystemFrameCount_;
        SubsystemCountMap receivedSubsystemDataCount_;
        SubsystemCountMap lateSubsystemFrameCount_;
        SubsystemCountMap earlySubsystemFrameCount_;
        SubsystemCountMap missedSubsystemFrameCount_;
        SubsystemCountMap missedDataFrameCount_;
        SubsystemFrameMap lastReceivedSubsystemFrames_;
        
        int totalFrames_;
        int totalMissedDataFrames_;
        int totalEarlyFrames_;
        int totalLateFrames_;
        int totalMissedFrames_;

        int outOfOrderSubsystemFrames_;
        int duplicateSubsystemFrames_;
        int erroneousNotifications_;

        // Fill msMap_ with ((int)(2*delay)+1) monitor systems.
        // The delay is the writeDelay param to the frameCollator,  
        // currently 600 (0.600sec) in carmaCore.xml
        void allocateMonitorSystems(double delayInS);
        void deallocateMonitorSystems();
        void rebuildMapHoldingLock( carma::util::frameType newHeadFrame );
        void checkForWriteDiscontinuityHoldingLock( const double currentFireTimeMJD );
        
        // There are some subsystems that are not counted
        bool isMissedDataCountingEnabled(unsigned int subsystemID);
        
        // Subsystem has a timestamp MP that can be used to check transport
        bool subsystemHasTimestamp(unsigned int subsystemID);

    }; // End class FrameSubscriber

   } // End namespace monitor
} // End namespace carma

#endif // CARMA_MONITOR_FRAME_SUBSCRIBER_H