looper.hpp

Go to the documentation of this file.

/*
  LOOPER.hpp  -  steam dispatcher loop and timing control logic

  Copyright (C)         Lumiera.org
    2016,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


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