dispatcher.hpp

Go to the documentation of this file.

/*
  DISPATCHER.hpp  -  translating calculation streams into frame jobs

   Copyright (C)
     2011,            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_ENGINE_DISPATCHER_H
#define STEAM_ENGINE_DISPATCHER_H

#include "steam/common.hpp"
#include "steam/mobject/model-port.hpp"
#include "steam/engine/job-ticket.hpp"
#include "steam/engine/job-planning.hpp"
#include "steam/play/timings.hpp"
#include "steam/play/output-slot.hpp"
#include "lib/iter-explorer.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/nocopy.hpp"

#include <functional>
#include <utility>
#include <tuple>


namespace steam {
namespace engine {
  
  using std::move;
  using std::make_pair;
  using mobject::ModelPort;
  using play::Timings;
  using play::DataSink;
  using lib::time::TimeValue;
  using lib::time::TimeSpan;
  using lib::time::FrameCnt;
  using lib::time::FSecs;
  using lib::time::Time;
  
  
  class Dispatcher
    : util::NonCopyable
    {
      
      struct PipeFrameTick;
      
      template<class IT>
      struct PipelineBuilder;
      
      
    public:
      virtual ~Dispatcher();  
      
      
      PipelineBuilder<PipeFrameTick> forCalcStream (Timings timings);
      
      template<class IT>
      class PlanningPipeline;
      
      virtual size_t resolveModelPort (ModelPort)                                  =0;
      
      virtual JobTicket& getJobTicketFor (size_t portIDX, TimeValue nominalTime)   =0;
      
      Job createJobFor (size_t portIDX, TimeValue nominalTime);
    };
  
  
  
  
  /* ======== Steps of the Job-planning Pipeline ======== */
  
  struct Dispatcher::PipeFrameTick
    {
      Dispatcher * const dispatcher;
      const Timings      timings;
      
      TimeVar currPoint{Time::NEVER};
      TimeVar stopPoint{Time::NEVER};
      FrameCnt frameNr{0};
      
      
      
      /* === state protocol API for IterStateWrapper === */
      bool
      checkPoint()  const
        {
          return currPoint < stopPoint;
        }
      
      TimeVar const&
      yield()  const
        {
          return currPoint;
        }
      
      void
      iterNext()
        {
          ++frameNr;
          currPoint = timings.getFrameStartAt (frameNr);
        }
      
    protected:
      void
      activate (Time start, Time after)
        {
          stopPoint = after;
          frameNr = timings.getBreakPointAfter(start);
          currPoint = timings.getFrameStartAt (frameNr);
        }
    };
  
  
  
  
  template<class SRC>
  struct Dispatcher::PipelineBuilder
    : SRC
    {
      
      auto
      timeRange (Time start, Time after)
        {
          SRC::activate (start,after);
          return buildPipeline (lib::explore (move(*this)));
        }                      // expected next to invoke pullFrom(port,sink)
      

      
      auto
      pullFrom (mobject::ModelPort port)
        {
          size_t portIDX = SRC::dispatcher->resolveModelPort(port);
          return buildPipeline (
                   SRC::transform(
                     [portIDX](PipeFrameTick& core)
                      {
                        return JobPlanning{core.dispatcher->getJobTicketFor(portIDX, core.currPoint)
                                          ,core.currPoint
                                          ,core.frameNr};
                      }));
        }
      
      
      auto
      expandPrerequisites()
        {
          return buildPipeline (
                   SRC::expandAll(
                     [](JobPlanning& currentLevel)
                      {
                        return currentLevel.buildDependencyPlanning();
                      }));
        }
      
      auto
      feedTo (play::DataSink& sink)
        {
          return terminatePipeline (
                   SRC::transform(
                     [sink](JobPlanning& currentLevel) -> JobPlanning&
                      {
                        return currentLevel;
                      })
                   .asIterator());
        }
      
      
    protected:
      template<class PIP>
      PipelineBuilder<PIP>
      buildPipeline(PIP&& treeExplorer)
        {
          return PipelineBuilder<PIP> {move (treeExplorer)};
        }
      
      template<class PIP>
      PlanningPipeline<PIP>
      terminatePipeline(PIP&& pipelineIterator)
        {
          return PlanningPipeline<PIP> {move (pipelineIterator)};
        }
    };
  
  
  template<class PIP>
  struct Dispatcher::PlanningPipeline
    : PIP
    {
      FrameCnt
      currFrameNr()  const
        {
          return PIP::frameNr;
        }
      
      bool
      isBefore (Time breakPoint)  const
        {
          return currFrameNr() < PIP::timings.getBreakPointAfter(breakPoint);
        }
      
      Job
      buildJob()
        {
          return PIP::operator->()->buildJob();
        }
      
      Time
      determineDeadline()
        {
          return PIP::operator->()->determineDeadline (PIP::timings);
        }
    };
  
  
  
  inline Dispatcher::PipelineBuilder<Dispatcher::PipeFrameTick>
  Dispatcher::forCalcStream (Timings timings)
  {
    return PipelineBuilder<PipeFrameTick> {this, timings};
  }
  
  inline Job
  Dispatcher::createJobFor (size_t portIDX, TimeValue nominalTime)
  {
    return getJobTicketFor (portIDX, nominalTime)
             .createJobFor (Time{nominalTime});
  }


  
}} // namespace steam::engine
#endif