[Bf-blender-cvs] [9fccaad] object_nodes: Use the new node block structure in code generation, to determine dependencies of symbols.

Lukas Tönne noreply at git.blender.org
Tue Jan 12 12:38:33 CET 2016


Commit: 9fccaadb844a5defbb64940732e638f865186fc4
Author: Lukas Tönne
Date:   Tue Jan 12 11:40:35 2016 +0100
Branches: object_nodes
https://developer.blender.org/rB9fccaadb844a5defbb64940732e638f865186fc4

Use the new node block structure in code generation, to determine dependencies of symbols.

===================================================================

M	source/blender/blenvm/bvm/bvm_eval.cc
M	source/blender/blenvm/bvm/bvm_function.h
M	source/blender/blenvm/compile/bvm_codegen.cc
M	source/blender/blenvm/compile/bvm_codegen.h
M	source/blender/blenvm/compile/bvm_codegen_debug.cc
M	source/blender/blenvm/compile/bvm_nodegraph.cc
M	source/blender/blenvm/compile/bvm_nodegraph.h
M	source/blender/blenvm/util/bvm_util_debug.h

===================================================================

diff --git a/source/blender/blenvm/bvm/bvm_eval.cc b/source/blender/blenvm/bvm/bvm_eval.cc
index 9b61286..0a7e8c5 100644
--- a/source/blender/blenvm/bvm/bvm_eval.cc
+++ b/source/blender/blenvm/bvm/bvm_eval.cc
@@ -1133,7 +1133,8 @@ void EvalContext::eval_function(const EvalGlobals *globals, const Function *fn,
 
 void EvalContext::eval_expression(const EvalGlobals *globals, const Function *fn, int entry_point, float *stack) const
 {
-	eval_instructions(globals, fn, entry_point, stack);
+	if (entry_point != BVM_JMP_INVALID)
+		eval_instructions(globals, fn, entry_point, stack);
 }
 
 } /* namespace bvm */
