[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