job-ticket.hpp

Go to the documentation of this file.

/*
  JOB-TICKET.hpp  -  execution plan for render jobs

  Copyright (C)         Lumiera.org
    2012,               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_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*/