sycl_task.hpp

Go to the documentation of this file.

#pragma once
 
#include "sycl_graph.hpp"
 
namespace tf {
 
// ----------------------------------------------------------------------------
// syclTask
// ----------------------------------------------------------------------------
 
class syclTask {
 
  friend class syclFlow;
 
  friend std::ostream& operator << (std::ostream&, const syclTask&);
 
  public:
 
    syclTask() = default;
 
    syclTask(const syclTask&) = default;
 
    syclTask& operator = (const syclTask&) = default;
 
    template <typename... Ts>
    syclTask& precede(Ts&&... tasks);
 
    template <typename... Ts>
    syclTask& succeed(Ts&&... tasks);
 
    syclTask& name(const std::string& name);
 
    const std::string& name() const;
 
    size_t num_successors() const;
 
    size_t num_dependents() const;
 
    bool empty() const;
 
    template <typename T>
    void dump(T& ostream) const;
 
    template <typename V>
    void for_each_successor(V&& visitor) const;
 
    template <typename V>
    void for_each_dependent(V&& visitor) const;
 
  private:
 
    syclTask(syclNode*);
 
    syclNode* _node {nullptr};
};
 
// Constructor
inline syclTask::syclTask(syclNode* node) : _node {node} {
}
 
// Function: precede
template <typename... Ts>
syclTask& syclTask::precede(Ts&&... tasks) {
  (_node->_precede(tasks._node), ...);
  return *this;
}
 
// Function: succeed
template <typename... Ts>
syclTask& syclTask::succeed(Ts&&... tasks) {
  (tasks._node->_precede(_node), ...);
  return *this;
}
 
// Function: empty
inline bool syclTask::empty() const {
  return _node == nullptr;
}
 
// Function: name
inline syclTask& syclTask::name(const std::string& name) {
  _node->_name = name;
  return *this;
}
 
// Function: name
inline const std::string& syclTask::name() const {
  return _node->_name;
}
 
// Function: num_successors
inline size_t syclTask::num_successors() const {
  return _node->_successors.size();
}
 
// Function: num_dependents
inline size_t syclTask::num_dependents() const {
  return _node->_dependents.size();
}
 
// Procedure: dump
template <typename T>
void syclTask::dump(T& os) const {
  os << "syclTask ";
  if(_node->_name.empty()) os << _node;
  else os << _node->_name;
}
 
// Function: for_each_successor
template <typename V>
void syclTask::for_each_successor(V&& visitor) const {
  for(size_t i=0; i<_node->_successors.size(); ++i) {
    visitor(syclTask(_node->_successors[i]));
  }
}
 
// Function: for_each_dependent
template <typename V>
void syclTask::for_each_dependent(V&& visitor) const {
  for(size_t i=0; i<_node->_dependents.size(); ++i) {
    visitor(syclTask(_node->_dependents[i]));
  }
}
 
 
// ----------------------------------------------------------------------------
// global ostream
// ----------------------------------------------------------------------------
 
inline std::ostream& operator << (std::ostream& os, const syclTask& ct) {
  ct.dump(os);
  return os;
}
 
}  // end of namespace tf -----------------------------------------------------