Skip to content

Commit 47e6583

Browse files
twhuang-utahtwhuang-utah
committed
Merge branch 'master' of https://github.com/taskflow/taskflow 
2 parents 99ed1ea + d890a7f commit 47e6583

3 files changed

Lines changed: 87 additions & 93 deletions

File tree

‎taskflow/core/executor.hpp‎

Lines changed: 21 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -919,7 +919,7 @@ inline void Executor::_tear_down_invoke(Node* node, bool cancel) {
919919
// async task needs to carry out the promise
920920
case Node::ASYNC:
921921
if(cancel) {
922-
std::get<Node::Async>(node->_handle).work(true);
922+
std::get_if<Node::Async>(&(node->_handle))->work(true);
923923
}
924924
_tear_down_async(node);
925925
break;
@@ -960,17 +960,17 @@ inline void Executor::_observer_epilogue(Worker& worker, Node* node) {
960960

961961
// Procedure: _invoke_static_task
962962
inline void Executor::_invoke_static_task(Worker& worker, Node* node) {
963-
_observer_prologue(worker, node);
964-
std::get<Node::Static>(node->_handle).work();
965-
_observer_epilogue(worker, node);
963+
_observer_prologue(worker, node);
964+
std::get_if<Node::Static>(&(node->_handle))->work();
965+
_observer_epilogue(worker, node);
966966
}
967967

968968
// Procedure: _invoke_dynamic_task
969969
inline void Executor::_invoke_dynamic_task(Worker& w, Node* node) {
970970

971971
_observer_prologue(w, node);
972972

973-
auto& handle = std::get<Node::Dynamic>(node->_handle);
973+
auto& handle = *(std::get_if<Node::Dynamic>(&(node->_handle)));
974974

975975
handle.subgraph.clear();
976976

@@ -1077,45 +1077,45 @@ inline void Executor::_invoke_dynamic_task_internal(
10771077
inline void Executor::_invoke_condition_task(
10781078
Worker& worker, Node* node, int& cond
10791079
) {
1080-
_observer_prologue(worker, node);
1081-
cond = std::get<Node::Condition>(node->_handle).work();
1082-
_observer_epilogue(worker, node);
1080+
_observer_prologue(worker, node);
1081+
cond = std::get_if<Node::Condition>(&(node->_handle))->work();
1082+
_observer_epilogue(worker, node);
10831083
}
10841084

10851085
// Procedure: _invoke_cudaflow_task
10861086
inline void Executor::_invoke_cudaflow_task(Worker& worker, Node* node) {
1087-
_observer_prologue(worker, node);
1088-
std::get<Node::cudaFlow>(node->_handle).work(*this, node);
1089-
_observer_epilogue(worker, node);
1087+
_observer_prologue(worker, node);
1088+
std::get_if<Node::cudaFlow>(&(node->_handle))->work(*this, node);
1089+
_observer_epilogue(worker, node);
10901090
}
10911091

10921092
// Procedure: _invoke_syclflow_task
10931093
inline void Executor::_invoke_syclflow_task(Worker& worker, Node* node) {
1094-
_observer_prologue(worker, node);
1095-
std::get<Node::syclFlow>(node->_handle).work(*this, node);
1096-
_observer_epilogue(worker, node);
1094+
_observer_prologue(worker, node);
1095+
std::get_if<Node::syclFlow>(&(node->_handle))->work(*this, node);
1096+
_observer_epilogue(worker, node);
10971097
}
10981098

10991099
// Procedure: _invoke_module_task
11001100
inline void Executor::_invoke_module_task(Worker& w, Node* node) {
11011101
_observer_prologue(w, node);
1102-
auto module = std::get<Node::Module>(node->_handle).module;
1102+
auto module = std::get_if<Node::Module>(&(node->_handle))->module;
11031103
_invoke_dynamic_task_internal(w, node, module->_graph, false);
11041104
_observer_epilogue(w, node);
11051105
}
11061106

11071107
// Procedure: _invoke_async_task
11081108
inline void Executor::_invoke_async_task(Worker& w, Node* node) {
1109-
_observer_prologue(w, node);
1110-
std::get<Node::Async>(node->_handle).work(false);
1111-
_observer_epilogue(w, node);
1109+
_observer_prologue(w, node);
1110+
std::get_if<Node::Async>(&(node->_handle))->work(false);
1111+
_observer_epilogue(w, node);
11121112
}
11131113

11141114
// Procedure: _invoke_silent_async_task
11151115
inline void Executor::_invoke_silent_async_task(Worker& w, Node* node) {
1116-
_observer_prologue(w, node);
1117-
std::get<Node::SilentAsync>(node->_handle).work();
1118-
_observer_epilogue(w, node);
1116+
_observer_prologue(w, node);
1117+
std::get_if<Node::SilentAsync>(&(node->_handle))->work();
1118+
_observer_epilogue(w, node);
11191119
}
11201120

11211121
// Function: run
@@ -1447,6 +1447,3 @@ void Subflow::silent_async(F&& f, ArgsT&&... args) {
14471447

14481448

14491449
} // end of namespace tf -----------------------------------------------------
1450-
1451-
1452-

‎taskflow/core/graph.hpp‎

Lines changed: 26 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -336,31 +336,31 @@ inline Node::~Node() {
336336
// this is to avoid stack overflow
337337

338338
if(_handle.index() == DYNAMIC) {
339+
// using std::get_if instead of std::get makes this compatible with older macOS versions
340+
// the result of std::get_if is guaranteed to be non-null due to the index check above
341+
auto& subgraph = std::get_if<Dynamic>(&_handle)->subgraph;
339342

340-
auto& subgraph = std::get<Dynamic>(_handle).subgraph;
343+
std::vector<Node*> nodes;
344+
nodes.reserve(subgraph.size());
341345

342-
std::vector<Node*> nodes;
343-
nodes.reserve(subgraph.size());
346+
std::move(
347+
subgraph._nodes.begin(), subgraph._nodes.end(), std::back_inserter(nodes));
348+
subgraph._nodes.clear();
344349

345-
std::move(
346-
subgraph._nodes.begin(), subgraph._nodes.end(), std::back_inserter(nodes)
347-
);
348-
subgraph._nodes.clear();
350+
size_t i = 0;
349351

350-
size_t i = 0;
351-
352-
while(i < nodes.size()) {
352+
while(i < nodes.size()) {
353353

354354
if(nodes[i]->_handle.index() == DYNAMIC) {
355-
356-
auto& sbg = std::get<Dynamic>(nodes[i]->_handle).subgraph;
357-
std::move(
358-
sbg._nodes.begin(), sbg._nodes.end(), std::back_inserter(nodes)
359-
);
360-
sbg._nodes.clear();
361-
}
362-
363-
++i;
355+
// using std::get_if instead of std::get makes this compatible with older macOS versions
356+
// the result of std::get_if is guaranteed to be non-null due to the index check above
357+
auto& sbg = std::get_if<Dynamic>(&(nodes[i]->_handle))->subgraph;
358+
std::move(
359+
sbg._nodes.begin(), sbg._nodes.end(), std::back_inserter(nodes));
360+
sbg._nodes.clear();
361+
}
362+
363+
++i;
364364
}
365365

366366
//auto& np = Graph::_node_pool();
@@ -416,12 +416,14 @@ inline const std::string& Node::name() const {
416416
// Function: _is_cancelled
417417
inline bool Node::_is_cancelled() const {
418418
if(_handle.index() == Node::ASYNC) {
419-
auto& h = std::get<Node::Async>(_handle);
420-
if(h.topology && h.topology->_is_cancelled) {
421-
return true;
419+
// using std::get_if instead of std::get makes this compatible with older macOS versions
420+
// the result of std::get_if is guaranteed to be non-null due to the index check above
421+
auto& h = *(std::get_if<Node::Async>(&_handle));
422+
if (h.topology && h.topology->_is_cancelled) {
423+
return true;
424+
}
422425
}
423-
}
424-
// async tasks spawned from subflow does not have topology
426+
// async tasks spawned from subflow does not have topology
425427
return _topology && _topology->_is_cancelled;
426428
}
427429

@@ -565,8 +567,3 @@ inline void Graph::erase(Node* node) {
565567
}
566568

567569
} // end of namespace tf. ---------------------------------------------------
568-
569-
570-
571-
572-

‎taskflow/core/taskflow.hpp‎

Lines changed: 40 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -328,44 +328,43 @@ inline void Taskflow::_dump(
328328
// case edge is dashed
329329
os << 'p' << node << " -> p" << node->_successors[s]
330330
<< " [style=dashed label=\"" << s << "\"];\n";
331-
}
332-
else {
333-
os << 'p' << node << " -> p" << node->_successors[s] << ";\n";
331+
} else {
332+
os << 'p' << node << " -> p" << node->_successors[s] << ";\n";
334333
}
335334
}
336-
335+
337336
// subflow join node
338-
if(node->_parent && node->_successors.size() == 0) {
339-
os << 'p' << node << " -> p" << node->_parent << ";\n";
337+
if (node->_parent && node->_successors.size() == 0) {
338+
os << 'p' << node << " -> p" << node->_parent << ";\n";
340339
}
341340

342-
switch(node->_handle.index()) {
343-
344-
case Node::DYNAMIC: {
345-
auto& sbg = std::get<Node::Dynamic>(node->_handle).subgraph;
346-
if(!sbg.empty()) {
347-
os << "subgraph cluster_p" << node << " {\nlabel=\"Subflow: ";
348-
if(node->_name.empty()) os << 'p' << node;
349-
else os << node->_name;
350-
351-
os << "\";\n" << "color=blue\n";
352-
_dump(os, sbg, dumper);
341+
// using std::get_if instead of std::get in the following makes this compatible with older macOS versions
342+
// the result of std::get_if is guaranteed to be non-null due to the index check
343+
switch (node->_handle.index()) {
344+
case Node::DYNAMIC: {
345+
auto& sbg = std::get_if<Node::Dynamic>(&(node->_handle))->subgraph;
346+
if (!sbg.empty()) {
347+
os << "subgraph cluster_p" << node << " {\nlabel=\"Subflow: ";
348+
if (node->_name.empty())
349+
os << 'p' << node;
350+
else
351+
os << node->_name;
352+
353+
os << "\";\n"
354+
<< "color=blue\n";
355+
_dump(os, sbg, dumper);
353356
os << "}\n";
354357
}
355358
}
356359
break;
357360

358361
case Node::CUDAFLOW: {
359-
std::get<Node::cudaFlow>(node->_handle).graph->dump(
360-
os, node, node->_name
361-
);
362+
std::get_if<Node::cudaFlow>(&(node->_handle))->graph->dump(os, node, node->_name);
362363
}
363364
break;
364365

365366
case Node::SYCLFLOW: {
366-
std::get<Node::syclFlow>(node->_handle).graph->dump(
367-
os, node, node->_name
368-
);
367+
std::get_if<Node::syclFlow>(&(node->_handle))->graph->dump(os, node, node->_name);
369368
}
370369
break;
371370

@@ -387,19 +386,24 @@ inline void Taskflow::_dump(
387386
}
388387
// module task
389388
else {
390-
391-
auto module = std::get<Node::Module>(n->_handle).module;
392-
393-
os << 'p' << n << "[shape=box3d, color=blue, label=\"";
394-
if(n->_name.empty()) os << n;
395-
else os << n->_name;
396-
os << " [Taskflow: ";
397-
if(module->_name.empty()) os << 'p' << module;
398-
else os << module->_name;
399-
os << "]\"];\n";
400-
401-
if(dumper.visited.find(module) == dumper.visited.end()) {
402-
dumper.visited.insert(module);
389+
// using std::get_if instead of std::get makes this compatible with older macOS versions
390+
// the result of std::get_if is guaranteed to be non-null due to the index check above
391+
auto module = std::get_if<Node::Module>(&(n->_handle))->module;
392+
393+
os << 'p' << n << "[shape=box3d, color=blue, label=\"";
394+
if (n->_name.empty())
395+
os << n;
396+
else
397+
os << n->_name;
398+
os << " [Taskflow: ";
399+
if (module->_name.empty())
400+
os << 'p' << module;
401+
else
402+
os << module->_name;
403+
os << "]\"];\n";
404+
405+
if (dumper.visited.find(module) == dumper.visited.end()) {
406+
dumper.visited.insert(module);
403407
dumper.stack.push(module);
404408
}
405409

@@ -539,7 +543,3 @@ bool Future<T>::cancel() {
539543

540544

541545
} // end of namespace tf. ---------------------------------------------------
542-
543-
544-
545-

0 commit comments

Comments
 (0)