def create_declaration(edge, edge_map): expr_type = utils.get_attribute_value(edge.attributes['type']) vid = edge.vid var = create_value(expr_type, vid) vid_dims = utils.get_attribute_value( edge_map[vid].attributes['dimensions']) expr_dims = utils.get_attribute_value(edge.attributes['dimensions']) expr_attributes = list(edge.attributes) if len(vid_dims) > 0: for d in vid_dims: var = c.ArrayOf(var, d) elif len(expr_dims) > 0: for d in expr_dims: var = c.ArrayOf(var, d) elif edge.iid != '': iid = edge.iid bounds, bounds_dict = get_dims(iid, edge_map) for b in bounds: lower = bounds_dict[b][0] upper = bounds_dict[b][1] size = '(' + '(' + upper + ')' + '-' + lower + ')' + '+1' var = c.ArrayOf(var, size) return vid, var
def get_node(self, edge): if is_literal(edge): if edge not in self.symbol_table.keys(): node = DFGNode() node.operation = edge node.name = edge node.dataType = 'constant' self.dfg.add(node) self.connect_node(self.dfg.get(0), node) self.symbol_table[edge] = [node] return self.symbol_table[edge] else: return self.symbol_table[edge] elif edge in self.symbol_table.keys(): return self.symbol_table[edge] else: edge_info = self.flattened_graph.edge_info[edge] if 'alias' in list(edge_info.attributes): alias = hdfgutils.get_attribute_value( edge_info.attributes['alias']) print("Alias is: {}".format(alias)) vid = edge_info.vid context, var = self.get_var_context(edge) if edge_info.iid: iid = edge_info.iid if iid in list(self.flattened_graph.edge_info): iid_info = self.flattened_graph.edge_info[iid] elif (context + "/" + iid) in list( self.flattened_graph.edge_info): iid_info = self.flattened_graph.edge_info[context + "/" + iid] else: logging.error( "Index id not in edge map: context {}, id: {}".format( context, iid)) dimensions = hdfgutils.get_attribute_value( iid_info.attributes['dimensions']) if len(dimensions) == 0: dimensions.append(iid) _ = self.generate_index_nodes([''], dimensions, context, '') vid_hash = context + '/' + vid if len(self.symbol_table[vid_hash]) != len(self.idx_map[iid]): logging.error( "Trying to use wrong dimensional input for: {} with index {}, {} and {} " .format(vid, iid, len(self.symbol_table[vid_hash]), len(self.idx_map[iid]))) exit(1) else: self.symbol_table[edge] = self.symbol_table[vid_hash].copy( ) return self.symbol_table[edge] else: print(self.symbol_table.keys()) logging.error( "Error, edge not found in symbol table and doesnt have index: {}, vid: {} edge name: {}" .format(edge, vid, edge_info.name))
def init_var(self, var, instance_name, literal=False): args = [] kwargs = {} arg_type = var['arg_type'] if isinstance(instance_name, str): id = instance_name.rsplit('/', 1) if len(id) > 1: id = id[-1] else: id = id[0] else: id = str(instance_name).rsplit('/', 1) if len(id) > 1: id = id[-1] else: id = id[0] if arg_type == 'parameter' and not literal and not is_literal(id): if instance_name not in list(self.tvm_graph.edge_info): logging.error( f"Unable to get value for parameter {instance_name}") exit(1) edge = self.tvm_graph.edge_info[instance_name] if 'value' not in list(edge.attributes): logging.error( f"Could not find literal for parameter argument {instance_name}.\n" f"Possible attributes: {list(edge.attributes)}") exit(1) value = hdfgutils.get_attribute_value(edge.attributes['value']) elif is_literal(id): edge = self.tvm_graph.edge_info[id] value = hdfgutils.get_attribute_value(edge.attributes['value']) else: value = instance_name for a in var['init_func_args']: arg_result = self.get_arg_attribute(a, value, literal=literal) args.append(arg_result) for k in var['init_func_kw'].keys(): kwargs[k] = self.get_arg_attribute(var['init_func_kw'][k], value, literal=literal) if len(kwargs.keys()) == 0: var = self.get_func(var['init_func'])(*args) else: var = self.get_func(var['init_func'])(*args, **kwargs) return var
def create_gradient_table(self): for sg in self.flattened_graph.statement_graphs: nodes = sg.statement_node node_cats = [self.node_map[n].op_cat for n in nodes] if node_cats[-1] == 'read_write': assignee_edge = self.flattened_graph.edge_info[self.node_map[ nodes[-1]].output[0]] assignee_key = nodes[-1] else: continue assignee_update = False gradient = None gradient_key = None for n in nodes: node_info = self.node_map[n] if n == assignee_key: assignee_update = True else: cat = node_info.op_cat for i in node_info.input: if i in list(self.flattened_graph.edge_info): in_edge = self.flattened_graph.edge_info[i] vcat = hdfgutils.get_attribute_value( in_edge.attributes['vcat']) if vcat == 'assign': gradient = in_edge.name gradient_key = in_edge.vid if assignee_update and gradient: self.gradient_table[gradient_key] = True self.link_table[gradient] = assignee_key
def __init__(self, template, run_async): self.template = template if template.name == 'main': self.name = 'main_component' else: self.name = template.name self.graph = template.sub_graph self.edges = template.edge_info self.input = list(template.input) self.output = list(template.output) self.state = list(template.state) self.queues = self.input + self.output + self.state self.parameters = template.parameters self.op_type = template.op_type self.statements = template.statement_graphs self.order = utils.get_attribute_value( template.attributes['ordered_args']) self.vars = {} self.struct_members = [] self.init_args = [] self.assignments = [] self.var_names = [] self.node_map = {} self.components = {} self.create_node_map() self.init = ComponentInit(self.name, self.vars, self.var_names, self.op_type, self.order) self.instance = InstanceData(self.name, self.vars, self.var_names) self.execution = ComponentExecution(self.name, self.vars, self.var_names, self.statements, self.node_map, self.edges, run_async, self.op_type, template.statements)
def get_edge_dims(self, edge): if 'dimensions' in list(edge.attributes): dims = tuple(hu.get_attribute_value(edge.attributes['dimensions'])) else: dims = tuple() return dims
def get_vars(self, cname): vars = [] comp = self.templates[cname] # Parameters are constant arguments for p in list(comp.parameters): p_edge = comp.edge_info[p] dtype = hu.get_attribute_value(p_edge.attributes['type']) dims = self.get_edge_dims(p_edge) param_var = lp.ConstantArg(p, dtype, shape=dims) vars.append(param_var) # Need to add read only option for inputs # Inputs, outputs, and states represent global_args = list(comp.input) + list(comp.output) + list(comp.state) dim_vars = [] for g in global_args: g_edge = comp.edge_info[g] dtype = hu.get_attribute_value(g_edge.attributes['type']) dims = self.get_edge_dims(g_edge) for d in dims: if d not in dim_vars: dim_vars.append(d) dim_var = lp.ValueArg(d, dtype=np.int32) vars.append(dim_var) if len(dims) == 0: g_var = lp.ValueArg(g, dtype=dtype) else: g_var = lp.GlobalArg(g, dtype=dtype, shape=dims) vars.append(g_var) # Each flow declaration is a temporary variable declared in the comp scope for s in comp.statements: if s.op_type == 'declaration' and s.op_cat == 'declaration': d_vars = list(s.output) for d in d_vars: edge_decl = comp.edge_info[d] dims = self.get_edge_dims(edge_decl) dtype = hu.get_attribute_value( edge_decl.attributes['type']) t_var = lp.TemporaryVariable(d, dtype=dtype, shape=dims) vars.append(t_var) return vars
def create_default_map(self, template): default_map = {} ordered_args = hdfgutils.get_attribute_value( template.attributes['ordered_args']) for a in ordered_args: if a not in list(template.edge_info): logging.error( f"Argument {a} not found in edges for {template.op_type}") edge = template.edge_info[a] if 'default' in list(edge.attributes): dtype = hdfgutils.get_attribute_value(edge.attributes['type']) default_map[a] = CMLANG_CAST_MAP[dtype]( hdfgutils.get_attribute_value(edge.attributes['default'])) else: default_map[a] = None return default_map
def create_tvm_graph(self): self.graph_variables = {} output_id = None for n in self.tvm_graph.sub_graph: op_cat = hdfgutils.get_attribute_value(n.attributes['op_cat']) if op_cat == 'mapped_node': op_context = str(n.name).rsplit("/", 1) if len(op_context) > 1 and op_context[0] != 'main': scope = op_context[0] + '/' else: scope = '' op_config = self.translator_config['ops'][n.op_type] op_func = self.get_func(op_config['op_name']) args, kwargs, output_id = self.create_op_args( n.op_type, n, self.templates[n.op_type], scope) if len(output_id) == 1: self.graph_variables[output_id[0]] = op_func( *args, **kwargs) if output_id[0] in list(self.tvm_graph.edge_info): iedge = self.tvm_graph.edge_info[output_id[0]] if iedge.name != output_id[0]: self.graph_variables[str( iedge.name)] = self.graph_variables[ output_id[0]] else: temp = op_func(*args, **kwargs) if not hasattr(temp, '__len__'): logging.error( f"Size mismatch between output of {n.op_type} which has length 1 output" f"Supplied config outputs: {output_id}") exit(1) elif len(temp) != len(output_id): logging.error( f"Size mismatch between output of {n.op_type} which has length {len(temp)} output" f"Supplied config outputs: {output_id}") exit(1) for i in range(len(temp)): self.graph_variables[output_id[i]] = temp[i] if output_id[i] in list(self.tvm_graph.edge_info): iedge = self.tvm_graph.edge_info[output_id[i]] if iedge.name != output_id[i]: self.graph_variables[str( iedge.name)] = self.graph_variables[ output_id[i]] if not output_id: logging.error(f"No nodes mapped for graph") exit(1) elif len(output_id) != 1: logging.error( f"More than one output supplied for graph: {output_id}") exit(1)
def __init__(self, node, bounds, bounds_dict, group_id): self.function_code = [] self.expr_type = utils.get_attribute_value( node.attributes['edge_type']) self.bounds = bounds self.bounds_dict = bounds_dict self.expr_arg = node.input[0] self.function = node.op_type self.group_id = group_id
def get_arg_attribute(self, key, instance_name, literal=False): if isinstance(key, list): arg = [] for k in key: arg.append( self.get_arg_attribute(k, instance_name, literal=literal)) return arg elif key == 'name': return instance_name elif key == 'shape': if literal: logging.error( f"Cannot get shape for literal value {instance_name} as attribute" ) exit(1) edge = self.tvm_graph.edge_info[instance_name] if 'dimensions' not in list(edge.attributes): logging.error(f"No dimensions for edge {instance_name}") tuple_dims = () else: dimensions = hdfgutils.get_attribute_value( edge.attributes['dimensions']) tuple_dims = tuple( int(d) if is_number(d) else d for d in dimensions) return tuple_dims elif key == 'type': if literal: return type(instance_name).__name__ edge = self.tvm_graph.edge_info[instance_name] if 'type' not in list(edge.attributes): logging.error(f"No type for edge {instance_name}") dtype = 'float32' else: dtype = hdfgutils.get_attribute_value(edge.attributes['type']) return dtype elif instance_name in self.graph_variables.keys(): return self.graph_variables[instance_name] else: logging.error( f"Could not create attribute for {instance_name} with key {key}." ) exit(1)
def create_op_args(self, op_name, node, node_signature, scope): op_config = self.translator_config['ops'][op_name] instance_args = hdfgutils.get_attribute_value( node.attributes['ordered_args']) signature_args = hdfgutils.get_attribute_value( node_signature.attributes['ordered_args']) default_map = self.create_default_map(self.templates[op_name]) for i in range(len(instance_args)): instance_args[i] = scope + instance_args[i] args = self.get_ordered_args(op_config, signature_args, instance_args, default_map, op_name, scope) kwargs = self.get_kwargs(op_config, signature_args, instance_args, default_map, op_name, scope) output_keys = self.get_output_keys(op_config, signature_args, instance_args, op_name, scope) return args, kwargs, output_keys
def create_constant_table(self): for e in list(self.flattened_graph.edge_info): edge = self.flattened_graph.edge_info[e] vtype = hdfgutils.get_attribute_value(edge.attributes['vtype']) dtype = hdfgutils.get_attribute_value(edge.attributes['type']) if 'alias' in list(edge.attributes) and vtype == 'scalar': context, var = self.get_var_context(e) if context not in self.const_table.keys(): self.const_table[context] = {} alias = hdfgutils.get_attribute_value(edge.attributes['alias']) if var not in self.const_table[context].keys(): if dtype == 'int': self.const_table[context][var] = int(alias) elif dtype == 'float': self.const_table[context][var] = float(alias) else: self.const_table[context][var] = alias
def get_dims(edge, edge_map): edge_dims = utils.get_attribute_value(edge.attributes['dimensions']) vid = edge.vid vid_dims = utils.get_attribute_value( edge_map[vid].attributes['dimensions']) attributes = list(edge.attributes) if len(vid_dims) > 0: return vid_dims elif len(edge_dims) > 0: return edge_dims elif edge.iid != '': iid = edge.iid vid_type = utils.get_attribute_value(edge_map[iid].attributes['vtype']) if vid_type not in ['scalar', 'var']: bounds, bounds_dict = get_index_dims(iid, edge_map) return [bounds_dict[b][2] for b in bounds] else: return [iid] else: return []
def get_index_dims(index_id, edge_map): index = edge_map[index_id] bounds = [] bounds_dict = {} dims = utils.get_attribute_value(index.attributes['dimensions']) if len(dims) > 0: for d in dims: vid_type = utils.get_attribute_value( edge_map[d].attributes['vtype']) if vid_type not in ['scalar', 'var']: bounds.append(d) dim_edge = edge_map[d] if 'lower' not in list( dim_edge.attributes) or 'upper' not in list( dim_edge.attributes): logging.error( f"Bounds not available for dimension {d}, variable {index_id}" ) exit(1) else: lower = utils.get_attribute_value( dim_edge.attributes['lower']) upper = utils.get_attribute_value( dim_edge.attributes['upper']) size = '(' + '(' + upper + ')' + '-' + lower + ')' + '+1' bounds_dict[d] = [lower, upper, size] else: bounds.append(index.name) lower = utils.get_attribute_value(index.attributes['lower']) upper = utils.get_attribute_value(index.attributes['upper']) size = '(' + '(' + upper + ')' + '-' + lower + ')' + '+1' bounds_dict[index.name] = [lower, upper, size] return bounds, bounds_dict
def create_iter_table(self): for e in list(self.flattened_graph.edge_info): edge = self.flattened_graph.edge_info[e] vtype = hdfgutils.get_attribute_value(edge.attributes['vtype']) vcat = hdfgutils.get_attribute_value(edge.attributes['vcat']) if vcat == 'declaration' and vtype == 'index': context = "/".join(e.split('/')[:-1]) lower = hdfgutils.get_attribute_value(edge.attributes['lower']) upper = hdfgutils.get_attribute_value(edge.attributes['upper']) lower_val = self.try_eval(lower, context) upper_val = self.try_eval(upper, context) if not is_literal(str(lower_val)): logging.error( "Error, indices not evaluated for {}, lower val {}". format(e, lower)) if not is_literal(str(upper_val)): logging.error( "Error, indices not evaluated for {}, upper val {}". format(e, upper)) self.iter_table[e] = (lower_val, upper_val)
def try_eval(self, expr, context): context_expr = context + "/" + expr if expr in list(self.flattened_graph.edge_info): edge_expr = self.flattened_graph.edge_info[expr] elif context_expr in list(self.flattened_graph.edge_info): edge_expr = self.flattened_graph.edge_info[(context_expr)] else: print("Error! No expression in edges: {}".format(expr)) vtype = hdfgutils.get_attribute_value(edge_expr.attributes['vtype']) if vtype == 'scalar': return int(expr) else: result = eval(expr, self.const_table[context].copy()) return result
def __init__(self, statement, edges, vars, var_names, defined): self.statement_node = statement self.stype = statement.op_type self.nodes = statement.sub_graph self.vars = vars self.var_names = var_names self.line = utils.get_attribute_value(self.nodes[0].attributes['line']) self.line = self.line.replace(";", "") self.node_cats = [n.op_cat for n in self.nodes] self.edges = edges self.read_func = None self.write_func = None self.path = None self.read_func_size = None self.group_vals = 0 self.statements = [] self.new_variable = None self.defined = defined self.create_statement()
def create_symbol_table(self): for c in self.const_table.keys(): for k in self.const_table[c].keys(): const = c + '/' + k node = DFGNode() node.operation = const node.name = const node.dataType = 'constant' self.dfg.add(node) self.connect_node(self.dfg.get(0), node) self.symbol_table[const] = [node] for ename in list(self.flattened_graph.edge_info): context, var = self.get_var_context(ename) context_expr = context + "/" + var if var in list(self.flattened_graph.edge_info): e = var edge = self.flattened_graph.edge_info[var] elif context_expr in list(self.flattened_graph.edge_info): e = context_expr edge = self.flattened_graph.edge_info[context_expr] else: logging.error( "Error! Edge name not in edge map: {}, context: {}".format( var, context)) vtype = hdfgutils.get_attribute_value(edge.attributes['vtype']) vcat = hdfgutils.get_attribute_value(edge.attributes['vcat']) if e in self.flattened_graph.input or e in self.flattened_graph.state: if e in self.flattened_graph.input: dtype = 'model_input' elif e in self.flattened_graph.state: dtype = 'model' dims = hdfgutils.get_attribute_value( edge.attributes['dimensions']) if len(dims) == 0: if 'alias' in list(edge.attributes): name = hdfgutils.get_attribute_value( edge.attributes['alias']) else: name = e node = DFGNode() node.operation = name node.dataType = dtype self.dfg.add(node) self.connect_node(self.dfg.get(0), node) self.symbol_table[name] = [node] else: iters = [] for d in dims: if d.isdigit(): iter = int(d) iters.append(iter) elif d in self.const_table[context].keys(): iter = self.const_table[context][d] iters.append(iter) else: logging.error( "Dimension not in constants: {}".format(d)) node_strings = self.generate_array_nodes([e], iters) self.symbol_table[e] = [] for n in node_strings: node = DFGNode() node.operation = n node.name = n node.dataType = dtype self.dfg.add(node) self.connect_node(self.dfg.get(0), node) self.symbol_table[e].append(node)
def handle_assignment_statement(self): assign = [] if self.node_cats[-1] == 'assign': self.assignee = self.edges[self.nodes[-1].output[0]] else: self.assignee = self.edges[self.nodes[-2].output[0]] assignee_attr = list(self.assignee.attributes) vid = self.assignee.vid vid_type = utils.get_attribute_value( self.edges[vid].attributes['vtype']) if vid_type not in ['index', 'scalar'] and vid not in self.defined: new = self.vars[vid] self.new_variable = c.Value(new['dtype'], '(*' + vid + ')') size_text = 'sizeof({dtype}'.format(dtype=new['dtype']) for di in range(len(new['dims'])): d = new['dims'][di] if di > 0: self.new_variable = c.ArrayOf(self.new_variable, d) size_text += '[{dim}]'.format(dim=d) self.new_variable = c.Assign( self.new_variable, 'malloc({size}))'.format(size=size_text)) self.defined.append(vid) if self.assignee.iid != '': iid = self.assignee.iid vtype = utils.get_attribute_value( self.edges[iid].attributes['vtype']) if vtype == 'index': loop_statement = True else: loop_statement = False else: loop_statement = False orig_line = self.line # text_map = {"e()" : "M_E"} text_map = {} nnames = [n.name for n in self.nodes] # print(f"Original line: {self.line}\t {nnames}") for n in list(self.nodes)[::-1]: op = n.name op_cat = n.op_cat op_type = n.op_type inputs = n.input if op_cat == 'group': index_id = inputs[-1] bounds, bounds_dict = cutils.get_index_dims( index_id, self.edges) temp_var = 'group_' + str(self.group_vals) self.group_vals += 1 group = GroupFunction(n, bounds, bounds_dict, temp_var) group.gen_code() assign += group.function_code if op in text_map.keys(): op = text_map[op] text_map[op] = temp_var self.line = self.line.replace(op, temp_var) elif op_cat == 'function': fn = self.handle_function(op_type, n.input, assignment=self.assignee.name) if fn: if n.output[0] in text_map.keys(): op = text_map[n.output[0]] else: op = n.output[0] text_map[op] = fn self.line = self.line.replace(op, fn) elif op_type == 'exp': if inputs[0] in text_map.keys(): op1 = text_map[inputs[0]] else: op1 = inputs[0] if inputs[1] in text_map.keys(): op2 = text_map[inputs[1]] else: op2 = inputs[1] if op in text_map.keys(): op = text_map[op] # if op in self.line: # print(f"Test 1 {op} in {self.line}") # elif '(' + op + ')' in self.line: # print(f"Test 2 {'(' + op + ')'} in {self.line}") # else: # temp_op1 = '(' + op1 + ')' # temp_op2 = '(' + op2 + ')' # test1 = temp_op1 + '^' + temp_op2 # test2 = temp_op1 + '^' + op2 # test3 = op1 + '^' + temp_op2 # if test1 in self.line: # print(f"test 3: {test1} in {self.line}") # elif test2 in self.line: # print(f"test 4: {test2} in {self.line}") # elif test3 in self.line: # print(f"test 5: {test3} in {self.line}") # else: # print(f"No replacements for {self.line} with {op}") new_pow = 'pow({op1},{op2})'.format(op1=op1, op2=op2) text_map[op] = new_pow self.line = self.line.replace(op, new_pow) # print(f"Final line: {self.line}") # print("\n") assign.append(c.Statement(self.line)) if loop_statement: bounds, bounds_dict = cutils.get_index_dims(iid, self.edges) idx = Index(assign, bounds_dict, bounds) return [idx.loop] elif self.read_func: return [] else: return assign
def create_node_map(self): for n in self.graph: name = n.name self.node_map[name] = n op_cat = n.op_cat if op_cat == 'component': if n.op_type not in self.components.keys(): self.components[n.op_type] = 0 name = n.op_type + '_' + str(self.components[n.op_type]) self.components[n.op_type] += 1 init_arg = c.Pointer(cutils.create_value( '_' + n.op_type, name)) ordered_args = utils.get_attribute_value( n.attributes['ordered_args']) var = { 'vtype': 'component', 'name': name, 'pointers': 1, 'struct_dtype': '_' + n.op_type, 'dtype': '_' + n.op_type, 'dims': [], 'init_type': name, 'init_arg_type': init_arg, 'cname': n.op_type, 'args': ordered_args, 'input': list(n.input) } self.add_var(var) elif op_cat == 'assign' or op_cat == 'argument': assignee = self.edges[n.output[0]] vid = assignee.vid dtype = utils.get_attribute_value(assignee.attributes['type']) dims = cutils.get_dims(assignee, self.edges) pointers = len(dims) default = None if vid in self.input: struct_dtype = 'input' vtype = 'flow' init_type = self.queue_map['input'].format(qname=vid) init_arg_type = cutils.create_value('flow', vid) elif vid in self.output: struct_dtype = 'output' vtype = 'flow' init_type = self.queue_map['output'].format(qname=vid) init_arg_type = cutils.create_value('flow', vid) elif vid in self.state: struct_dtype = 'state' vtype = 'flow' init_type = self.queue_map['input'].format(qname=vid) init_arg_type = cutils.create_value('flow', vid) elif vid in self.parameters: struct_dtype = dtype vtype = 'param' init_arg_type = cutils.create_value(dtype, vid) for _ in range(pointers): init_arg_type = c.Pointer(init_arg_type) init_type = vid attributes = list(self.edges[vid].attributes) if 'default' in attributes: default = utils.get_attribute_value( self.edges[vid].attributes['default']) else: vtype = 'dynamic_variable' struct_dtype = None init_arg_type = None init_type = None if vid in self.queues or vid in self.parameters: for d in dims: dimvar = { 'name': d, 'vtype': 'dim', 'dims': [], 'pointers': 0, 'struct_dtype': 'int', 'dtype': 'int', 'init_type': d, 'init_arg_type': cutils.create_value('int', d) } self.add_var(dimvar) var = { 'name': vid, 'vtype': vtype, 'dims': dims, 'pointers': pointers, 'struct_dtype': struct_dtype, 'dtype': dtype, 'init_type': init_type, 'init_arg_type': init_arg_type, 'default': default } self.add_var(var) elif op_cat == 'declaration': dtype = utils.get_attribute_value( self.edges[n.output[0]].attributes['type']) var = { 'name': n.output[0], 'vtype': 'flow_declaration', 'dims': list(n.input), 'pointers': 0, 'struct_dtype': None, 'dtype': dtype, 'init_type': None, 'init_arg_type': None } self.add_var(var) elif op_cat == 'index': index = self.edges[n.output[0]] dims = utils.get_attribute_value( index.attributes['dimensions']) if len(dims) == 0: dims = '(' + '(' + n.input[1] + ')' + '-' + n.input[ 0] + ')' + '+1' vtype = 'index_declaration' low = n.input[0] upper = n.input[1] else: vtype = 'multi_index' low = None upper = None var = { 'name': n.output[0], 'vtype': vtype, 'dims': dims, 'pointers': 0, 'struct_dtype': None, 'dtype': 'int', 'init_type': None, 'init_arg_type': None, 'lower': low, 'upper': upper } self.add_var(var)
def create_dfg(self): for sg in self.flattened_graph.statement_graphs: nodes = sg.statement_node node_cats = [self.node_map[n].op_cat for n in nodes] if 'assign' in node_cats: self.idx_map = {} if node_cats[-1] == 'read_write': assign_node = self.node_map[nodes[-2]] assignee_edge = self.flattened_graph.edge_info[ self.node_map[nodes[-2]].output[0]] context, var = self.get_var_context(assignee_edge.name) assignee_key = nodes[-1] else: assign_node = self.node_map[nodes[-1]] assignee_edge = self.flattened_graph.edge_info[ self.node_map[nodes[-1]].output[0]] context, var = self.get_var_context(assignee_edge.name) assignee_key = context + '/' + str(assignee_edge.vid) if assignee_edge.iid: iid = assignee_edge.iid if iid in list(self.flattened_graph.edge_info): iid_info = self.flattened_graph.edge_info[iid] elif (context + "/" + iid) in list( self.flattened_graph.edge_info): iid_info = self.flattened_graph.edge_info[context + "/" + iid] else: logging.error( "Index id not in edge map: context {}, id: {}". format(context, iid)) dimensions = hdfgutils.get_attribute_value( iid_info.attributes['dimensions']) if len(dimensions) == 0: dimensions.append(iid) node_strings = self.generate_index_nodes([assignee_key], dimensions, context, '') else: node_strings = [assignee_key] result = self.create_statement_nodes(nodes) if len(result) != len(node_strings): print("Assignee key for unequal nodes: {}".format( assignee_key)) else: var_id = var[:var.find('[')] if var_id in self.gradient_table.keys(): dtype = 'gradient' else: dtype = result[0].dataType if assignee_key not in self.symbol_table.keys(): self.symbol_table[assignee_key] = [] for n in range(len(node_strings)): result[n].dataType = dtype self.symbol_table[assignee_key].append(result[n]) for key in self.symbol_table.keys(): # Connect outputs if key in list(self.flattened_graph.state): for node in self.symbol_table[key]: if len(node.children) is 0 and len(node.parents) is not 1: node.dataType = 'model' self.connect_node(node, self.dfg.get(1))