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))
