LCOV - code coverage report
Current view: top level - libMagAOX/logger/types - telem_saving.hpp (source / functions) Coverage Total Hit
Test: MagAOX Lines: 41.5 % 41 17
Test Date: 2026-01-03 21:03:39 Functions: 30.0 % 10 3

            Line data    Source code
       1              : /** \file telem_saving.hpp
       2              :   * \brief The MagAO-X logger telem_saving log type.
       3              :   * \author Jared R. Males (jaredmales@gmail.com)
       4              :   *
       5              :   * \ingroup logger_types_files
       6              :   *
       7              :   * History:
       8              :   * - 2019-05-04 created by JRM
       9              :   */
      10              : #ifndef logger_types_telem_saving_hpp
      11              : #define logger_types_telem_saving_hpp
      12              : 
      13              : #include "generated/telem_saving_generated.h"
      14              : #include "flatbuffer_log.hpp"
      15              : 
      16              : namespace MagAOX
      17              : {
      18              : namespace logger
      19              : {
      20              : 
      21              : 
      22              : /// Log entry recording data saving statistics
      23              : /** \ingroup logger_types
      24              :   */
      25              : struct telem_saving : public flatbuffer_log
      26              : {
      27              :    ///The event code
      28              :    static const flatlogs::eventCodeT eventCode = eventCodes::TELEM_SAVING;
      29              : 
      30              :    ///The default level
      31              :    static const flatlogs::logPrioT defaultLevel = flatlogs::logPrio::LOG_TELEM;
      32              : 
      33              :    static timespec lastRecord; ///< The time of the last time this log was recorded.  Used by the telemetry system.
      34              : 
      35              :    ///The type of the input message
      36              :    struct messageT : public fbMessage
      37              :    {
      38              :       ///Construct from components
      39            6 :       messageT( const uint32_t & rawSize,
      40              :                 const uint32_t & compressedSize,
      41              :                 const float & encodeRate,
      42              :                 const float & differenceRate,
      43              :                 const float & reorderRate,
      44              :                 const float & compressRate
      45              :               )
      46            6 :       {
      47            6 :          auto fp = Createtelem_saving_fb(builder, rawSize,compressedSize, encodeRate, differenceRate, reorderRate, compressRate);
      48            6 :          builder.Finish(fp);
      49            6 :       }
      50              : 
      51              :    };
      52              : 
      53            2 :    static bool verify( flatlogs::bufferPtrT & logBuff,  ///< [in] Buffer containing the flatbuffer serialized message.
      54              :                        flatlogs::msgLenT len            ///< [in] length of msgBuffer.
      55              :                      )
      56              :    {
      57            2 :       auto verifier = flatbuffers::Verifier( static_cast<uint8_t*>(flatlogs::logHeader::messageBuffer(logBuff)), static_cast<size_t>(len));
      58            4 :       return Verifytelem_saving_fbBuffer(verifier);
      59              :    }
      60              : 
      61              :    ///Get the message formatte for human consumption.
      62            0 :    static std::string msgString( void * msgBuffer,  /**< [in] Buffer containing the flatbuffer serialized message.*/
      63              :                                  flatlogs::msgLenT len  /**< [in] [unused] length of msgBuffer.*/
      64              :                                )
      65              :    {
      66              :       static_cast<void>(len);
      67              : 
      68            0 :       auto fbs = Gettelem_saving_fb(msgBuffer);
      69              : 
      70              : 
      71            0 :       std::stringstream s;
      72            0 :       s << "Saved " << ((float)fbs->raw_size())/1048576.0 << " MB @ " << ((float) fbs->compressed_size() )/((float) fbs->raw_size()) << "%.";
      73            0 :       return s.str();
      74              : 
      75            0 :    }
      76              : 
      77            0 :    static unsigned int raw_size( void * msgBuffer  /**< [in] Buffer containing the flatbuffer serialized message.*/ )
      78              :    {
      79            0 :       auto fbs = Gettelem_saving_fb(msgBuffer);
      80              : 
      81            0 :       return fbs->raw_size();
      82              :    }
      83              : 
      84            0 :    static unsigned int compressed_size( void * msgBuffer  /**< [in] Buffer containing the flatbuffer serialized message.*/ )
      85              :    {
      86            0 :       auto fbs = Gettelem_saving_fb(msgBuffer);
      87              : 
      88            0 :       return fbs->compressed_size();
      89              :    }
      90              : 
      91            0 :    static float encode_rate( void * msgBuffer  /**< [in] Buffer containing the flatbuffer serialized message.*/ )
      92              :    {
      93            0 :       auto fbs = Gettelem_saving_fb(msgBuffer);
      94              : 
      95            0 :       return fbs->encode_rate();
      96              :    }
      97              : 
      98            0 :    static float difference_rate( void * msgBuffer  /**< [in] Buffer containing the flatbuffer serialized message.*/ )
      99              :    {
     100            0 :       auto fbs = Gettelem_saving_fb(msgBuffer);
     101              : 
     102            0 :       return fbs->difference_rate();
     103              :    }
     104              : 
     105            0 :    static float reorder_rate( void * msgBuffer  /**< [in] Buffer containing the flatbuffer serialized message.*/ )
     106              :    {
     107            0 :       auto fbs = Gettelem_saving_fb(msgBuffer);
     108              : 
     109            0 :       return fbs->reorder_rate();
     110              :    }
     111              : 
     112            0 :    static float compress_rate( void * msgBuffer  /**< [in] Buffer containing the flatbuffer serialized message.*/ )
     113              :    {
     114            0 :       auto fbs = Gettelem_saving_fb(msgBuffer);
     115              : 
     116            0 :       return fbs->compress_rate();
     117              :    }
     118              : 
     119              :    /// Get the logMetaDetail for a member by name
     120              :    /**
     121              :      * \returns the a logMetaDetail filled in with the appropriate details
     122              :      * \returns an empty logMetaDetail if member not recognized
     123              :      */
     124            1 :    static logMetaDetail getAccessor( const std::string & member /**< [in] the name of the member */ )
     125              :    {
     126            1 :       if(     member == "raw_size") return logMetaDetail({"RAW SIZE", "archive raw sized", logMeta::valTypes::UInt, logMeta::metaTypes::State, reinterpret_cast<void*>(&raw_size), false});
     127            1 :       else if( member == "compressed_size") return logMetaDetail({"COMPRESSED SIZE", "archive compressed sized", logMeta::valTypes::UInt, logMeta::metaTypes::State, reinterpret_cast<void*>(&compressed_size), false});
     128            1 :       else if( member == "encode_sate") return logMetaDetail({"ENCODE RATE", "encoding rate [MB/s]", logMeta::valTypes::Double, logMeta::metaTypes::State, reinterpret_cast<void*>(&encode_rate), false});
     129            1 :       else if( member == "difference_rate") return logMetaDetail({"DIFFERENCING RATE", "differencing rate [MB/s]", logMeta::valTypes::Double, logMeta::metaTypes::State, reinterpret_cast<void*>(&difference_rate), false});
     130            1 :       else if( member == "reorder_rate") return logMetaDetail({"REORDERING RATE", "reordering rate [MB/s]", logMeta::valTypes::Double, logMeta::metaTypes::State, reinterpret_cast<void*>(&reorder_rate), false});
     131            1 :       else if( member == "compress_rate") return logMetaDetail({"COMPRESSION RATE", "compression rate [MB/s]", logMeta::valTypes::Double, logMeta::metaTypes::State, reinterpret_cast<void*>(&compress_rate), false});
     132              :       else
     133              :       {
     134            1 :          std::cerr << "No member " << member << " in telem_saving\n";
     135            1 :          return logMetaDetail();
     136              :       }
     137              :     }
     138              : 
     139              : }; //telem_saving
     140              : 
     141              : 
     142              : } //namespace logger
     143              : } //namespace MagAOX
     144              : 
     145              : #endif //logger_types_telem_saving_hpp
        

Generated by: LCOV version 2.0-1