mtsIntervalStatistics.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */
 
/*
  Author(s):  Marcin Balicki, Anton Deguet
  Created on: 2010-03-31
 
  (C) Copyright 2010-2023 Johns Hopkins University (JHU), All Rights Reserved.
 
--- begin cisst license - do not edit ---
 
This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.
 
--- end cisst license ---
*/
 

 
#ifndef _mtsIntervalStatistics_h
#define _mtsIntervalStatistics_h
 
#include <cisstCommon/cmnSerializer.h>
#include <cisstCommon/cmnDeSerializer.h>
#include <cisstCommon/cmnGenericObjectProxy.h>
#include <cisstOSAbstraction/osaTimeServer.h>
#include <cisstMultiTask/mtsGenericObject.h>
#include <cisstMultiTask/mtsGenericObjectProxy.h>
#include <cisstMultiTask/mtsCallableVoidMethod.h>
 
#include <cisstMultiTask/mtsExport.h>

class CISST_EXPORT mtsIntervalStatistics : public mtsGenericObject {
 
    CMN_DECLARE_SERVICES(CMN_DYNAMIC_CREATION, CMN_LOG_ALLOW_DEFAULT);
 
public:
    typedef unsigned long long int TimeTicksType;

    typedef mtsGenericObject BaseType;

    inline const double & PeriodAvg(void) const {
        return mPeriodAvg;
    }

    inline const double & PeriodStdDev(void) const {
        return mPeriodStdDev;
    }

    inline const double & PeriodMin(void) const {
        return mPeriodMin;
    }

    inline const double & PeriodMax(void) const {
        return mPeriodMax;
    }

    inline const double & ComputeTimeAvg(void) const {
        return mComputeTimeAvg;
    }

    inline const double & ComputeTimeStdDev(void) const {
        return mComputeTimeStdDev;
    }

    inline const double & ComputeTimeMin(void) const {
        return mComputeTimeMin;
    }

    inline const double & ComputeTimeMax(void) const {
        return mComputeTimeMax;
    }

    inline const unsigned int & NumberOfSamples(void) const {
        return mNumberOfSamples;
    }

    inline const unsigned int & NumberOfOverruns(void) const {
        return mNumberOfOverruns;
    }

    inline void SetStatisticsInterval(const double & time) {
        mStatisticsInterval = time;
    }

    inline const double & StatisticsInterval(void) const {
        return mStatisticsInterval;
    }

    void Update(const double sample, const double computeTime);

    inline void SetCallback(mtsCallableVoidBase * callback) {
        mCallback = callback;
    }
 
    template <class __classType>
    inline void SetCallback(void (__classType::*method)(void),
                            __classType * classInstantiation) {
        this->SetCallback(new mtsCallableVoidMethod<__classType>(method, classInstantiation));
    }
 
    void Reset(void);
 
    inline void SetFromExisting(const double periodAvg,
                                const double periodStdDev,
                                const double periodMin,
                                const double periodMax,
                                const double computeTimeAvg,
                                const double computeTimeStdDev,
                                const double computeTimeMin,
                                const double computeTimeMax,
                                const unsigned int numberOfSamples,
                                const unsigned int numberOfOverruns,
                                const double statisticsInterval) {
        mPeriodAvg = periodAvg;
        mPeriodStdDev = periodStdDev;
        mPeriodMin = periodMin;
        mPeriodMax = periodMax;
        mComputeTimeAvg = computeTimeAvg;
        mComputeTimeStdDev = computeTimeStdDev;
        mComputeTimeMin = computeTimeMin;
        mComputeTimeMax = computeTimeMax;
        mNumberOfSamples = numberOfSamples;
        mNumberOfOverruns = numberOfOverruns;
        mStatisticsInterval = statisticsInterval;
    }
    
private:

    double mPeriodSum;
    double mPeriodSumSquares;
    double mPeriodRunningMin;
    double mPeriodRunningMax;
    double mComputeTimeSum;
    double mComputeTimeSumSquares;
    double mComputeTimeRunningMin;
    double mComputeTimeRunningMax;
    unsigned int mRunningNumberOfSamples;
    unsigned int mRunningNumberOfOverruns;
    double mLastUpdateTime;

    const osaTimeServer * mTimeServer;

    double mPeriodAvg;
    double mPeriodStdDev;
    double mPeriodMin;
    double mPeriodMax;
    double mComputeTimeAvg;
    double mComputeTimeStdDev;
    double mComputeTimeMin;
    double mComputeTimeMax;
    unsigned int mNumberOfSamples;
    unsigned int mNumberOfOverruns;

    double mStatisticsInterval;

    mtsCallableVoidBase * mCallback;
 
public:
 
    mtsIntervalStatistics();
    inline ~mtsIntervalStatistics() {};

    void ToStream(std::ostream & outputStream) const override;

    void ToStreamRaw(std::ostream & outputStream, const char delimiter = ' ',
                     bool headerOnly = false, const std::string & headerPrefix = "") const override;

    void SerializeRaw(std::ostream & outputStream) const override;

    void DeSerializeRaw(std::istream & inputStream) override;
};
 
CMN_DECLARE_SERVICES_INSTANTIATION(mtsIntervalStatistics)
 
#endif // _mtsIntervalStatistics_h