job.h

Go to the documentation of this file.

/*
  JOB.h  -  render job closure

   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 VAULT_GEAR_JOB_H
#define VAULT_GEAR_JOB_H


#include "lib/llist.h"
#include "lib/hash-value.h"
#include "lib/time.h"



enum JobState
  { 
    DONE,      
    RUNNING,   
    WAITING,   
    REJECTED,  
    EXPIRED,   
    ABORTED    
  };

enum JobKind
  {
    CALC_JOB,  
    LOAD_JOB,  
    META_JOB,  
    TEST_JOB   
  };

enum JobPriority
  {
    TIMEBOUND_JOB,   
    PAUSED_JOB,      
    ASAP_JOB,        
    BACKGROUND_JOB   
  };


typedef int64_t FrameCnt;



struct lumiera_jobClosure { /* placeholder */ };
typedef struct lumiera_jobClosure* LumieraJobClosure;



union InvocationInstanceID
  {
    lumiera_uid luid{0};
    
    /* ----- alternative accessors for test code ---- */
    FrameCnt frameNumber;
    struct { int32_t a,b;
             int64_t t;
           } part;
    struct {
             uint64_t w1;
             uint64_t w2;
           } code;
  };




struct lumiera_jobParameter_struct
  {
    gavl_time_t nominalTime;        
    InvocationInstanceID invoKey;
  };
typedef struct lumiera_jobParameter_struct lumiera_jobParameter;
typedef lumiera_jobParameter* LumieraJobParameter;


struct lumiera_jobDefinition_struct
  {
    LumieraJobClosure jobClosure;     
    lumiera_jobParameter parameter;   
  };
typedef struct lumiera_jobDefinition_struct lumiera_jobDefinition;
typedef lumiera_jobDefinition* LumieraJobDefinition;


struct lumiera_jobDescriptor_struct
  {
    gavl_time_t deadline;                
    JobState jobState;
    
    lumiera_jobDefinition jobDefinition; 
    
    /* == Job prerequisites == */
    LList waiting;
    LList failed;
    LList completed;
  };
typedef struct lumiera_jobDescriptor_struct lumiera_jobDescriptor;
typedef lumiera_jobDescriptor* LumieraJobDescriptor;








#ifdef __cplusplus  /* ============== C++ Interface ================= */

#include "lib/nocopy.hpp"
#include <string>



namespace vault{
namespace gear {
  
  using lib::time::TimeValue;
  using lib::time::Time;
  using lib::HashVal;
  
  typedef lumiera_jobParameter const& JobParameter;
  
  
  class JobFunctor                                      
    : util::NonCopyable            // ....has distinct identity and stable address
    {
    public:
      virtual ~JobFunctor();     
       
      virtual std::string
      diagnostic()  const
        {
          return "JobFunctor";
        }
      
      operator std::string()  const
        {
          return diagnostic();
        }
    };                                                   
  class JobClosure
    : public lumiera_jobClosure
    , public JobFunctor                                 
    {
    public:
      virtual ~JobClosure();     
      
      
      virtual void invokeJobOperation (JobParameter parameter)   =0;
      
      virtual JobKind getJobKind()                         const =0;
      virtual HashVal hashOfInstance(InvocationInstanceID) const =0;
      virtual InvocationInstanceID buildInstanceID(HashVal)const =0;             
      
      lib::HashVal hash_value (JobParameter)  const;
    };
  
  
  
  
  class Job
    : public lumiera_jobDefinition
    {
      
    public:
      
      Job (JobClosure& specificJobDefinition
          ,InvocationInstanceID invoKey
          ,Time nominalFrameTime)
        {
          this->jobClosure = &specificJobDefinition;
          this->parameter.nominalTime = _raw(nominalFrameTime);
          this->parameter.invoKey = invoKey;
        }
      
      // using standard copy operations
      
      
      void triggerJob()                     const;
      
      
      Time
      getNominalTime()  const
        {
          return Time (TimeValue(parameter.nominalTime));
        }
      
      InvocationInstanceID
      getInvocationInstanceID()  const
        {
          return this->parameter.invoKey;
        }
      
      JobKind getKind() const;
      
      bool usesClosure (JobClosure const&)  const;
      
      friend lib::HashVal hash_value (Job const&);
    };
  
  inline bool
  operator== (Job const& left, Job const& right)
  {
    return hash_value (left) == hash_value (right);
  }
  
  inline bool
  operator!= (Job const& left, Job const& right)
  {
    return hash_value (left) != hash_value (right);
  }
  
  
  
  
  
}} // namespace vault::gear




extern "C" {
#endif /* =========================== C Interface ===================== */


void lumiera_job_invoke  (LumieraJobDefinition);

size_t lumiera_job_get_hash (LumieraJobDefinition);

int lumiera_invokey_eq (void* l, void* r);


#ifdef __cplusplus
}
#endif
#endif /*VAULT_GEAR_JOB_H*/