TimerEventProxy.ct

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
//


/** \file
    \brief TimerEventProxy non-inline template implementation */

// Custom includes
#include <senf/Utils/membind.hh>
#include <senf/Scheduler/Scheduler.hh>

#define prefix_
//-/////////////////////////////////////////////////////////////////////////////////////////////////

template<typename IdType>
prefix_ senf::scheduler::TimerEventProxy<IdType>::ChangeTimeout::ChangeTimeout(senf::ClockService::clock_type const & t)
    : timeout_(t)
{}

template<typename IdType>
prefix_ void senf::scheduler::TimerEventProxy<IdType>::ChangeTimeout::operator()(Entry & entry)
{
    entry.timeout = timeout_;
}

template<typename IdType>
prefix_ senf::scheduler::TimerEventProxy<IdType>::TimerEventProxy(std::string const & description, ClockService::clock_type const & callbackDurationThreshold, DurationExceededCallback decb)
    : entrySetById_( entrySet_.template get<Id>()),
      entrySetByTimeout_( entrySet_.template get<Timeout>()),
      timer_( "TimerEventProxy " + description, membind(&TimerEventProxy<IdType>::timerEvent, this)),
      callbackDurationThreshold_(callbackDurationThreshold),
      durationExceededCallback_(decb)
{}

template<typename IdType>
prefix_ void senf::scheduler::TimerEventProxy<IdType>::timerEvent()
{
    ClockService::clock_type now (callbackDurationThreshold_ ? ClockService::now() : scheduler::now());
    typename EntrySetByTimeout_t::iterator it = entrySetByTimeout_.begin();
    while (it != entrySetByTimeout_.end() && it->timeout <= now) {
        Entry item (*it);
        // remove due entry from set
        entrySetByTimeout_.erase(it);
        // call callback
        item.cb(now, item.id);
        it = entrySetByTimeout_.begin();
        if (callbackDurationThreshold_) {
            ClockService::clock_type tend ( ClockService::now());
            callbackDurations_.accumulate(ClockService::in_milliseconds(tend - now));
            if (durationExceededCallback_ and ((tend - now) > callbackDurationThreshold_)) {
                durationExceededCallback_(item.id, tend - now, callbackDurations_.data());
            }
            now = tend;
        }
    }
    if (entrySet_.size() > 0)
        timer_.timeout(entrySetByTimeout_.begin()->timeout);
}

template<typename IdType>
prefix_ void senf::scheduler::TimerEventProxy<IdType>::add(
        ClockService::clock_type const &timeout, IdType const & id, Callback cb)
{
    // insert new entry or replace the timeout of an entry already indexed
    typename EntrySetById_t::iterator it = entrySetById_.find(id);
    if (it == entrySetById_.end())
        entrySet_.insert( Entry(timeout, id, cb));
    else
        entrySetById_.modify( it, ChangeTimeout(timeout));
    // the scheduler time to the first earliest timeout (ordered index)
    timer_.timeout( entrySetByTimeout_.begin()->timeout);
}

template<typename IdType>
prefix_ bool senf::scheduler::TimerEventProxy<IdType>::remove(IdType const & id)
{
    bool removed (entrySetById_.erase(id) > 0);
    if (entrySet_.size() > 0)
        timer_.timeout(entrySetByTimeout_.begin()->timeout);
    else
        timer_.disable();
    return removed;
}

template<typename IdType>
prefix_ senf::ClockService::clock_type senf::scheduler::TimerEventProxy<IdType>::timeout(IdType const & id)
    const
{
    typename EntrySetById_t::const_iterator it (entrySetById_.find( id));
    return it == entrySetById_.end() ? ClockService::clock_type(0) : it->timeout;
}

template<typename IdType>
prefix_ std::vector<std::pair<senf::ClockService::clock_type, IdType> > senf::scheduler::TimerEventProxy<IdType>::list()
    const
{
    std::vector<std::pair<ClockService::clock_type, IdType> > tmp;
    typename EntrySetByTimeout_t::const_iterator it;
    for (it = entrySetByTimeout_.begin(); it != entrySetByTimeout_.end(); ++it)
        tmp.push_back(std::make_pair( it->timeout, it->id));
    return tmp;
}

template<typename IdType>
prefix_ unsigned senf::scheduler::TimerEventProxy<IdType>::numEvents()
  const
{
    return entrySet_.size();
}

template<typename IdType>
prefix_ void senf::scheduler::TimerEventProxy<IdType>::clear()
{
    entrySet_.clear();
    timer_.disable();
}

template<typename IdType>
prefix_ senf::StatisticsData senf::scheduler::TimerEventProxy<IdType>::callbackDurationStats()
{
    auto tmp (callbackDurations_.data());
    callbackDurations_.clear();
    return tmp;
}


//-/////////////////////////////////////////////////////////////////////////////////////////////////
#undef prefix_

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