tensor_graph.hpp

 
#ifndef EXATN_RUNTIME_TENSOR_GRAPH_HPP_
#define EXATN_RUNTIME_TENSOR_GRAPH_HPP_
 
#include "Identifiable.hpp"
 
#include "tensor_exec_state.hpp"
#include "tensor_operation.hpp"
#include "tensor.hpp"
 
#include <vector>
#include <memory>
#include <atomic>
#include <mutex>
 
#include <cassert>
 
namespace exatn {
namespace runtime {
 
// Tensor Graph node
class TensorOpNode {
 
public:
  TensorOpNode():
   op_(nullptr), is_noop_(true), executing_(false), executed_(false), error_(0)
  {}
 
  TensorOpNode(std::shared_ptr<TensorOperation> tens_op):
   op_(tens_op), is_noop_(false), executing_(false), executed_(false), error_(0)
  {}
 
  TensorOpNode(const TensorOpNode &) = delete;
  TensorOpNode & operator=(const TensorOpNode &) = delete;
  TensorOpNode(TensorOpNode &&) noexcept = delete;
  TensorOpNode & operator=(TensorOpNode &&) noexcept = delete;
  ~TensorOpNode() = default;
 
  inline bool isDummy() const {return is_noop_;}
 
  inline std::shared_ptr<TensorOperation> & getOperation() {return op_;}
 
  inline VertexIdType getId() const {return id_;}
 
  inline bool isExecuting() {return executing_.load();}
 
  inline bool isExecuted(int * error_code = nullptr) {
    bool ans = executed_.load();
    if(error_code != nullptr && ans) *error_code = error_.load();
    return ans;
  }
 
  inline void setId(VertexIdType id) {
    id_ = id;
    return;
  }
 
  inline void setExecuting() {
    auto executing = executing_.load();
    auto executed = executed_.load();
    assert(!executing && !executed);
    executing_.store(true);
    return;
  }
 
  inline void setExecuted(int error_code = 0) {
    auto executing = executing_.load();
    auto executed = executed_.load();
    assert(executing && !executed);
    error_.store(error_code);
    executed_.store(true);
    executing_.store(false);
    return;
  }
 
  inline void setIdle() {
    auto executed = executed_.load();
    assert(!executed);
    error_.store(0);
    executing_.store(false);
    return;
  }
 
  inline void lock() {mtx_.lock();}
  inline void unlock() {mtx_.unlock();}
 
protected:
  std::shared_ptr<TensorOperation> op_; //stored tensor operation
  bool is_noop_;                //TRUE if the stored tensor operation is NOOP (dummy node)
  std::atomic<bool> executing_; //TRUE if the stored tensor operation is currently being executed
  std::atomic<bool> executed_;  //TRUE if the stored tensor operation has been executed to completion
  std::atomic<int> error_;      //execution error code (0:success)
  VertexIdType id_;             //graph vertex id
 
private:
  std::recursive_mutex mtx_; //object access mutex
};
 
 
// Public Tensor Graph API
class TensorGraph : public Identifiable, public Cloneable<TensorGraph> {
 
public:
  TensorGraph() = default;
  TensorGraph(const TensorGraph &) = delete;
  TensorGraph & operator=(const TensorGraph &) = delete;
  TensorGraph(TensorGraph &&) noexcept = default;
  TensorGraph & operator=(TensorGraph &&) noexcept = default;
  virtual ~TensorGraph() = default;
 
  virtual VertexIdType addOperation(std::shared_ptr<TensorOperation> op) = 0;
 
  virtual void addDependency(VertexIdType dependent,
                             VertexIdType dependee) = 0;
 
  virtual bool dependencyExists(VertexIdType vertex_id1,
                                VertexIdType vertex_id2) = 0;
 
  virtual TensorOpNode & getNodeProperties(VertexIdType vertex_id) = 0;
 
  virtual std::size_t getNodeDegree(VertexIdType vertex_id) = 0;
 
  virtual std::size_t getNumNodes() = 0;
 
  virtual std::size_t getNumDependencies() = 0;
 
  virtual std::vector<VertexIdType> getNeighborList(VertexIdType vertex_id) = 0;
 
  virtual void computeShortestPath(VertexIdType startIndex,
                                   std::vector<double> & distances,
                                   std::vector<VertexIdType> & paths) = 0;
 
  virtual void printIt() = 0;
 
  virtual std::shared_ptr<TensorGraph> clone() = 0;
 
 
  void setNodeExecuting(VertexIdType vertex_id) {
    return getNodeProperties(vertex_id).setExecuting();
  }
 
  void setNodeExecuted(VertexIdType vertex_id, int error_code = 0) {
    TensorOpNode & node_properties = getNodeProperties(vertex_id);
    node_properties.setExecuted(error_code);
    auto & op = node_properties.getOperation();
    auto & output_tensor = *(op->getTensorOperand(0));
    lock();
    auto update_cnt = exec_state_.registerWriteCompletion(output_tensor);
    unlock();
    return;
  }
 
  void setNodeIdle(VertexIdType vertex_id) {
    return getNodeProperties(vertex_id).setIdle();
  }
 
  bool nodeExecuting(VertexIdType vertex_id) {
    return getNodeProperties(vertex_id).isExecuting();
  }
 
  bool nodeExecuted(VertexIdType vertex_id, int * error_code = nullptr) {
    return getNodeProperties(vertex_id).isExecuted(error_code);
  }
 
  inline std::size_t getTensorUpdateCount(const Tensor & tensor) {
    lock();
    auto upd_cnt = exec_state_.getTensorUpdateCount(tensor);
    unlock();
    return upd_cnt;
  }
 
  inline void registerDependencyFreeNode(VertexIdType node_id) {
    lock();
    exec_state_.registerDependencyFreeNode(node_id);
    unlock();
    return;
  }
 
  inline bool extractDependencyFreeNode(VertexIdType * node_id) {
    lock();
    auto avail = exec_state_.extractDependencyFreeNode(node_id);
    unlock();
    return avail;
  }
 
  inline void registerExecutingNode(VertexIdType node_id) {
    lock();
    exec_state_.registerExecutingNode(node_id);
    unlock();
    return;
  }
 
  inline bool extractExecutingNode(VertexIdType * node_id) {
    lock();
    auto avail = exec_state_.extractExecutingNode(node_id);
    unlock();
    return avail;
  }
 
  inline bool progressFrontNode(VertexIdType node_executed) {
    return exec_state_.progressFrontNode(node_executed);
  }
 
  inline VertexIdType getFrontNode() const {
    return exec_state_.getFrontNode();
  }
 
  inline bool hasUnexecutedNodes() {
    return (exec_state_.getFrontNode() < this->getNumNodes());
  }
 
  inline void lock() {mtx_.lock();}
  inline void unlock() {mtx_.unlock();}
 
protected:
  TensorExecState exec_state_; //tensor graph execution state
 
private:
  std::recursive_mutex mtx_; //object access mutex
};
 
} // namespace runtime
} // namespace exatn
 
#endif //EXATN_RUNTIME_TENSOR_GRAPH_HPP_