def get_result_type(operand1, operand2, operator):
for t in ('double', 'float') + sum(
(('int%d_t' % w, 'uint%d_t' % w) for w in (64, 32, 16, 8)), tuple()):
if t in (operand1, operand2):
return t
raise util.SemanticError('cannot parse type: %s %s %s' %
(operand1, operator, operand2))
def _get_expr_for(self, node):
if isinstance(node, grammar.Output):
return node.expr
if isinstance(node, grammar.Local):
return node.expr
raise util.SemanticError('cannot get expression for %s' %
str(type(node)))
def __init__(self, **kwargs):
super().__init__(**kwargs)
for node in self.input_stmts:
if hasattr(self, 'tile_size'):
# pylint: disable=access-member-before-definition
if self.tile_size != node.tile_size:
msg = (
'tile size %s doesn\'t match previous one %s' %
# pylint: disable=access-member-before-definition
(node.tile_size, self.tile_size))
raise util.SemanticError(msg)
elif node.tile_size[:-1]:
self.tile_size = node.tile_size
self.dim = len(self.tile_size)
# deal with 1D case
if not hasattr(self, 'tile_size'):
# pylint: disable=undefined-loop-variable
self.tile_size = node.tile_size
self.dim = len(self.tile_size)
def __init__(self, **kwargs):
self.iterate = kwargs.pop('iterate')
if self.iterate < 1:
raise util.SemanticError('cannot iterate %d times' % self.iterate)
self.border = kwargs.pop('border')
self.preserve_border = self.border == 'preserve'
self.cluster = kwargs.pop('cluster')
# platform determined
self.burst_width = kwargs.pop('burst_width')
# application determined
self.app_name = kwargs.pop('app_name')
# parameters that can be explored
self.tile_size = tuple(kwargs.pop('tile_size'))
self.unroll_factor = kwargs.pop('unroll_factor')
self.replication_factor = kwargs.pop('replication_factor')
# stage-independent
self.dim = kwargs.pop('dim')
self.param_stmts = kwargs.pop('param_stmts')
# stage-specific
self.input_stmts = kwargs.pop('input_stmts')
self.local_stmts = kwargs.pop('local_stmts')
self.output_stmts = kwargs.pop('output_stmts')
self.optimizations = {}
if 'optimizations' in kwargs:
self.optimizations = kwargs.pop('optimizations')
if 'dram_in' in kwargs:
dram_in = kwargs.pop('dram_in')
if dram_in is not None:
if ':' in dram_in:
input_stmt_map = {_.name: _ for _ in self.input_stmts}
for dram_map in dram_in.split('^'):
var_name, bank_list = dram_map.split(':')
if var_name not in input_stmt_map:
raise util.SemanticError(
'no input named `{}`'.format(var_name))
input_stmt_map[var_name].dram = tuple(
map(int, bank_list.split('.')))
else:
for input_stmt in self.input_stmts:
input_stmt.dram = tuple(map(int, dram_in.split('.')))
if 'dram_out' in kwargs:
dram_out = kwargs.pop('dram_out')
if dram_out is not None:
if ':' in dram_out:
output_stmt_map = {_.name: _ for _ in self.output_stmts}
for dram_map in dram_out.split(','):
var_name, bank_list = dram_map.split(':')
if var_name not in output_stmt_map:
raise util.SemanticError(
'no output named `{}`'.format(var_name))
output_stmt_map[var_name].dram = tuple(
map(int, bank_list.split('.')))
else:
for output_stmt in self.output_stmts:
output_stmt.dram = tuple(map(int, dram_out.split('.')))
if self.iterate > 1:
if len(self.input_stmts) != len(self.output_stmts):
raise util.SemanticError(
'number of input tensors must be the same as output if iterate > 1 '
'times, currently there are %d input(s) but %d output(s)' %
(len(self.input_stmts), len(self.output_stmts)))
if self.input_types != self.output_types:
raise util.SemanticError(
'input must have the same type(s) as output if iterate > 1 '
'times, current input has type %s but output has type %s' %
(util.lst2str(
self.input_types), util.lst2str(self.output_types)))
_logger.debug(
'pipeline %d iterations of [%s] -> [%s]' %
(self.iterate, ', '.join('%s: %s' %
(stmt.haoda_type, stmt.name)
for stmt in self.input_stmts),
', '.join('%s: %s' % (stmt.haoda_type, stmt.name)
for stmt in self.output_stmts)))
for stmt in itertools.chain(self.local_stmts, self.output_stmts):
_logger.debug('simplify %s', stmt.name)
# LocalStmt and OutputStmt must remember the stencil object
# for type propagation
stmt.stencil = self
stmt.expr = arithmetic.simplify(stmt.expr)
stmt.let = arithmetic.simplify(stmt.let)
self._cr_counter = 0
cr.computation_reuse(self)
if 'inline' in self.optimizations:
inline.inline(self)
inline.rebalance(self)
for stmt in itertools.chain(self.local_stmts, self.output_stmts):
stmt.propagate_type()
# soda frontend successfully parsed
_logger.debug(
'producer tensors: [%s]',
', '.join(tensor.name for tensor in self.producer_tensors))
_logger.debug(
'consumer tensors: [%s]',
', '.join(tensor.name for tensor in self.consumer_tensors))
# TODO: build Ref table and Var table
# generate reuse buffers and get haoda nodes
# pylint: disable=pointless-statement
self.dataflow_super_source
_logger.debug('dataflow: %s', self.dataflow_super_source)
_logger.debug('module table: %s', dict(self.module_table))
_logger.debug('module traits: %s', self.module_traits)