def _mk_func1(): declars = n, inp, out = Variable('n', integer), Pointer('inp', real), Pointer( 'out', real) i = Variable('i', integer) whl = While(i < n, [Assignment(out[i], inp[i]), PreIncrement(i)]) body = CodeBlock(i.as_Declaration(value=0), whl) return FunctionDefinition(void, 'our_test_function', declars, body)
def _mk_func1(): declars = n, inp, out = ( Variable("n", integer), Pointer("inp", real), Pointer("out", real), ) i = Variable("i", integer) whl = While(i < n, [Assignment(out[i], inp[i]), PreIncrement(i)]) body = CodeBlock(i.as_Declaration(value=0), whl) return FunctionDefinition(void, "our_test_function", declars, body)
def test_Pointer(): p = Pointer(x) assert p.symbol == x assert p.type == None assert not p.value_const assert not p.pointer_const u = symbols('u', real=True) py = Pointer(u, {value_const, pointer_const}, Type.from_expr(u)) assert py.symbol is u assert py.type == real assert py.value_const assert py.pointer_const
def test_ccode_Declaration(): i = symbols('i', integer=True) var1 = Variable(i, type=Type.from_expr(i)) dcl1 = Declaration(var1) assert ccode(dcl1) == 'int i' var2 = Variable(x, type=float32, attrs={value_const}) dcl2a = Declaration(var2) assert ccode(dcl2a) == 'const float x' dcl2b = var2.as_Declaration(value=pi) assert ccode(dcl2b) == 'const float x = M_PI' var3 = Variable(y, type=Type('bool')) dcl3 = Declaration(var3) printer = C89CodePrinter() assert 'stdbool.h' not in printer.headers assert printer.doprint(dcl3) == 'bool y' assert 'stdbool.h' in printer.headers u = symbols('u', real=True) ptr4 = Pointer.deduced(u, attrs={pointer_const, restrict}) dcl4 = Declaration(ptr4) assert ccode(dcl4) == 'double * const restrict u' var5 = Variable(x, Type('__float128'), attrs={value_const}) dcl5a = Declaration(var5) assert ccode(dcl5a) == 'const __float128 x' var5b = Variable(var5.symbol, var5.type, pi, attrs=var5.attrs) dcl5b = Declaration(var5b) assert ccode(dcl5b) == 'const __float128 x = M_PI'
def test_ccode_Declaration(): i = symbols('i', integer=True) var1 = Variable(i, type=Type.from_expr(i)) dcl1 = Declaration(var1) assert ccode(dcl1) == 'int i' var2 = Variable(x, type=float32, attrs={value_const}) dcl2a = Declaration(var2) assert ccode(dcl2a) == 'const float x' dcl2b = var2.as_Declaration(value=pi) assert ccode(dcl2b) == 'const float x = M_PI' var3 = Variable(y, type=Type('bool')) dcl3 = Declaration(var3) printer = C89CodePrinter() assert 'stdbool.h' not in printer.headers assert printer.doprint(dcl3) == 'bool y' assert 'stdbool.h' in printer.headers u = symbols('u', real=True) ptr4 = Pointer.deduced(u, attrs={pointer_const, restrict}) dcl4 = Declaration(ptr4) assert ccode(dcl4) == 'double * const restrict u' var5 = Variable(x, Type('__float128'), attrs={value_const}) dcl5a = Declaration(var5) assert ccode(dcl5a) == 'const __float128 x' var5b = Variable(var5.symbol, var5.type, pi, attrs=var5.attrs) dcl5b = Declaration(var5b) assert ccode(dcl5b) == 'const __float128 x = M_PI'
def test_ccode_Declaration(): i = symbols("i", integer=True) var1 = Variable(i, type=Type.from_expr(i)) dcl1 = Declaration(var1) assert ccode(dcl1) == "int i" var2 = Variable(x, type=float32, attrs={value_const}) dcl2a = Declaration(var2) assert ccode(dcl2a) == "const float x" dcl2b = var2.as_Declaration(value=pi) assert ccode(dcl2b) == "const float x = M_PI" var3 = Variable(y, type=Type("bool")) dcl3 = Declaration(var3) printer = C89CodePrinter() assert "stdbool.h" not in printer.headers assert printer.doprint(dcl3) == "bool y" assert "stdbool.h" in printer.headers u = symbols("u", real=True) ptr4 = Pointer.deduced(u, attrs={pointer_const, restrict}) dcl4 = Declaration(ptr4) assert ccode(dcl4) == "double * const restrict u" var5 = Variable(x, Type("__float128"), attrs={value_const}) dcl5a = Declaration(var5) assert ccode(dcl5a) == "const __float128 x" var5b = Variable(var5.symbol, var5.type, pi, attrs=var5.attrs) dcl5b = Declaration(var5b) assert ccode(dcl5b) == "const __float128 x = M_PI"
def test_Pointer(): p = Pointer(x) assert p.symbol == x assert p.type == untyped assert value_const not in p.attrs assert pointer_const not in p.attrs assert p.func(*p.args) == p u = symbols('u', real=True) pu = Pointer(u, type=Type.from_expr(u), attrs={value_const, pointer_const}) assert pu.symbol is u assert pu.type == real assert value_const in pu.attrs assert pointer_const in pu.attrs assert pu.func(*pu.args) == pu i = symbols('i', integer=True) deref = pu[i] assert deref.indices == (i,)
def kernel_arg_local_assign(self, args_var): member_types = { "int32": lambda x: Variable(x, type=int32), "uint32": lambda x: Variable(x, type=uint32), "pint8": lambda x: Pointer(x, type=int8, attrs=(restrict, )), } return [ AssignmentEx( Declaration(member_types[kernel_arg[1]](kernel_arg[0])), StructVariable(args_var, Symbol(kernel_arg[0]))) for kernel_arg in self.kernel_args ]
def kernel_arg_type_codegen(self, type_name): member_types = { "int32": lambda x: Variable(x, type=int32), "uint32": lambda x: Variable(x, type=uint32), "pint8": lambda x: Pointer(x, type=int8), } main_block = [] main_block.append( TypeDef( type_name, Struct( type_name, (StructMember(member_types[kernel_arg[1]](kernel_arg[0])) for kernel_arg in self.kernel_args)))) return ccode(CodeBlock(*main_block), contract=False, type_mappings=TYPE_MAPPINGS)
def setup_codegen(self): args_var = Pointer("Args") block = self.kernel_arg_local_assign(args_var) if self._kernel_dims == 1: last_first = Variable("Sz", type=uint32) block.append( AssignmentEx(Declaration(last_first), Symbol("W") * Symbol("H"))) elif self._kernel_dims == 2: last_first = Variable("H", type=uint32) elif self._kernel_dims == 3: last_first = Variable("InFeatures", type=uint32) else: raise ValueError("expression has too many dimensions") var_chunk = Variable("Chunk", type=uint32) var_first = Variable("First", type=uint32) var_last = Variable("Last", type=uint32) var_coreid = Variable("CoreId", type=uint32) # unsigned int CoreId = gap_coreid(); block.append( AssignmentEx(Declaration(var_coreid), FunctionCall("gap_coreid", []))) # unsigned int Chunk = ChunkSize(OutFeatures); block.append( AssignmentEx(Declaration(var_chunk), FunctionCall("ChunkSize", [last_first]))) # unsigned int First = Chunk*CoreId; block.append( AssignmentEx(Declaration(var_first), Symbol("Chunk") * Symbol("CoreId"))) # unsigned int Last = Min(First+Chunk, OutFeatures); block.append( AssignmentEx( Declaration(var_last), FunctionCall("gap_min", [Symbol("First") + Symbol("Chunk"), last_first]))) return block
def test_Pointer(): p = Pointer(x) assert p.symbol == x assert p.type == untyped assert value_const not in p.attrs assert pointer_const not in p.attrs assert p.func(*p.args) == p u = symbols('u', real=True) pu = Pointer(u, type=Type.from_expr(u), attrs={value_const, pointer_const}) assert pu.symbol is u assert pu.type == real assert value_const in pu.attrs assert pointer_const in pu.attrs assert pu.func(*pu.args) == pu i = symbols('i', integer=True) deref = pu[i] assert deref.indices == (i, )
def gen_function(self, kernel_name, kernel_arg_type_name): main_block = [] main_block.append( Comment( "Output iteration space %s reduced to %s iteration spaces" % (self._max_shape, len(self._indexes)))) # dereference all symbols that are not indexed dereference = [ symbol for symbol in self._symbol_indexes if not self._symbol_indexes[symbol] ] for expr_state in self._expr_states: free_symbols = [ symbol for symbol in expr_state.expr.free_symbols if not symbol in self._temporaries ] # create substitutions for symbols that are indexed subs = [(symbol, indexed_symbol(symbol, [ self._indexes[idx][1] for idx in self._symbol_indexes[symbol] ], [ self._indexes[idx][0] for idx in self._symbol_indexes[symbol] ])) for symbol in free_symbols if self._symbol_indexes[symbol]] # indexed results. non indexed temps if not expr_state.is_intermediate: main_block.append( Comment("Produce output symbol %s" % expr_state.symbol)) res_symbol = IndexedBase( expr_state.symbol, shape=tuple(tuple(index[1] for index in self._indexes))) res_symbol = res_symbol[tuple(index[0] for index in self._indexes)] else: main_block.append( Comment("Produce intermediate symbol %s" % expr_state.symbol)) res_symbol = expr_state.symbol main_block.append( Assignment(res_symbol, expr_state.expr.subs(subs))) # create all the for loops def func(block, idx): return [ VarFor(Declaration(Variable(Symbol(idx[0]), type=uint32)), VarRange(idx[2][0], idx[2][1], Integer(1)), block) ] for_block = reduce(func, self._indexes[::-1], main_block)[0] # Create the initial code with args assignments and paralellization calcluation ast = self.setup_codegen() # declare temporaries ast.extend([ Declaration(Variable(symbol, type=int32)) for symbol in self._temporaries ]) ast.append(for_block) ast.append(FunctionCall("gap_waitbarrier", (Integer(0), ))) # create function definition func_def = FunctionDefinition( VOID, kernel_name, [Pointer("Args", type=Type(kernel_arg_type_name))], ast) # generate code return ccode(func_def, contract=False, dereference=dereference, user_functions=CFUNC_DEFS, type_mappings=TYPE_MAPPINGS)