job-ticket.hpp

Go to the documentation of this file.

/*
  JOB-TICKET.hpp  -  execution plan for 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_TICKET_H
#define STEAM_ENGINE_JOB_TICKET_H
 
#include "steam/common.hpp"
#include "vault/gear/job.h"
#include "steam/engine/exit-node.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/linked-elements.hpp"
#include "lib/util-foreach.hpp"
#include "lib/iter-adapter.hpp"
#include "lib/itertools.hpp"
#include "lib/util.hpp"
 
#include <utility>
#include <stack>
 
 
namespace steam {
namespace engine {
  
using vault::gear::Job;
using vault::gear::JobFunctor;
using vault::gear::JobClosure;        
using lib::LinkedElements;
using lib::time::Duration;
using lib::time::Time;
using util::isnil;
using lib::HashVal;
using lib::LUID;
  
  
  class JobTicket
    : util::NonCopyable
    {
      struct Prerequisite
        {
          Prerequisite* next{nullptr};  // for intrusive list
          JobTicket&    prereqTicket;
          
          template<class ALO>
          Prerequisite (ExitNode const& node, ALO& allocateTicket)
            : prereqTicket{allocateTicket (node, allocateTicket)}
          { }
        };
      using Prerequisites = LinkedElements<Prerequisite>;
      
      
      struct Provision
        {
          JobFunctor&          jobFunctor;
          ExitNode const&      exitNode;
          InvocationInstanceID invocationSeed;
          Prerequisites        prerequisites{};
          
          Provision (JobFunctor& func, ExitNode const& node, HashVal seed =0)
            : jobFunctor{func}
            , exitNode{node}
            , invocationSeed(static_cast<JobClosure&>(func).buildInstanceID(seed))      
          { }                                                                          
        };
      
      Provision provision_;
      
      
      JobTicket();      
      
      template<class ALO>
      static Provision buildProvisionSpec (ExitNode const&, ALO&);
      
      
      
    public:
      template<class ALO>
      JobTicket (ExitNode const& exitNode, ALO& allocator)
        : provision_{buildProvisionSpec (exitNode, allocator)}
        { }
      
      static JobTicket NOP;
      
      
      bool
      empty()  const
        {
          return isnil (provision_.exitNode);
        }
      
      bool
      isValid()  const
        {
          if (empty()) return false;
          
            InvocationInstanceID empty; 
          return not lumiera_invokey_eq (&util::unConst(provision_).invocationSeed, &empty)
             and provision_.exitNode.isValid()
             and util::and_all (provision_.prerequisites
                               ,[](auto& pq){ return pq.prereqTicket.isValid(); });
        }
      
      
      auto
      getPrerequisites ()
        {
          return lib::transformIterator (this->empty()? Prerequisites::iterator()
                                                      : provision_.prerequisites.begin()
                                        ,[](Prerequisite& prq) -> JobTicket&
                                           {
                                             return prq.prereqTicket;
                                           });
        }
      
      Job createJobFor (Time nominalTime);
      
      Duration getExpectedRuntime();
      
      
    protected:
      static InvocationInstanceID timeHash (Time, InvocationInstanceID const&);
      bool verifyInstance (JobFunctor&, InvocationInstanceID const&, Time)  const;
 
    };
  
  
  
  
 
  template<class ALO>
  inline JobTicket::Provision
  JobTicket::buildProvisionSpec (ExitNode const& exitNode, ALO& allocTicket)
  {
    REQUIRE (not isnil (exitNode));  // has valid functor
    HashVal invoSeed = exitNode.getPipelineIdentity();
    JobFunctor& func = exitNode.getInvocationFunctor();
    Provision provisionSpec{func, exitNode, invoSeed};
    for (ExitNode const& preNode: exitNode.getPrerequisites())
      provisionSpec.prerequisites.emplace(preNode, allocTicket);    
    return provisionSpec;
  }
  
  
  
}}// namespace steam::engine
#endif /*STEAM_ENGINE_JOB_TICKET_H*/