ClockService.hh

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


#ifndef HH_SENF_Scheduler_ClockService_
#define HH_SENF_Scheduler_ClockService_ 1

// Custom includes
#include <boost/date_time/posix_time/posix_time.hpp>
#include <senf/config.hh>
#include <senf/Utils/singleton.hh>
#include <senf/Utils/Console/Parse.hh>

#ifdef SENF_DEBUG
#  include <senf/Utils/RestrictedInt.hh>
#endif

#ifdef SENF_DEBUG
#  define SENF_CLOCKSERVICE_CONSTEXPR
#else
#  ifdef SENF_CXX11_ENABLED
#    define SENF_CLOCKSERVICE_CONSTEXPR constexpr
#  else
#    define SENF_CLOCKSERVICE_CONSTEXPR
#  endif
#endif

//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {

    // Implementation note: The clock value is represented as a 64bit unsigned integer number of
    // nanoseconds based on the CLOCK_MONOTONIC POSIX clock.
    //
    // To allow conversion between clock value and absolute time, the ClockService samples the
    // absolute current time and the clock value when the conversion is performed. This is done at
    // most once per second on a if-needed basis.

//    namespace scheduler { ClockService::clock_type now(); }

    class ClockService
        : singleton<ClockService>
    {
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

#ifdef SENF_DEBUG
        struct ClockTypeTag {};
        typedef senf::RestrictedInt<config::time_type, ClockTypeTag> clock_type;
#else
        typedef config::time_type clock_type;
#endif        

        typedef std::int64_t int64_type;

        typedef boost::posix_time::ptime abstime_type;

        typedef boost::posix_time::time_duration reltime_type;

        //-////////////////////////////////////////////////////////////////////////

        static constexpr clock_type        maxTime = std::numeric_limits<config::time_type>::max();
        
        static clock_type now();  

        static abstime_type abstime(clock_type const & clock); 

        static reltime_type reltime(clock_type const & clock); 

        static clock_type clock(abstime_type const & time); 

        static clock_type from_time_t(time_t const & time);

        static time_t to_time_t(clock_type const & time);

        static clock_type from_timeval(timeval const & time);

        static SENF_CLOCKSERVICE_CONSTEXPR clock_type nanoseconds(int64_type const & v); 
        static SENF_CLOCKSERVICE_CONSTEXPR clock_type microseconds(int64_type const & v); 
        static SENF_CLOCKSERVICE_CONSTEXPR clock_type milliseconds(int64_type const & v); 
        static SENF_CLOCKSERVICE_CONSTEXPR clock_type seconds(int64_type const & v); 
        static SENF_CLOCKSERVICE_CONSTEXPR clock_type minutes(int64_type const & v); 
        static SENF_CLOCKSERVICE_CONSTEXPR clock_type hours(int64_type const & v); 
        static SENF_CLOCKSERVICE_CONSTEXPR clock_type days(int64_type const & v); 

        static SENF_CLOCKSERVICE_CONSTEXPR int64_type in_nanoseconds(clock_type const & v); 
        static SENF_CLOCKSERVICE_CONSTEXPR int64_type in_microseconds(clock_type const & v); 
        static SENF_CLOCKSERVICE_CONSTEXPR int64_type in_milliseconds(clock_type const & v); 
        static SENF_CLOCKSERVICE_CONSTEXPR int64_type in_seconds(clock_type const & v); 
        static SENF_CLOCKSERVICE_CONSTEXPR int64_type in_minutes(clock_type const & v); 
        static SENF_CLOCKSERVICE_CONSTEXPR int64_type in_hours(clock_type const & v); 
        static SENF_CLOCKSERVICE_CONSTEXPR int64_type in_days(clock_type const & v); 

        static void restart(); 

    private:
        ClockService();

        abstime_type abstime_m(clock_type const & clock);
        clock_type clock_m(abstime_type const & time);
        void restart_m();

        boost::posix_time::ptime baseAbstime_;
        clock_type baseClock_;

        friend class singleton<ClockService>;
    };

    void parseClockServiceInterval(console::ParseCommandInfo::TokensRange const & tokens,
                                   ClockService::clock_type & out);

    void formatClockServiceInterval(ClockService::clock_type interval, std::ostream & os);
    
    class CyclicTimestamp final
    {
    public:
        CyclicTimestamp()
            : tstamp_(0) {
        }
        CyclicTimestamp(std::uint32_t const & secs, std::uint32_t const & nsecs) {
            update(secs, nsecs);
        }
        
        void update(ClockService::clock_type const & clockType) {
            tstamp_ = std::uint32_t(std::uint64_t(senf::ClockService::in_milliseconds(clockType)) % 0x100000000ull);
        }
        
        void update(std::uint32_t const & secs, std::uint32_t const & nsecs) {
            tstamp_ = (secs * 1000) + (nsecs / 1000000);
        }
        
        std::uint32_t const & value() const {
            return tstamp_;
        }
        
        CyclicTimestamp distance(CyclicTimestamp const & other) const {
            return CyclicTimestamp(other.tstamp_ - tstamp_);
        }

        std::uint32_t distanceAsMilliseconds(CyclicTimestamp const & other) const {
            return other.tstamp_ - tstamp_;
        }

        senf::ClockService::clock_type distanceAsClockType(CyclicTimestamp const & other) const {
            return senf::ClockService::milliseconds(distanceAsMilliseconds(other));
        }
        
    private:
        CyclicTimestamp(std::uint32_t && value)
            :tstamp_(value) {
        }

        std::uint32_t tstamp_;
    };
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "ClockService.cci"
//#include "ClockService.ct"
//#include "ClockService.cti"
#endif


// Local Variables:
// mode: c++
// fill-column: 100
// comment-column: 40
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
// End: