Skip to content

Commit

Permalink
fix formatting issues
Browse files Browse the repository at this point in the history
  • Loading branch information
@reble
reble committed Oct 13, 2022
1 parent 50d49a1 commit 9b46c4b
Show file tree
Hide file tree
Showing 3 changed files with 1,606 additions and 1,044 deletions.
235 changes: 123 additions & 112 deletions sycl/include/sycl/ext/oneapi/experimental/graph.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -10,8 +10,8 @@

#include <CL/sycl/detail/defines_elementary.hpp>

#include <set>
#include <list>
#include <set>

__SYCL_INLINE_NAMESPACE(cl) {
namespace sycl {
Expand All @@ -29,90 +29,98 @@ using node_ptr = std::shared_ptr<node_impl>;
using graph_ptr = std::shared_ptr<graph_impl>;

class wrapper {
using T = std::function<void(sycl::handler&)>;
T my_func;
std::vector<sycl::event> my_deps;
using T = std::function<void(sycl::handler &)>;
T my_func;
std::vector<sycl::event> my_deps;

public:
wrapper(T t, const std::vector<sycl::event>& deps) : my_func(t), my_deps(deps) {};
wrapper(T t, const std::vector<sycl::event> &deps)
: my_func(t), my_deps(deps){};

void operator()(sycl::handler& cgh) {
cgh.depends_on(my_deps);
std::invoke(my_func,cgh);
}
void operator()(sycl::handler &cgh) {
cgh.depends_on(my_deps);
std::invoke(my_func, cgh);
}
};

struct node_impl {
bool is_scheduled;
bool is_scheduled;

graph_ptr my_graph;
sycl::event my_event;
graph_ptr my_graph;
sycl::event my_event;

std::vector<node_ptr> my_successors;
std::vector<node_ptr> my_predecessors;
std::vector<node_ptr> my_successors;
std::vector<node_ptr> my_predecessors;

std::function<void(sycl::handler&)> my_body;
std::function<void(sycl::handler &)> my_body;

void exec( sycl::queue q ) {
std::vector<sycl::event> __deps;
for(auto i:my_predecessors) __deps.push_back(i->get_event());
my_event = q.submit(wrapper{my_body,__deps});
}
void exec(sycl::queue q) {
std::vector<sycl::event> __deps;
for (auto i : my_predecessors)
__deps.push_back(i->get_event());
my_event = q.submit(wrapper{my_body, __deps});
}

void register_successor(node_ptr n) {
my_successors.push_back(n);
n->register_predecessor(node_ptr(this));
}
void register_successor(node_ptr n) {
my_successors.push_back(n);
n->register_predecessor(node_ptr(this));
}

void register_predecessor(node_ptr n) { my_predecessors.push_back(n); }
void register_predecessor(node_ptr n) { my_predecessors.push_back(n); }

sycl::event get_event(void) {return my_event;}
sycl::event get_event(void) { return my_event; }

template<typename T>
node_impl(graph_ptr g, T cgf) : is_scheduled(false), my_graph(g), my_body(cgf) {}
template <typename T>
node_impl(graph_ptr g, T cgf)
: is_scheduled(false), my_graph(g), my_body(cgf) {}

// Recursively adding nodes to execution stack:
void topology_sort(std::list<node_ptr>& schedule) {
is_scheduled = true;
for(auto i:my_successors) {
if(!i->is_scheduled) i->topology_sort(schedule);
}
schedule.push_front(node_ptr(this));
// Recursively adding nodes to execution stack:
void topology_sort(std::list<node_ptr> &schedule) {
is_scheduled = true;
for (auto i : my_successors) {
if (!i->is_scheduled)
i->topology_sort(schedule);
}
schedule.push_front(node_ptr(this));
}
};

struct graph_impl {
std::set<node_ptr> my_roots;
std::list<node_ptr> my_schedule;

graph_ptr parent;

void exec( sycl::queue q ) {
if( my_schedule.empty() ) {
for(auto n : my_roots) {
n->topology_sort(my_schedule);
}
}
for(auto n : my_schedule) n->exec(q);
}
std::set<node_ptr> my_roots;
std::list<node_ptr> my_schedule;

void exec_and_wait( sycl::queue q ) {
exec(q);
q.wait();
}
graph_ptr parent;

void add_root(node_ptr n) {
my_roots.insert(n);
for(auto n : my_schedule) n->is_scheduled=false;
my_schedule.clear();
void exec(sycl::queue q) {
if (my_schedule.empty()) {
for (auto n : my_roots) {
n->topology_sort(my_schedule);
}
}

void remove_root(node_ptr n) {
my_roots.erase(n);
for(auto n : my_schedule) n->is_scheduled=false;
my_schedule.clear();
}

graph_impl() {}
for (auto n : my_schedule)
n->exec(q);
}

void exec_and_wait(sycl::queue q) {
exec(q);
q.wait();
}

void add_root(node_ptr n) {
my_roots.insert(n);
for (auto n : my_schedule)
n->is_scheduled = false;
my_schedule.clear();
}

void remove_root(node_ptr n) {
my_roots.erase(n);
for (auto n : my_schedule)
n->is_scheduled = false;
my_schedule.clear();
}

graph_impl() {}
};

} // namespace detail
Expand All @@ -124,89 +132,92 @@ class graph;
class executable_graph;

struct node {
// TODO: add properties to distinguish between empty, host, device nodes.
detail::node_ptr my_node;
detail::graph_ptr my_graph;
// TODO: add properties to distinguish between empty, host, device nodes.
detail::node_ptr my_node;
detail::graph_ptr my_graph;

template<typename T>
node(detail::graph_ptr g, T cgf) : my_graph(g), my_node(new detail::node_impl(g,cgf)) {};
void register_successor(node n) { my_node->register_successor(n.my_node); }
void exec( sycl::queue q, sycl::event = sycl::event() ) { my_node->exec(q); }
template <typename T>
node(detail::graph_ptr g, T cgf)
: my_graph(g), my_node(new detail::node_impl(g, cgf)){};
void register_successor(node n) { my_node->register_successor(n.my_node); }
void exec(sycl::queue q, sycl::event = sycl::event()) { my_node->exec(q); }

void set_root() { my_graph->add_root(my_node);}
void set_root() { my_graph->add_root(my_node); }

// TODO: Add query functions: is_root, ...
// TODO: Add query functions: is_root, ...
};

class executable_graph {
public:
int my_tag;
sycl::queue my_queue;
int my_tag;
sycl::queue my_queue;

void exec_and_wait();// { my_queue.wait(); }
void exec_and_wait(); // { my_queue.wait(); }

executable_graph(detail::graph_ptr g, sycl::queue q) : my_queue(q), my_tag(rand()) {
g->exec(my_queue);
}
executable_graph(detail::graph_ptr g, sycl::queue q)
: my_queue(q), my_tag(rand()) {
g->exec(my_queue);
}
};

class graph {
public:
// Adding empty node with [0..n] predecessors:
node add_empty_node(const std::vector<node>& dep = {});
// Adding empty node with [0..n] predecessors:
node add_empty_node(const std::vector<node> &dep = {});

// Adding node for host task
template<typename T>
node add_host_node(T hostTaskCallable, const std::vector<node>& dep = {});
// Adding node for host task
template <typename T>
node add_host_node(T hostTaskCallable, const std::vector<node> &dep = {});

// Adding device node:
template<typename T>
node add_device_node(T cgf, const std::vector<node>& dep = {});
// Adding device node:
template <typename T>
node add_device_node(T cgf, const std::vector<node> &dep = {});

// Adding dependency between two nodes.
void make_edge(node sender, node receiver);
// Adding dependency between two nodes.
void make_edge(node sender, node receiver);

// TODO: Extend queue to directly submit graph
void exec_and_wait( sycl::queue q );
// TODO: Extend queue to directly submit graph
void exec_and_wait(sycl::queue q);

executable_graph exec( sycl::queue q ) { return executable_graph{my_graph,q};};
executable_graph exec(sycl::queue q) {
return executable_graph{my_graph, q};
};

graph() : my_graph(new detail::graph_impl()) {}
graph() : my_graph(new detail::graph_impl()) {}

// Creating a subgraph (with predecessors)
graph(graph& parent, const std::vector<node>& dep = {}) {}
// Creating a subgraph (with predecessors)
graph(graph &parent, const std::vector<node> &dep = {}) {}

bool is_subgraph();
bool is_subgraph();

private:
detail::graph_ptr my_graph;
detail::graph_ptr my_graph;
};

void executable_graph::exec_and_wait() { my_queue.wait(); }

template<typename T>
node graph::add_device_node(T cgf , const std::vector<node>& dep) {
node _node(my_graph,cgf);
if( !dep.empty() ) {
for(auto n : dep) this->make_edge(n,_node);
} else {
_node.set_root();
}
return _node;
template <typename T>
node graph::add_device_node(T cgf, const std::vector<node> &dep) {
node _node(my_graph, cgf);
if (!dep.empty()) {
for (auto n : dep)
this->make_edge(n, _node);
} else {
_node.set_root();
}
return _node;
}

void graph::make_edge(node sender, node receiver) {
sender.register_successor(receiver);//register successor
my_graph->remove_root(receiver.my_node); //remove receiver from root node list
sender.register_successor(receiver); // register successor
my_graph->remove_root(receiver.my_node); // remove receiver from root node
// list
}

void graph::exec_and_wait( sycl::queue q ) {
my_graph->exec_and_wait(q);
};
void graph::exec_and_wait(sycl::queue q) { my_graph->exec_and_wait(q); };

} // namespace experimental
} // namespace oneapi
} // namespace ext
} // namespace sycl
} // __SYCL_INLINE_NAMESPACE(cl)

Loading

0 comments on commit 9b46c4b

Please sign in to comment.