tensor_exec_state.hpp

 
#ifndef EXATN_RUNTIME_TENSOR_EXEC_STATE_HPP_
#define EXATN_RUNTIME_TENSOR_EXEC_STATE_HPP_
 
#include "tensor_operation.hpp"
#include "tensor.hpp"
 
#include <unordered_map>
#include <list>
#include <memory>
#include <atomic>
 
namespace exatn {
namespace runtime {
 
// Tensor Graph node id (DirectedBoostGraph vertex descriptor):
using VertexIdType = std::size_t; //must match with boost::graph vertex descriptor type
 
// Tensor implementation:
using numerics::TensorHashType; //each numerics::Tensor has its unique integer hash
using numerics::Tensor;
using numerics::TensorOperation;
 
 
class TensorExecState {
 
protected:
 
  struct TensorExecInfo {
    std::atomic<std::size_t> update_count;    //total number of outstanding updates on a given Tensor in the current DAG
    std::atomic<int> rw_epoch;                //>0: number of current epoch reads; -1: current epoch write (single)
    std::vector<VertexIdType> rw_epoch_nodes; //nodes participating in the current R/W epoch (either read or write)
 
    TensorExecInfo(): update_count(0), rw_epoch(0) {}
    TensorExecInfo(const TensorExecInfo &) = delete;
    TensorExecInfo & operator=(const TensorExecInfo &) = delete;
    TensorExecInfo(TensorExecInfo &&) noexcept = delete;
    TensorExecInfo & operator=(TensorExecInfo &&) noexcept = delete;
    ~TensorExecInfo() = default;
  };
 
public:
 
  TensorExecState(): front_node_(0) {}
 
  TensorExecState(const TensorExecState &) = delete;
  TensorExecState & operator=(const TensorExecState &) = delete;
  TensorExecState(TensorExecState &&) noexcept = default;
  TensorExecState & operator=(TensorExecState &&) noexcept = default;
  ~TensorExecState() = default;
 
  const std::vector<VertexIdType> * getTensorEpochNodes(const Tensor & tensor,
                                                        int * epoch);
  int registerTensorRead(const Tensor & tensor,
                         VertexIdType node_id);
  int registerTensorWrite(const Tensor & tensor,
                          VertexIdType node_id);
 
  std::size_t registerWriteCompletion(const Tensor & tensor);
  std::size_t getTensorUpdateCount(const Tensor & tensor);
 
  void registerDependencyFreeNode(VertexIdType node_id);
  bool extractDependencyFreeNode(VertexIdType * node_id);
 
  void registerExecutingNode(VertexIdType node_id);
  bool extractExecutingNode(VertexIdType * node_id);
 
  bool progressFrontNode(VertexIdType node_executed);
 
  VertexIdType getFrontNode() const;
 
private:
  std::unordered_map<TensorHashType,std::shared_ptr<TensorExecInfo>> tensor_info_;
  std::list<VertexIdType> nodes_ready_;
  std::list<VertexIdType> nodes_executing_;
  VertexIdType front_node_;
};
 
} // namespace runtime
} // namespace exatn
 
#endif //EXATN_RUNTIME_TENSOR_EXEC_STATE_HPP_