def __new__( cls, t_domain, t_codomain ): assert(isinstance(t_domain, BasicTypeVariable)) assert(isinstance(t_codomain, (TypeVariable, TypeTuple, TypeList))) obj = Basic.__new__(cls, t_domain, t_codomain) obj._tag = random_string( 4 ) return obj
def __new__(cls, expr, args): # ... if not isinstance(args, (tuple, list, Tuple)): args = [args] args = Tuple(*args) # ... return Basic.__new__(cls, expr, args)
def __new__( cls, func, target ): if not isinstance(target, (list, tuple, Tuple)): target = [target] target = Tuple(*target) obj = Basic.__new__(cls, func, target) obj._tag = random_string( 4 ) return obj
def __new__( cls, func, target ): assert(isinstance( func, FunctionSymbol )) assert(isinstance( target, Dict )) obj = Basic.__new__( cls, func, target ) tag = random_string( 4 ) obj._name = 'partial_{func}_{tag}'.format( func=func.name, tag=tag ) obj._funcdef = None return obj
def __new__(cls, *args): # ... create iterator and index variables iterable = args if len(args) == 1: iterable = args[0] tag = random_string(4) index = new_variable('int', iterable, tag=tag) iterator = new_variable('real', iterable, tag=tag) length = new_variable('int', iterable, tag=tag, kind='len') # ... return Basic.__new__(cls, iterable, index, iterator, length)
def __new__( cls, var, rank=0 ): assert(isinstance(var, (Variable, TypeVariable))) dtype = var.dtype rank = var.rank + rank is_stack_array = var.is_stack_array order = var.order precision = var.precision shape = var.shape obj = Basic.__new__( cls, dtype, rank, is_stack_array, order, precision, shape ) obj._tag = random_string( 4 ) return obj
def __new__(cls, *args): # ... create iterator and index variables target = args if len(args) == 1: print(args) raise NotImplementedError('') tag = random_string(4) length = new_variable('int', target[0], tag=tag, kind='len') index = new_variable('int', target[0], tag=tag) iterator = new_variable('real', target, tag=tag) # ... return Basic.__new__(cls, args, index, iterator, length)
def __new__(cls, *args): # ... create iterator and index variables target = args assert (len(args) > 1) tag = random_string(4) length = new_variable('int', target, tag=tag, kind='len') index = new_variable('int', target, tag=tag) iterator = new_variable('real', target, tag=tag) multi_index = new_variable('int', target[0], tag=tag, kind='multi') # ... obj = Basic.__new__(cls, args, index, iterator, length, multi_index) obj._is_list = False return obj
def __new__( cls, var, rank=0 ): assert(isinstance(var, (tuple, list, Tuple))) for i in var: assert( isinstance(i, (Variable, TypeVariable)) ) t_vars = [] for i in var: t_var = TypeVariable( i, rank=rank ) t_vars.append(t_var) t_vars = Tuple(*t_vars) obj = Basic.__new__(cls, t_vars) obj._tag = random_string( 4 ) return obj
def __new__(cls, block, **kwargs): # ... settings = kwargs.copy() accelerator = settings.pop('accelerator', None) # ... # ... assert (isinstance(block, GeneratorBlock)) # ... # ... decs = block.decs body = block.body # ... # ... add parallel loop if accelerator: if not (accelerator == 'omp'): raise NotImplementedError('Only OpenMP is available') # ... create clauses clauses = [] # ##### DEBUG # clauses += [OMP_NumThread(4)] # ... # ... create variables variables = [] # ... # ... body = [OMP_Parallel(clauses, variables, body)] # ... # TODO this is a hack to handle the last comment after a loop, so that # it can be parsed and added to the For body += [Pass()] # ... decs = Tuple(*decs) body = Tuple(*body) return Basic.__new__(cls, decs, body)
def __new__( cls, var ): assert(isinstance(var, (TypeVariable, TypeTuple, TypeList))) obj = Basic.__new__(cls, var) obj._tag = random_string( 4 ) # ... def _get_core_type(expr): if isinstance(expr, TypeList): return _get_core_type(expr.parent) else: return expr # ... obj._types = _get_core_type(var) return obj
def __new__(cls, generator): # ... define the name for the shape and the statements to be able to # compute it inside the python interface if isinstance(generator, VariableGenerator): var = generator.length stmts = [Assign(var, Len(generator.arguments))] elif isinstance(generator, ZipGenerator): var = generator.length stmts = [Assign(var, Len(generator.arguments[0]))] elif isinstance(generator, ProductGenerator): arguments = generator.arguments length = generator.length stmts = [Assign(l, Len(a)) for l, a in zip(length, arguments)] if generator.is_list: n = 1 for i in length: n *= i else: n = length var = Dummy() stmts += [Assign(var, n)] else: msg = 'not available for {}'.format(type(generator)) raise NotImplementedError(msg) stmts = Tuple(*stmts) return Basic.__new__(cls, var, stmts)
def __new__( cls, target ): obj = Basic.__new__(cls, target) obj._name = 'reduce_{}'.format( random_string( 4 ) ) return obj
def __new__( cls, *target ): target = Tuple(*target) obj = Basic.__new__(cls, target) obj._name = 'product_{}'.format( random_string( 4 ) ) return obj
def __new__( cls, func ): assert(isinstance( func, Lambda )) return Basic.__new__( cls, func )
def __new__(cls, op, arguments): # assert( isinstance( generator, BasicGenerator ) ) assert (isinstance(op, str)) assert (op in ['+', '-']) return Basic.__new__(cls, op, arguments)
def __new__(cls, generator, stmts, **kwargs): # ... settings = kwargs.copy() accelerator = settings.pop('accelerator') nowait = settings.pop('nowait') schedule = settings.pop('schedule') chunk = settings.pop('chunk') # ... # ... assert (isinstance(generator, BasicGenerator)) decs, body = _build_block(generator, stmts) # ... # ... assert (isinstance(decs, (tuple, list, Tuple))) assert (isinstance(body, (tuple, list, Tuple))) decs = Tuple(*decs) body = Tuple(*body) # ... # ... define private variables of the current block private_vars = generator.private # TODO add private vars from internal blocks private_vars = Tuple(*private_vars) # ... # ... add parallel loop if accelerator: if not (accelerator == 'omp'): raise NotImplementedError('Only OpenMP is available') # ... create clauses clauses = [] # TODO move this treatment to OMP_Schedule if chunk is None: clauses += [OMP_Schedule(schedule)] else: clauses += [OMP_Schedule(schedule, chunk)] if private_vars: clauses += [OMP_Private(*private_vars)] # ... # ... assert (len(body) == 1) loop = body[0] body = [OMP_For(loop, Tuple(*clauses), nowait)] # ... # ... decs = Tuple(*decs) body = Tuple(*body) return Basic.__new__(cls, generator, decs, body, private_vars)
def __new__(cls, block, reduction, lhs, **kwargs): # ... settings = kwargs.copy() accelerator = settings.pop('accelerator') # ... assert (isinstance(reduction, Reduction)) # ... if isinstance(lhs, (list, tuple, Tuple)): raise NotImplementedError() # ... # ... generator = block.generator decs = block.decs body = block.body private_vars = generator.private # ... # ... lhs_name = lhs.name assign_stmts = list(block.body.atoms(Assign)) # ... # ... ls = [i for i in assign_stmts if _get_name(i.lhs) == lhs_name] if len(ls) > 1: raise NotImplementedError() assign_iterable = ls[0] rhs = assign_iterable.rhs new_stmt = AugAssign(lhs, reduction.op, rhs) body = block.body.subs(assign_iterable, new_stmt) decs = block.decs # ... # ... add initial values for reduced variables _reduction_init = lambda i: _get_default_value(i, op=reduction.op) reduction_stmts = [ Assign(r, _reduction_init(r)) for r in reduction.arguments ] # update declarations decs = list(decs) + reduction_stmts decs = Tuple(*decs) # ... # ... define private variables of the current block # TODO add private vars from internal blocks private_vars = Tuple(*private_vars) # ... # ... add parallel loop if accelerator: if not (accelerator == 'omp'): raise NotImplementedError('Only OpenMP is available') # ... omp_fors = list(body.atoms(OMP_For)) omp_for = [i for i in body if isinstance(i, OMP_For)] assert (len(omp_for) == 1) omp_for = omp_for[0] loop = omp_for.loop clauses = list(omp_for.clauses) nowait = omp_for.nowait # ... reduction_args = [reduction.op] + list(reduction.arguments) clauses += [OMP_Reduction(*reduction_args)] clauses = Tuple(*clauses) # ... new = OMP_For(loop, clauses, nowait) body = body.subs(omp_for, new) # ... decs = Tuple(*decs) body = Tuple(*body) return Basic.__new__(cls, generator, decs, body, private_vars)