Skip to content

Commit f34713d

Browse files
burgholzerburgholzer
committed
🐛 replace std::get calls with std::get_if to increase macOS compatibility
Signed-off-by: burgholzer <[email protected]>
1 parent 79345ba commit f34713d

File tree

3 files changed

+88
-94
lines changed

3 files changed

+88
-94
lines changed

‎taskflow/core/executor.hpp‎

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

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

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

970970
_observer_prologue(w, node);
971971

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

974974
handle.subgraph.clear();
975975

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

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

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

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

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

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

11201120
// Function: run
@@ -1446,6 +1446,3 @@ void Subflow::silent_async(F&& f, ArgsT&&... args) {
14461446

14471447

14481448
} // end of namespace tf -----------------------------------------------------
1449-
1450-
1451-

‎taskflow/core/graph.hpp‎

Lines changed: 27 additions & 30 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

@@ -472,7 +474,7 @@ inline std::vector<Node*> Node::_release_all() {
472474
nodes.insert(end(nodes), begin(r), end(r));
473475
}
474476

475-
return std::move(nodes);
477+
return nodes;
476478
}
477479

478480
// ----------------------------------------------------------------------------
@@ -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)