def visit_For(self, node): debug_print("visiting a For...\n") # check if this is the right kind of For loop if (node.iter.__class__.__name__ == "Call" and node.iter.func.__class__.__name__ == "Attribute"): debug_print("Found something to change...\n") if (node.iter.func.attr == "interior_points"): grid = self.visit(node.iter.func.value).id # do we need the name of the grid, or the obj itself? target = self.visit(node.target) body = map(self.visit, node.body) newnode = StencilKernel.StencilInteriorIter(grid, body, target) return newnode elif (node.iter.func.attr == "neighbors"): debug_print(ast.dump(node) + "\n") target = self.visit(node.target) body = map(self.visit, node.body) grid = self.visit(node.iter.func.value).id dist = self.visit(node.iter.args[1]).n newnode = StencilKernel.StencilNeighborIter(grid, body, target, dist) return newnode else: return node else: return node
def shadow_kernel(self, *args): if self.pure_python: return self.pure_python_kernel(*args) #FIXME: need to somehow match arg names to args argnames = map(lambda x: str(x.id), self.kernel_ast.body[0].args.args) argdict = dict(zip(argnames[1:], args)) #debug_print('Kernel arguments:\n' + str(argdict)) phase2 = StencilKernel.StencilProcessAST(argdict).visit(self.kernel_ast) debug_print('Phase 2 AST:\n' + ast.dump(phase2)) phase3 = StencilKernel.StencilConvertAST(argdict).visit(phase2) mod = self.asp_module_factory() self.add_libraries(mod) mod.add_function(phase3) grid_data = [grid.data for grid in args] mod.kernel(*grid_data)
def shadow_kernel(self, *args): if self.pure_python: return self.pure_python_kernel(*args) #FIXME: need to somehow match arg names to args argnames = map(lambda x: str(x.id), self.kernel_ast.body[0].args.args) argdict = dict(zip(argnames[1:], args)) debug_print(argdict) phase2 = StencilKernel.StencilProcessAST(argdict).visit(self.kernel_ast) debug_print(ast.dump(phase2)) phase3 = StencilKernel.StencilConvertAST(argdict).visit(phase2) from asp.jit import asp_module mod = asp_module.ASPModule() self.add_libraries(mod) mod.add_function(phase3) # mod.compile() # mod.compiled_module.kernel(argdict['in_grid'].data, argdict['out_grid'].data) myargs = [y.data for y in args] # mod.kernel(argdict['in_grid'].data, argdict['out_grid'].data) mod.kernel(*myargs)
def shadow_kernel(self, *args): if self.pure_python: return self.pure_python_kernel(*args) #FIXME: instead of doing this short-circuit, we should use the Asp infrastructure to # do it, by passing in a lambda that does this check # if already specialized to these sizes, just run if self.specialized_sizes and self.specialized_sizes == [y.shape for y in args]: print "match!" self.mod.kernel(*[y.data for y in args]) return # otherwise, do the first-run flow # check if we can specialize for this data #FIXME: impelement. # ask asp infrastructure for machine and platform info, including if cilk+ is available #FIXME: impelement. set self.with_cilk=true if cilk is available #FIXME: need to somehow match arg names to args argnames = map(lambda x: str(x.id), self.kernel_ast.body[0].args.args) argdict = dict(zip(argnames[1:], args)) debug_print(argdict) phase2 = StencilKernel.StencilProcessAST(argdict).visit(self.kernel_ast) debug_print(ast.dump(phase2)) # depending on whether cilk is available, we choose which converter to use if not self.with_cilk: Converter = StencilKernel.StencilConvertAST else: Converter = StencilKernel.StencilConvertASTCilk # generate variant with no unrolling, then generate variants for various unrollings variants = [Converter(argdict).visit(phase2)] variant_names = ["kernel_unroll_1"] for x in [2,4,8,16,32,64]: check_valid = max(map( lambda y: (y.shape[-1]-2*y.ghost_depth) % x, args)) if check_valid == 0: to_append = Converter(argdict, unroll_factor=x).visit(phase2) variants.append(Converter(argdict, unroll_factor=x).visit(phase2)) variant_names.append("kernel_unroll_%s" % x) from asp.jit import asp_module mod = self.mod = asp_module.ASPModule() self.add_libraries(mod) if self.with_cilk: mod.toolchain.cc = "icc" mod.toolchain.cflags += ["-intel-extensions", "-fast"] mod.toolchain.cflags += ["-I/usr/include/x86_64-linux-gnu"] mod.toolchain.cflags.remove('-fwrapv') else: mod.toolchain.cflags += ["-fopenmp", "-O3", "-msse3"] # print mod.toolchain.cflags if mod.toolchain.cflags.count('-Os') > 0: mod.toolchain.cflags.remove('-Os') if mod.toolchain.cflags.count('-O2') > 0: mod.toolchain.cflags.remove('-O2') debug_print("toolchain" + str(mod.toolchain.cflags)) mod.add_function_with_variants(variants, "kernel", variant_names) # package arguments myargs = [y.data for y in args] # and do the call mod.kernel(*myargs) # save parameter sizes for next run self.specialized_sizes = [x.shape for x in args]
def shadow_kernel(self, *args): if self.pure_python: return self.pure_python_kernel(*args) #FIXME: need to somehow match arg names to args argnames = map(lambda x: str(x.id), self.kernel_ast.body[0].args.args) argdict = dict(zip(argnames[1:], args)) phase2 = NewtonKernel.NewtonProcessAST(argdict).visit(self.kernel_ast) curList = [] def flattenAST(ast, lst): if isinstance(ast, list): for node in ast: flattenAST(node, lst) elif isinstance(ast, phase2.body[0].__class__): lst.append(ast) def extractFunctions(fDef): extractedList = [] removeList = [] for node in fDef.body: if isinstance(node, NewtonKernel.MathFunctionDef): extractedList.append(node) removeList.append(node) for item in removeList: fDef.body.remove(item) return extractedList lst.extend(extractFunctions(ast)) #lst[0].body = [ast_tools.Call("newtonsMethod_in_c", ["initialGuess", "epsilon", "max_iters"])] lst.append(lst[0]) lst.remove(lst[0]) return lst phase2.body= flattenAST(phase2.body, []) debug_print('Phase 2 AST:\n' + ast.dump(phase2)) phase3 = NewtonKernel.NewtonConvertAST(argdict).visit(phase2) import asp.codegen.templating.template as template mod = self.asp_module_factory() self.add_libraries(mod) index = self.processFunctions(mod) mytemplate = template.Template(filename="templates/test.c") rendered = mytemplate.render(length=2) # remember, must specify function name when using a string for ast_func in phase2.body[:-1]: mod.add_function(NewtonKernel.NewtonConvertAST(argdict).visit(ast_func)) mod.add_function(rendered, fname="newtonsMethod_in_c") #mod.add_function(NewtonKernel.NewtonConvertAST(argdict).visit(phase2.body[-1])) #newtonsMethod_in_c = open(templates/test.c") #mod.add_function(newtonsMethod_in_c, fname="newtonsMethod_in_c") #mod.add_function(phase3) #mod.add_function(NewtonKernel.NewtonConvertAST(argdict).visit(phase2.body[1])) #mod.kernel(*grid_data) #mod.func0(1) #mod.add_function(phase3, fname="func"+str(index))#rendered) initialXs = args[0] solution = args[1] npInitialXs = numpy.zeros(len(initialXs), float) for i in range(len(initialXs)): npInitialXs[i] = initialXs[i] npSolution = numpy.zeros(len(solution), float) real_args = [args[0], args[1], args[2], args[3]] mod.newtonsMethod_in_c(*real_args)