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 <inttypes.h>
 
typedef int64_t  raw_time_64;        
 
 
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
  {
    raw_time_64 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
  {
    raw_time_64 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 "lib/time/timevalue.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*/