looper.hpp

Go to the documentation of this file.

/*
  LOOPER.hpp  -  steam dispatcher loop and timing control logic
 
   Copyright (C)
     2016,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
*/
 
 
#ifndef STEAM_CONTROL_LOOPER_H
#define STEAM_CONTROL_LOOPER_H
 
#include "lib/time/timevalue.hpp"
#include "vault/real-clock.hpp"
 
#include <functional>
#include <chrono>
 
 
 
namespace steam {
namespace control {
  
  using lib::time::Time;
  using lib::time::TimeVar;
  using lib::time::Offset;
  using lib::time::Duration;
  using std::chrono::milliseconds;
  using vault::RealClock;
  
  namespace {
    const uint STEAM_DISPATCHER_BUILDER_DELAY_ms = 50;
    
    const uint STEAM_DISPATCHER_BUSY_SLOWDOWN_FACTOR = 15;
  }
  
  
  
  class Looper
    {
      using Predicate = std::function<bool(void)>;
      
      bool shutdown_ = false;
      bool disabled_ = false;
      bool inChange_ = false;
      bool hasWork_  = false;
      bool isDirty_  = false;
      
      TimeVar gotDirty_ = Time::NEVER;
      
      Predicate hasCommandsPending_;
      
        
    public:
      template<class FUN>
      Looper(FUN determine_commands_are_waiting)
        : hasCommandsPending_(determine_commands_are_waiting)
      { }
      
      // standard copy acceptable
      
      
      /* == working state logic == */
      
      bool isDying()    const  { return shutdown_; }
      bool isDisabled() const  { return disabled_ or isDying(); }
      bool useTimeout() const  { return isDirty_ and not isDisabled(); }
      bool isWorking()  const  { return hasWork_ and not isDisabled(); }
      bool idleBuild()  const  { return isDirty_ and not hasWork_; }
      bool runBuild()   const  { return (idleBuild() or forceBuild()) and not isDisabled(); }
      bool isIdle()     const  { return not (isWorking() or runBuild() or isDisabled()); }
      
      
      /* == operation control == */
      
      void
      triggerShutdown()
        {
          shutdown_ = true;
        }
      
      void
      enableProcessing(bool yes =true)
        {
          disabled_ = not yes;
        }
      
      void
      markStateProcessed()
        {
          inChange_ = false;
          if (runBuild())
            isDirty_ = false; // assume the builder has been triggered in the loop body
        }
      
      bool
      hasPendingChanges()  const  
        {
          return inChange_;
        }
      
      bool
      requireAction()
        {
          hasWork_ = hasCommandsPending_();
          bool proceedImmediately = isWorking() or forceBuild() or isDying();
          inChange_ = proceedImmediately or useTimeout();
          
          if (isWorking() and not isDirty_)
            { // schedule Builder run after timeout
              startBuilderTimeout();
              isDirty_ = true;
            }
          
          return proceedImmediately;
        }
      
      bool
      shallLoop()  const
        {
          return not isDying();
        }
      
      milliseconds
      getTimeout()  const
        {
          if (not useTimeout())
            return milliseconds::zero();
          else
            return milliseconds{
                    wakeTimeout_ms()
                    * (isDirty_ and not isWorking()? 1 : slowdownFactor())};
        }
      
      
    private:
      static uint wakeTimeout_ms();
      static uint slowdownFactor();
 
      void startBuilderTimeout();
      bool forceBuild()  const;
    };
  
  
  
  inline uint
  Looper::wakeTimeout_ms()
  {
    return STEAM_DISPATCHER_BUILDER_DELAY_ms;
  }
  
  inline uint
  Looper::slowdownFactor()
  {
    return STEAM_DISPATCHER_BUSY_SLOWDOWN_FACTOR;
  }
  
  inline void
  Looper::startBuilderTimeout()
  {
    gotDirty_ = RealClock::now();
  }
  
  inline bool
  Looper::forceBuild()  const
  {
    static Duration maxBuildTimeout{Time(wakeTimeout_ms() * slowdownFactor(), 0)};
    
    return isDirty_
       and maxBuildTimeout < Offset(gotDirty_, RealClock::now());
  }                                                                          
 
  
  
}} // namespace steam::control
#endif /*STEAM_CONTROL_LOOPER_H*/