Differential D7618 Diff 24385 source/blender/blenlib/intern/task_graph.cc

Changeset View

Standalone View

source/blender/blenlib/intern/task_graph.cc

This file was added.

				/*
				* This program is free software; you can redistribute it and/or
				* modify it under the terms of the GNU General Public License
				* as published by the Free Software Foundation; either version 2
				* of the License, or (at your option) any later version.
				*
				* This program is distributed in the hope that it will be useful,
				* but WITHOUT ANY WARRANTY; without even the implied warranty of
				* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
				* GNU General Public License for more details.
				*
				* You should have received a copy of the GNU General Public License
				* along with this program; if not, write to the Free Software Foundation,
				* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
				*/

				/** \file
				* \ingroup bli
				*
				* Task graph.
				*/

				#include "MEM_guardedalloc.h"

				#include "BLI_listbase.h"
				#include "BLI_task.h"

				#ifdef WITH_TBB
				/* Quiet top level deprecation message, unrelated to API usage here. */
				# define TBB_SUPPRESS_DEPRECATED_MESSAGES 1
				# include "tbb/flow_graph.h"
				# include <tbb/tbb.h>
				#endif

				/* Task Graph */
				struct TaskGraph {
				/* the flow graph from TBB */
				tbb::flow::graph tbb_graph;
				/* A list with all created `TaskNode`s. */
				ListBase nodes;

				~TaskGraph();

				/* Creates a new node with the given TaskGraphNodeRunFunction */
				TaskNode *add_node(TaskGraphNodeRunFunction run,
				void *user_data,
				TaskGraphNodeFreeFunction free_func);
				/* finish all scheduled work */
				void work_and_wait();

				#ifdef WITH_CXX_GUARDEDALLOC
				MEM_CXX_CLASS_ALLOC_FUNCS("task_graph:TaskGraph")
				#endif
				};

				/* TaskNode - a node in the task graph. */
				struct TaskNode {
				/* Adds DNA_listbase#Link so TaskNode can be used with ListBase. */
				struct TaskNode next, prev;

				/* Reference to the task_graph this node belongs to. */
				TaskGraph *task_graph;
				/* The user function that will be executed. */
				TaskGraphNodeRunFunction run_func;
				void *task_data;
				TaskGraphNodeFreeFunction free_func;

				/* Reference to the TBB `graph_node` of this node. */
				tbb::flow::continue_node<tbb::flow::continue_msg> tbb_node;

				tbb::flow::continue_msg run(const tbb::flow::continue_msg UNUSED(input))
				{
				run_func(task_data);
				return tbb::flow::continue_msg();
				}

				TaskNode(TaskGraph *task_graph,
				TaskGraphNodeRunFunction run_func,
				void *task_data,
				TaskGraphNodeFreeFunction free_func)
				: next(NULL),
				prev(NULL),
				task_graph(task_graph),
				run_func(run_func),
				task_data(task_data),
				free_func(free_func),
				tbb_node(task_graph->tbb_graph,
				tbb::flow::unlimited,
				std::bind(&TaskNode::run, this, std::placeholders::_1))
				{
				}

				~TaskNode()
				{
				if (task_data && free_func) {
				free_func(task_data);
				}
				}

				#ifdef WITH_CXX_GUARDEDALLOC
				MEM_CXX_CLASS_ALLOC_FUNCS("task_graph:TaskMessage")
				#endif
				};

				TaskGraph::~TaskGraph()
				{
				while (TaskNode task_node = (TaskNode )BLI_pophead(&nodes)) {
				delete task_node;
				}
				}

				TaskNode *TaskGraph::add_node(TaskGraphNodeRunFunction run,
				void *task_data,
				TaskGraphNodeFreeFunction free_func)
				{
				TaskNode *task_node = new TaskNode(this, run, task_data, free_func);
				BLI_addtail(&nodes, task_node);
				return task_node;
				}
				void TaskGraph::work_and_wait()
				{
				tbb_graph.wait_for_all();
				}

				TaskGraph *BLI_task_graph_create(void)
				{
				TaskGraph *task_graph = new TaskGraph();
				return task_graph;
				}

				void BLI_task_graph_free(TaskGraph *task_graph)
				{
				BLI_assert(task_graph);
				delete task_graph;
				}

				void BLI_task_graph_work_and_wait(TaskGraph *task_graph)
				{
				BLI_assert(task_graph);
				task_graph->work_and_wait();
				}

				struct TaskNode BLI_task_graph_node_create(struct TaskGraph task_graph,
				TaskGraphNodeRunFunction run,
				void *user_data,
				TaskGraphNodeFreeFunction free_func)
				{
				BLI_assert(task_graph);
				TaskNode *task_node = task_graph->add_node(run, user_data, free_func);
				return task_node;
				}

				bool BLI_task_graph_node_push_work(struct TaskNode *task_node)
				{
				BLI_assert(task_node);
				return task_node->tbb_node.try_put(tbb::flow::continue_msg());
				}

				void BLI_task_graph_edge_create(struct TaskNode from_node, struct TaskNode to_node)
				{
				BLI_assert(from_node);
				BLI_assert(to_node);
				BLI_assert(from_node->task_graph == to_node->task_graph);
				tbb::flow::make_edge(from_node->tbb_node, to_node->tbb_node);
				}
				No newline at end of file