UserJobGraph.h

Go to the documentation of this file.

// ========================================================================= //
// This file is part of MyraMath, copyright (c) 2014-2019 by Ryan A Chilton  //
// and distributed by MyraCore, LLC. See LICENSE.txt for license terms.      //
// ========================================================================= //

#ifndef MYRAMATH_JOBGRAPH_USERJOBGRAPH_H
#define MYRAMATH_JOBGRAPH_USERJOBGRAPH_H

#include <myramath/MYRAMATH_EXPORT.h>
#include <myramath/utility/eprintf.h>
#include <myramath/utility/detail/ssize.h>

#include <myramath/jobgraph/Job.h>
#include <myramath/jobgraph/JobID.h>
#include <myramath/jobgraph/JobGraph.h>

#include <string>
#include <stdint.h>

#include <vector>
#include <set>

namespace myra {

class UserJobGraph : public ::myra::JobGraphBase
  {
  public:

    // --------------------------- UserJobBase

    class UserJobBase : public :: myra::Job
      {
      public:

        UserJobBase(uint64_t j, const std::string& s)
          : job(j), n(s) { }

        virtual UserJobBase* clone() const = 0;

        virtual JobID id() const
          { return JobID(job); }

        virtual void parents(JobIDs& output) const
          { 
          for (int p = 0; p < pids.size(); ++p) 
            output.push_back( JobID(pids[p]) ); 
          }

        virtual void children(JobIDs& output) const
          { 
          for (int c = 0; c < cids.size(); ++c) 
            output.push_back( JobID(cids[c]) ); 
          }

        virtual std::string name() const { return n; }

        void add_parent(uint64_t p)
          { pids.push_back(p); }

        void add_child(uint64_t c)
          { cids.push_back(c); }

       ~UserJobBase() 
         { }

      protected:
      
        // A unique identifier for this Job.
        uint64_t job;

        // Name string.
        std::string n;

        // Parent JobID's
        std::vector<uint64_t> pids;

        // Children JobID's
        std::vector<uint64_t> cids;

      };

    template<class Functor> class UserJob : public UserJobBase
      {
      public:

        UserJob(uint64_t j, const Functor& f, const std::string& s)
          : UserJobBase(j,s), functor(f) { }

        UserJob(const UserJob& that) : UserJobBase(that.job, that.n), functor(that.functor) 
          {
          this->pids = that.pids; 
          this->cids = that.cids;
          }

        virtual UserJobBase* clone() const
          { return new UserJob<Functor>(*this); }

        virtual uint64_t execute() 
          { functor(); return 1; }

        virtual ~UserJob() { }

      private:

        // Executable payload.
        Functor functor;
        
      };

    // --------------------------- Graph/container API.

    UserJobGraph()
      { }

    template<class Functor> uint64_t insert(const Functor& f)
      {
      uint64_t id = jobs.size();
      jobs.push_back( new UserJob<Functor>(id,f,"UserJob") );
      bids.insert(id);
      eids.insert(id);
      return id;
      }

    template<class Functor> uint64_t insert(const Functor& f, const std::string& n)
      {
      uint64_t id = jobs.size();
      jobs.push_back( new UserJob<Functor>(id,f,n) );
      bids.insert(id);
      eids.insert(id);
      return id;
      }

    void add_edge(uint64_t j0, uint64_t j1)
      {
      uint64_t J = ssize(jobs);
      if (j0 < 0) throw eprintf("UserJobGraph::add_edge(), underflow j0 < 0", j0);
      if (j1 < 0) throw eprintf("UserJobGraph::add_edge(), underflow j1 < 0", j1);
      if (j0 >= J) throw eprintf("UserJobGraph::add_edge(), overflow j0 >= J", j0, J);
      if (j1 >= J) throw eprintf("UserJobGraph::add_edge(), overflow j1 >= J", j1, J);      
      // Add child/parent links.
      jobs[j0]->add_child(j1);
      jobs[j1]->add_parent(j0);
      // Job j0 has a child, so it can't be an end.
      eids.erase(j0);
      // Job j1 has a parent, so it can't be a begin.
      bids.erase(j1);
      }

    // --------------------------- JobGraphBase obligations.

    virtual JobGraphBase* clone() const
      {
      UserJobGraph* that = new UserJobGraph();
      for (uint64_t j = 0; j < this->jobs.size(); ++j)
        that->jobs.push_back( this->jobs[j]->clone() );
      that->bids = this->bids;
      that->eids = this->eids;
      return that;
      }

    virtual uint64_t n_work() const 
      { return jobs.size(); }
    
    virtual std::string name() const 
      { return "UserJobGraph"; }

    virtual void begins(JobIDs& output) const
      {
      typedef std::set<uint64_t>::const_iterator Iterator;
      for (Iterator b = bids.begin(); b != bids.end(); ++b) 
        output.push_back( JobID(*b) );
      }

    virtual void ends(JobIDs& output) const
      {
      typedef std::set<uint64_t>::const_iterator Iterator;
      for (Iterator e = eids.begin(); e != eids.end(); ++e) 
        output.push_back( JobID(*e) ); 
      }

    virtual Job* create(JobID id)
      { return jobs[id.unpack()]->clone(); }

    uint64_t size() const
      { return jobs.size(); }

    virtual ~UserJobGraph()
      { 
      for (uint64_t j = 0; j < jobs.size(); ++j) 
        delete jobs[j]; 
      }

  private:

    // Internal contents.
    std::vector<UserJobBase*> jobs;

    // Begin JobID's
    std::set<uint64_t> bids;

    // End JobID's
    std::set<uint64_t> eids;

  };

} // namespace myra

#endif