activity-term.hpp

Go to the documentation of this file.

/*
  ACTIVITY-TERM.hpp  -  definition language framework for scheduler activities
 
   Copyright (C)
     2023,            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 SRC_VAULT_GEAR_ACTIVITY_TERM_H_
#define SRC_VAULT_GEAR_ACTIVITY_TERM_H_
 
 
#include "vault/gear/activity.hpp"
#include "vault/gear/block-flow.hpp"
#include "vault/gear/job.h"
#include "lib/time/timevalue.hpp"
 
#include <string>
#include <utility>
 
 
namespace vault{
namespace gear {
  
  using lib::time::Time;
  using lib::time::TimeValue;
  using std::string;
  using std::move;
  
  using BlockFlowAlloc = BlockFlow<blockFlow::RenderConfig>;
  
  
  namespace activity {
    
    class Term
      {
        
        using AllocHandle = BlockFlowAlloc::AllocatorHandle;
        
        AllocHandle alloc_;
        
        Activity* invoke_{nullptr};
        Activity* post_{nullptr};
        
        Activity* gate_{nullptr};
        Activity* callback_{nullptr};   
        
        
      public:
        enum Template {CALC_JOB  
                      ,LOAD_JOB  
                      ,META_JOB  
                      };
        
        explicit
        Term (AllocHandle&& allocHandle, Template kind, Time start, Time dead, Job job)
          : alloc_{move (allocHandle)}
          , invoke_{setupInvocation (job)}
          , post_{setupPost (start,dead, invoke_)}
          {
            configureTemplate (kind);
          }
        
        // standard copy acceptable
        
        operator std::string()  const
          {
            return "Term-"
                 + (post_? string{*post_} : util::BOTTOM_INDICATOR)
                 + "⧐"
                 + (invoke_? string{*invoke_} : util::BOTTOM_INDICATOR);
          }
        
        
        Activity&
        post()
          {
            REQUIRE (post_, "Activity Term not yet fully configured");
            return *post_;
          }
        
        Activity&
        callback()
          {
            REQUIRE (callback_, "Activity Term properly configured for async IO");
            return *callback_;
          }
        
        Term&
        expectNotification (Activity& notificationSrc, bool unlimitedTime =false)
          {
            REQUIRE (notificationSrc.is (Activity::NOTIFY));
            setupGate();
            gate_->incDependencies();
            Time triggerTimeStart{unlimitedTime? Time::ANYTIME : post_->data_.timeWindow.life};
            notificationSrc.setNotificationTarget (gate_, triggerTimeStart);
            return *this;
          }
        
        Term&
        appendNotificationTo (Term& targetTerm, bool unlimitedTime =false)
          {
            Activity& success = alloc_.create (Activity::NOTIFY);
            insert (findTail (callback_? callback_ : invoke_), &success);
            targetTerm.expectNotification (success, unlimitedTime);
            return *this;
          }
        
        Term&
        requireDirectActivation()
          {
            Activity& trigger = alloc_.create (Activity::NOTIFY);
            expectNotification (trigger);
            insert (post_, &trigger);
            return *this;
          }
        
      private:
        void
        configureTemplate (Template kind)
          {
            switch (kind) {
              case CALC_JOB:
                setupGate();
                insertWorkBracket();
                break;
              case LOAD_JOB:
                insertWorkBracket();
                severAsyncChain();
                break;
              case META_JOB:
                /* use the minimal default wiring */
                break;
              default:
                NOTREACHED ("unknown wiring scheme for Render Jobs.");
                break;
              }
          }
        
        
        Activity*
        setupInvocation (Job& job)
          {
            Activity& feed1 = alloc_.create (job.parameter.invoKey.code.w1
                                            ,job.parameter.invoKey.code.w2);
            Activity& feed2 = alloc_.create (Activity::FEED);         
            feed1.next = &feed2;
            
            JobClosure* functor = static_cast<JobClosure*> (job.jobClosure);             
            REQUIRE (functor);
            Activity& invo  = alloc_.create (*functor
                                            , Time{TimeValue{job.parameter.nominalTime}}
                                            , feed1);             
            return & invo;
          }
        
        Activity*
        setupPost (Time start, Time dead, Activity* followUp)
          {
            return & alloc_.create (start,dead,followUp);
          }
        
        void
        setupGate()
          {
            if (gate_) return;
            gate_ = & alloc_.create (0, Time{post_->data_.timeWindow.dead});
            ENSURE (gate_);
            ENSURE (gate_->is (Activity::GATE));
            insert (post_, gate_);
          }
 
        void
        insertWorkBracket()
          {
            Activity& start = alloc_.create (Activity::WORKSTART);
            Activity& stop  = alloc_.create (Activity::WORKSTOP);
            
            insert (gate_? gate_: post_,  &start);
            insert (findTail (start.next), &stop);
          }
        
        void
        severAsyncChain()
          {
            if (callback_) return;
            Activity& cut = *invoke_->next->next;
            REQUIRE (cut.is (Activity::FEED));
            callback_ = cut.next;
            cut.next = nullptr;
            ENSURE (callback_);
          }
        
        
        static void
        insert (Activity* anchor, Activity* target)
          {
            REQUIRE (anchor);
            REQUIRE (target);
            target->next = anchor->next;
            anchor->next = target;
          }
        
        static Activity*
        findTail (Activity* chain)
          {
            REQUIRE (chain);
            while (chain->next)
              chain = chain->next;
            return chain;
          }
      };
    
  }//(End)namespace activity
}}// namespace vault::gear
#endif /*SRC_VAULT_GEAR_ACTIVITY_TERM_H_*/