From 4975f1e0b17cee620a58b29232867c667c24b0e3 Mon Sep 17 00:00:00 2001 From: David Robillard Date: Thu, 5 Oct 2017 19:15:57 +0200 Subject: Simplify Task implementation --- src/server/CompiledGraph.cpp | 8 +++---- src/server/CompiledGraph.hpp | 6 ++--- src/server/Task.cpp | 56 +++++++++++++++++++++----------------------- src/server/Task.hpp | 24 +++++++++++++++---- 4 files changed, 54 insertions(+), 40 deletions(-) diff --git a/src/server/CompiledGraph.cpp b/src/server/CompiledGraph.cpp index 09e378b4..337baf95 100644 --- a/src/server/CompiledGraph.cpp +++ b/src/server/CompiledGraph.cpp @@ -55,7 +55,7 @@ has_provider_with_many_dependants(BlockImpl* n) CompiledGraph::CompiledGraph(GraphImpl* graph) : _log(graph->engine().log()) , _path(graph->path()) - , _master(new Task(Task::Mode::SEQUENTIAL)) + , _master(Task::Mode::SEQUENTIAL) { compile_graph(graph); } @@ -139,7 +139,7 @@ CompiledGraph::compile_graph(GraphImpl* graph) compile_block(b, seq, depth, predecessors); par.push_front(std::move(seq)); } - _master->push_front(std::move(par)); + _master.push_front(std::move(par)); blocks = predecessors; } @@ -257,7 +257,7 @@ CompiledGraph::compile_block(BlockImpl* n, void CompiledGraph::run(RunContext& context) { - _master->run(context); + _master.run(context); } void @@ -265,7 +265,7 @@ CompiledGraph::dump(std::function sink) const { sink("(compiled-graph "); sink(_path); - _master->dump(sink, 2, false); + _master.dump(sink, 2, false); sink(")\n"); } diff --git a/src/server/CompiledGraph.hpp b/src/server/CompiledGraph.hpp index 0578c18a..8d6ebf52 100644 --- a/src/server/CompiledGraph.hpp +++ b/src/server/CompiledGraph.hpp @@ -73,9 +73,9 @@ private: size_t max_depth, BlockSet& k); - Log& _log; - const Raul::Path _path; - std::unique_ptr _master; + Log& _log; + const Raul::Path _path; + Task _master; }; } // namespace Server diff --git a/src/server/Task.cpp b/src/server/Task.cpp index f15c9881..7f1d4327 100644 --- a/src/server/Task.cpp +++ b/src/server/Task.cpp @@ -30,14 +30,14 @@ Task::run(RunContext& context) _block->process(context); break; case Mode::SEQUENTIAL: - for (const auto& task : _children) { - task->run(context); + for (auto& task : _children) { + task.run(context); } break; case Mode::PARALLEL: // Initialize (not) done state of sub-tasks - for (const auto& task : _children) { - task->set_done(false); + for (auto& task : _children) { + task.set_done(false); } // Grab the first sub-task @@ -66,7 +66,7 @@ Task::steal(RunContext& context) if (_mode == Mode::PARALLEL) { const unsigned i = _next++; if (i < _children.size()) { - return _children[i].get(); + return &_children[i]; } } @@ -84,7 +84,7 @@ Task::get_task(RunContext& context) while (true) { // Push done end index as forward as possible - while (_done_end < _children.size() && _children[_done_end]->done()) { + while (_done_end < _children.size() && _children[_done_end].done()) { ++_done_end; } @@ -105,36 +105,34 @@ Task::get_task(RunContext& context) } } -std::unique_ptr -Task::simplify(std::unique_ptr&& task) +Task +Task::simplify(Task task) { - if (task->mode() == Mode::SINGLE) { - return std::move(task); + if (task.mode() == Mode::SINGLE) { + return task; } - for (auto t = task->_children.begin(); t != task->_children.end();) { - *t = simplify(std::move(*t)); - if ((*t)->empty()) { - // Empty task, erase - t = task->_children.erase(t); - } else if ((*t)->mode() == task->_mode) { - // Subtask with the same type, fold child into parent - std::unique_ptr child(std::move(*t)); - t = task->_children.erase(t); - t = task->_children.insert( - t, - std::make_move_iterator(child->_children.begin()), - std::make_move_iterator(child->_children.end())); - } else { - ++t; + Task ret(task.mode()); + for (auto&& c : task._children) { + auto child = simplify(std::move(c)); + if (!child.empty()) { + if (child.mode() == task.mode()) { + // Merge child into parent + for (auto&& grandchild : child._children) { + ret.append(std::move(grandchild)); + } + } else { + // Add child task + ret.append(std::move(child)); + } } } - if (task->_children.size() == 1) { - return std::move(task->_children.front()); + if (ret._children.size() == 1) { + return std::move(ret._children.front()); } - return std::move(task); + return ret; } void @@ -152,7 +150,7 @@ Task::dump(std::function sink, unsigned indent, bool } else { sink(((_mode == Mode::SEQUENTIAL) ? "(seq " : "(par ")); for (size_t i = 0; i < _children.size(); ++i) { - _children[i]->dump(sink, indent + 5, i == 0); + _children[i].dump(sink, indent + 5, i == 0); } sink(")"); } diff --git a/src/server/Task.hpp b/src/server/Task.hpp index 982a6206..203627a1 100644 --- a/src/server/Task.hpp +++ b/src/server/Task.hpp @@ -17,9 +17,10 @@ #ifndef INGEN_ENGINE_TASK_HPP #define INGEN_ENGINE_TASK_HPP +#include #include #include -#include +#include #include namespace Ingen { @@ -55,6 +56,17 @@ public: , _done(task._done.load()) {} + Task& operator=(Task&& task) + { + _children = std::move(task._children); + _block = task._block; + _mode = task._mode; + _done_end = task._done_end; + _next = task._next.load(); + _done = task._done.load(); + return *this; + } + /** Run task in the given context. */ void run(RunContext& context); @@ -65,14 +77,14 @@ public: bool empty() const { return _mode != Mode::SINGLE && _children.empty(); } /** Simplify task expression. */ - static std::unique_ptr simplify(std::unique_ptr&& task); + static Task simplify(Task task); /** Steal a child task from this task (succeeds for PARALLEL only). */ Task* steal(RunContext& context); /** Prepend a child to this task. */ void push_front(Task&& task) { - _children.push_front(std::unique_ptr(new Task(std::move(task)))); + _children.emplace_front(std::move(task)); } Mode mode() const { return _mode; } @@ -82,13 +94,17 @@ public: void set_done(bool done) { _done = done; } private: - typedef std::deque> Children; + typedef std::deque Children; Task(const Task&) = delete; Task& operator=(const Task&) = delete; Task* get_task(RunContext& context); + void append(Task t) { + _children.emplace_back(std::move(t)); + } + Children _children; ///< Vector of child tasks BlockImpl* _block; ///< Used for SINGLE only Mode _mode; ///< Execution mode -- cgit v1.2.1