diff --git a/source/blender/blenvm/bvm/bvm_function.h b/source/blender/blenvm/bvm/bvm_function.h
index 84f7e9c..4de0705 100644
--- a/source/blender/blenvm/bvm/bvm_function.h
+++ b/source/blender/blenvm/bvm/bvm_function.h
@@ -47,6 +47,7 @@ namespace bvm {
 typedef uint32_t Instruction;
 typedef Instruction StackIndex;
 #define BVM_STACK_INVALID 0xFFFFFFFF
+#define BVM_JMP_INVALID 0xFFFFFFFF
 
 static inline Instruction float_to_instruction(float f)
 {
diff --git a/source/blender/blenvm/compile/bvm_codegen.cc b/source/blender/blenvm/compile/bvm_codegen.cc
index c838eba..1f23235 100644
--- a/source/blender/blenvm/compile/bvm_codegen.cc
+++ b/source/blender/blenvm/compile/bvm_codegen.cc
@@ -48,175 +48,83 @@ Compiler::~Compiler()
 {
 }
 
-void Compiler::get_local_args(const NodeGraph &graph, const NodeInstance *node, OutputSet &local_args)
+static bool is_parent_block(const NodeBlock *parent, const NodeBlock *block)
 {
-	if (!node->type->is_kernel_node())
-		return;
-	
-	for (int i = 0; i < node->num_outputs(); ++i) {
-		const NodeOutput *output = node->type->find_output(i);
-		
-		if (output->value_type == OUTPUT_LOCAL) {
-			const NodeGraph::Input *graph_input = graph.get_input(output->name);
-			assert(graph_input);
-			
-			if (graph_input->key) {
-				local_args.insert(graph_input->key);
-			}
-		}
-	}
-}
-
-static bool is_arg_node(const NodeInstance *node, const OutputSet &args)
-{
-	for (int i = 0; i < node->num_outputs(); ++i) {
-		ConstOutputKey output = node->output(i);
-		if (args.find(output) != args.end())
+	while (block->parent()) {
+		block = block->parent();
+		if (block == parent)
 			return true;
 	}
 	return false;
 }
 
-static void count_output_users(const NodeGraph &graph,
-                               BasicBlock &block)
+void Compiler::calc_node_dependencies(const NodeInstance *node, BlockDependencyMap &block_deps_map)
 {
-	block.output_users.clear();
-	for (OrderedNodeSet::const_iterator it = block.nodes.begin(); it != block.nodes.end(); ++it) {
-		const NodeInstance *node = *it;
-		
-		for (int i = 0; i < node->num_outputs(); ++i) {
-			ConstOutputKey key = node->output(i);
-			block.output_users[key] = 0;
-		}
-	}
-	
-	for (OrderedNodeSet::const_iterator it = block.nodes.begin(); it != block.nodes.end(); ++it) {
-		const NodeInstance *node = *it;
-		
-		/* note: pass nodes are normally removed, but can exist for debugging purposes */
-		if (node->type->is_pass_node())
-			continue;
-		
-		for (int i = 0; i < node->num_inputs(); ++i) {
-			if (node->link(i)) {
-				block.output_users[node->link(i)] += 1;
-			}
-		}
-	}
-	
-	/* inputs are defined externally, they should be retained during evaluation */
-	for (NodeGraph::InputList::const_iterator it = graph.inputs.begin(); it != graph.inputs.end(); ++it) {
-		const NodeGraph::Input &input = *it;
-		block.output_users[input.key] += 1;
-	}
-	
-	/* outputs are passed on to the caller, who is responsible for freeing them */
-	for (NodeGraph::OutputList::const_iterator it = graph.outputs.begin(); it != graph.outputs.end(); ++it) {
-		const NodeGraph::Output &output = *it;
-		block.output_users[output.key] += 1;
-	}
-}
-
-bool Compiler::add_block_node(const NodeGraph &graph, const NodeInstance *node, const OutputSet &block_args,
-                              BasicBlock &block, int depth)
-{
-	bool is_block_node = false; /* determines if the node is part of the block */
-	
-	is_block_node |= is_arg_node(node, block_args);
-	
-	OutputSet local_args;
-	get_local_args(graph, node, local_args);
+	if (node_deps_map.find(node) != node_deps_map.end())
+		return;
+	OutputSet &node_deps = node_deps_map[node];
+	OutputSet &block_deps = block_deps_map.at(node->block);
 	
 	for (int i = 0; i < node->num_inputs(); ++i) {
 		ConstInputKey input = node->input(i);
-		if (input.is_constant()) {
-			if (depth == 0)
-				is_block_node |= true;
-		}
-		else if (input.is_expression()) {
-			if (depth == 0)
-				is_block_node |= parse_expression_block(graph, input, block_args, local_args, block, depth);
-		}
-		else {
-			ConstOutputKey output = input.link();
-			if (output) {
-				is_block_node |= add_block_node(graph, output.node, block_args, block, depth);
+		
+		if (input.link()) {
+			const NodeInstance *link_node = input.link().node;
+			
+			if (link_node->block == node->block
+			    || is_parent_block(node->block, link_node->block))
+				node_deps.insert(input.link());
+			else if (is_parent_block(link_node->block, node->block)) {
+				block_deps.insert(input.link());
+			}
+			
+			if (input.is_expression()) {
+				if (link_node->block != node->block) {
+					calc_block_dependencies(link_node->block, block_deps_map);
+					
+					const OutputSet &expr_deps = block_deps_map.at(link_node->block);
+					node_deps.insert(expr_deps.begin(), expr_deps.end());
+				}
 			}
 		}
 	}
-	
-	if (is_block_node) {
-		block.nodes.insert(node);
-		return true;
-	}
-	else
-		return false;
 }
 
-bool Compiler::parse_expression_block(const NodeGraph &graph, const ConstInputKey &input,
-                                      const OutputSet &block_args, const OutputSet &local_args,
-                                      BasicBlock &block, int depth)
+void Compiler::calc_block_dependencies(const NodeBlock *block, BlockDependencyMap &block_deps_map)
 {
-	ConstOutputKey output = input.link();
-	if (!output)
-		return false;
-	const NodeInstance *node = output.node;
-	
-	bool is_block_node = false;
-	
-	/* generate a local block for the input expression */
-	BasicBlock &expr_block = block.expression_blocks[input];
-	
-	add_block_node(graph, node, local_args, expr_block, depth + 1);
-	if (expr_block.nodes.empty()) {
-		/* use the input directly if no expression nodes are generated (no local arg dependencies) */
-		is_block_node |= add_block_node(graph, node, block_args, block, depth);
-	}
-	
-	count_output_users(graph, expr_block);
+	if (block_deps_map.find(block) != block_deps_map.end())
+		return;
+	block_deps_map[block] = OutputSet();
 	
-	/* find node inputs in the expression block that use values outside of it,
-	 * which means these must be included in the parent block
-	 */
-	for (OrderedNodeSet::const_iterator it = expr_block.nodes.begin(); it != expr_block.nodes.end(); ++it) {
+	for (NodeSet::const_iterator it = block->nodes().begin(); it != block->nodes().end(); ++it) {
 		const NodeInstance *node = *it;
-		for (int i = 0; i < node->num_inputs(); ++i) {
-			ConstInputKey expr_input = node->input(i);
-			const NodeInstance *link_node = expr_input.link().node;
-			if (link_node && expr_block.nodes.find(link_node) == expr_block.nodes.end())
-				is_block_node |= add_block_node(graph, link_node, block_args, block, depth);
-		}
+		calc_node_dependencies(node, block_deps_map);
 	}
-	
-	return is_block_node;
 }
 
-void Compiler::parse_blocks(const NodeGraph &graph)
+void Compiler::calc_symbol_scope(const NodeGraph &graph)
 {
-	OutputSet main_args;
-	for (NodeGraph::InputList::const_iterator it = graph.inputs.begin(); it != graph.inputs.end(); ++it) {
-		const NodeGraph::Input &input = *it;
-		if (input.key)
-			main_args.insert(input.key);
+	{
+		BlockDependencyMap block_deps_map;
+		calc_block_dependencies(&graph.main_block(), block_deps_map);
 	}
 	
-	main = BasicBlock();
-	
+	assert(output_users.empty());
+	for (NodeDependencyMap::const_iterator it = node_deps_map.begin(); it != node_deps_map.end(); ++it) {
+		const OutputSet &deps = it->second;
+		
+		for (OutputSet::const_iterator it_dep = deps.begin(); it_dep != deps.end(); ++it_dep) {
+			ConstOutputKey output = *it_dep;
+			
+			++output_users[output];
+		}
+	}
+	/* retain graph outputs for the main caller */
 	for (NodeGraph::OutputList::const_iterator it = graph.outputs.begin(); it != graph.outputs.end(); ++it) {
 		const NodeGraph::Output &output = *it;
 		if (output.key)
-			add_block_node(graph, output.key.node, main_args, main, 0);
-	}
-	/* input argument nodes must always be included in main,
-	 * to provide reliable storage for caller arguments
-	 */
-	for (NodeGraph::InputList::const_iterator it = graph.inputs.begin(); it != graph.inputs.end(); ++it) {
-		const NodeGraph::Input &input = *it;
-		if (input.key)
-			add_block_node(graph, input.key.node, main_args, main, 0);
+			++output_users[output.key];
 	}
-	
-	count_output_users(graph, main);
 }
 
 StackIndex Compiler::find_stack_index(int size) const
@@ -252,68 +160,65 @@ StackIndex Compiler::assign_stack_index(const TypeDesc &typedesc)
 	return stack_offset;
 }
 
-void Compiler::resolve_basic_block_symbols(const NodeGraph &graph, BasicBlock &block)
+void Compiler::get_local_arg_indices(const NodeInstance *node, const NodeBlock *local_block)
 {
-	for (OrderedNodeSet::const_iterator it = block.nodes.begin(); it != block.nodes.end(); ++it) {
-		const NodeInstance &node = **it;
+	for (int i = 0; i < node->num_outputs(); ++i) {
+		ConstOutputKey output = node->output(i);
 		
-		/* local arguments for expression inputs */
-		OutputIndexMap local_output_index;
-		local_output_index.insert(block.output_index.begin(), block.output_index.end());
+		if (output.socket->value_type == OUTPUT_LOCAL) {
+			ConstOutputKey local_output = local_block->local_arg(output.socket->name);
+			output_index[local_output] = output_index.at(output);
+		}
+	}
+}
+
+void Compiler::resolve_node_block_symbols(const NodeBlock *block)
+{
+	assert(block_info.find(block) == block_info.end());
+	block_info[block] = BlockInfo();
+	
+	OrderedNodeSet nodes;
+	nodes.insert(block->nodes().begin(), block->nodes().end());
+	
+	for (OrderedNodeSet::const_iterator it = nodes.begin(); it != nodes.end(); ++it) {
+		const NodeInstance &node = **i

@@ Diff output truncated at 10240 characters. @@




More information about the Bf-blender-cvs mailing list