job-planning.hpp

Go to the documentation of this file.

/*
  JOB-PLANNING.hpp  -  steps to prepare and build render jobs

   Copyright (C)
     2012,            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_JOB_PLANNING_H
#define STEAM_ENGINE_JOB_PLANNING_H

#include "steam/common.hpp"
#include "vault/gear/job.h"
#include "steam/engine/job-ticket.hpp"
#include "steam/play/output-slot.hpp"
#include "steam/play/timings.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/itertools.hpp"
#include "lib/nocopy.hpp"



namespace steam {
namespace engine {
  
  namespace error = lumiera::error;

  using play::DataSink;
  using play::Timings;
  using lib::time::Time;
  using lib::time::TimeVar;
  using lib::time::Duration;
  using vault::gear::Job;
  
  
  
  class JobPlanning
    : util::MoveOnly
    {
      JobTicket&      jobTicket_;
      TimeVar  const& nominalTime_;
      FrameCnt const& frameNr_;

    public:
      JobPlanning (JobTicket& ticket, TimeVar const& nominalTime, FrameCnt const& frameNr)
        : jobTicket_{ticket}
        , nominalTime_{nominalTime}
        , frameNr_{frameNr}
        { }
      
      // move construction is possible
      
      
      JobTicket& ticket()     { return jobTicket_; }
      bool isTopLevel() const { return not dependentPlan_; }
      
      
      Job
      buildJob()
        {
          Job job = jobTicket_.createJobFor (Time{nominalTime_});
          return job;
        }
      
      Time
      determineDeadline(Timings const& timings)
        {
          switch (timings.playbackUrgency)
            {
            case play::ASAP:
            case play::NICE:
              return Time::ANYTIME;
            
            case play::TIMEBOUND:
              return doCalcDeadline (timings);
            }
          NOTREACHED ("unexpected playbackUrgency");
        }
      
      Duration
      determineLeeway(Timings const&)
        {
          UNIMPLEMENTED ("Job planning logic to establish Leeway for scheduling");
        }
      
      
      auto
      buildDependencyPlanning()
        {
          return lib::transformIterator (jobTicket_.getPrerequisites()
                                        ,[this](JobTicket& prereqTicket)
                                                {
                                                  return JobPlanning{*this, prereqTicket};
                                                });
        }

    private:
      JobPlanning* dependentPlan_{nullptr};
      
      JobPlanning (JobPlanning& parent, JobTicket& prerequisite)
        : jobTicket_{prerequisite}
        , nominalTime_{parent.nominalTime_}
        , frameNr_{parent.frameNr_}
        , dependentPlan_{&parent}
        { }
      
      
      Time
      doCalcDeadline(Timings const& timings)
        {
          if (isTopLevel())
            return timings.getTimeDue(frameNr_)                  // anchor at timing grid
                 - jobTicket_.getExpectedRuntime()               // deduce the presumably runtime
                 - timings.engineLatency                         // and the generic engine overhead
                 - timings.outputLatency;                        // Note: output latency only on top-level job
          else
            return dependentPlan_->determineDeadline (timings)   
                 - jobTicket_.getExpectedRuntime()
                 - timings.engineLatency;
        }
    };
  
  
  
}}// namespace steam::engine
#endif /*STEAM_ENGINE_JOB_PLANNING_H*/