def _handle_jit_decorator(self, func_def, decorator): from numba import ast_type_inference jit_args = ast_type_inference._parse_args( decorator, ['restype', 'argtypes', 'backend', 'target', 'nopython']) if decorator.args or decorator.keywords: restype = self._parse_restype(decorator, jit_args) if restype is not None and restype.is_function: signature = restype else: argtypes = self._parse_argtypes(decorator, func_def, jit_args) signature = minitypes.FunctionType(restype, argtypes, name=func_def.name) else: #elif func_def.args: raise error.NumbaError( decorator, "The argument types and return type " "need to be specified") #else: # signature = minitypes.FunctionType(None, []) # TODO: Analyse closure at call or outer function return time to # TODO: infer return type # TODO: parse out nopython argument return signature
def infer(func, arg_types): sig = minitypes.FunctionType(return_type=None, args=arg_types) ast = functions._get_ast(func) sig, symtab, ast = ast_type_inference._infer_types(decorators.context, func, ast, sig) return sig, symtab
def run_pipeline(self, func): func_sig = minitypes.FunctionType(minitypes.void, []) source = inspect.getsource(func) astree = ast.parse(source) pipeline = decorators.context.numba_pipeline(decorators.context, func, astree, func_sig) return pipeline.const_folding(astree)
def test_math_funcs(): functions = get_functions() exceptions = 0 for func_name in functions: # func_name = 'sqrt' func = functions[func_name] for dest_type in dest_types: signature = minitypes.FunctionType(None, [dest_type, dest_type]) print(("executing...", func_name, signature)) try: numba_func = jit(signature)(func) except error.NumbaError as e: exceptions += 1 print((func_name, dest_type, e)) continue x, y = 5.2, 6.9 if dest_type.is_int: x, y = 5, 6 r1 = numba_func(x, y) r2 = func(x, y) assert np.allclose(r1, r2), (r1, r2, signature, func_name) if exceptions: raise Exception
def __init__(self, signature, func, args, keywords=None, py_func=None, **kw): if py_func and not kw.get('name', None): kw['name'] = py_func.__name__ if signature is None: signature = minitypes.FunctionType(return_type=object_, args=[object_] * len(args)) if keywords: signature.args.extend([object_] * len(keywords)) super(ObjectCallNode, self).__init__(signature, args) assert func is not None self.function = func self.py_func = py_func self.args_tuple = ast.Tuple(elts=args, ctx=ast.Load()) self.args_tuple.variable = Variable( numba_types.TupleType(size=len(args))) if keywords: keywords = [(ConstNode(k.arg), k.value) for k in keywords] keys, values = zip(*keywords) self.kwargs_dict = ast.Dict(list(keys), list(values)) self.kwargs_dict.variable = Variable(minitypes.object_) else: self.kwargs_dict = NULL_obj self.type = signature.return_type
def test(): for argtype in [object_, float_, double]: # f_ = autojit(f) f_ = jit(minitypes.FunctionType(None, [argtype]))(f) for v in range(-10, 10): assert f_(v) == f(v) assert f_(float(v)) == f(float(v))
def compile2(env, func, restype=None, argtypes=None, ctypes=False, compile_only=False, **kwds): """ Compile a numba annotated function. - decompile function into a Python ast - run type inference using the given input types - compile the function to LLVM """ # Let the pipeline create a module for the function it is compiling # and the user will link that in. assert 'llvm_module' not in kwds kwds['llvm_module'] = lc.Module.new(module_name(func)) logger.debug(kwds) func_ast = functions._get_ast(func) func_signature = minitypes.FunctionType(return_type=restype, args=argtypes) #pipeline, (func_signature, symtab, ast) = _infer_types2( # env, func, restype, argtypes, codegen=True, **kwds) with env.TranslationContext(env, func, func_ast, func_signature, need_lfunc_wrapper=not compile_only, **kwds) as func_env: pipeline = env.get_pipeline(kwds.get('pipeline_name', None)) func_ast.pipeline = pipeline post_ast = pipeline(func_ast, env) func_signature = func_env.func_signature symtab = func_env.symtab t = func_env.translator return func_env
def _process_signature(ext_type, method, default_signature, is_static=False, is_class=False): if isinstance(method, minitypes.Function): # @double(...) # def func(self, ...): ... return _process_signature(ext_type, method.py_func, method.signature, is_static, is_class) elif isinstance(method, types.FunctionType): if default_signature is None: # TODO: construct dependency graph, toposort, type infer # TODO: delayed types raise error.NumbaError( "Method '%s' does not have signature" % (method.__name__,)) validate_method(method, default_signature or object_(), is_static) if default_signature is None: default_signature = minitypes.FunctionType(return_type=None, args=[]) sig = get_signature(ext_type, is_class, is_static, default_signature) return Method(method, is_class, is_static), sig.return_type, sig.args else: if isinstance(method, staticmethod): is_static = True elif isinstance(method, classmethod): is_class = True else: return None, None, None method, restype, argtypes = _process_signature( ext_type, method.__func__, default_signature, is_static=is_static, is_class=is_class) return method, restype, argtypes
def run_pipeline(self, func): func_sig = minitypes.FunctionType(minitypes.void, []) source = inspect.getsource(func) astree = ast.parse(source) with environment.TranslationContext(self.env, func, astree, func_sig): pipeline_callable = self.env.get_or_add_pipeline( 'const_folding', pipeline.ConstFolding) astree = pipeline.AST3to2()(astree, self.env) ret_val = pipeline_callable(astree, self.env) return ret_val
def get_signature(ext_type, is_class, is_static, sig): if is_static: leading_arg_types = () elif is_class: leading_arg_types = (object_,) else: leading_arg_types = (ext_type,) argtypes = leading_arg_types + sig.args restype = sig.return_type return minitypes.FunctionType(return_type=restype, args=argtypes)
def __init__(self, object, attr, **kwargs): super(ExtensionMethod, self).__init__(**kwargs) ext_type = object.variable.type assert ext_type.is_extension self.value = object self.attr = attr method_type, self.vtab_index = ext_type.methoddict[attr] self.type = minitypes.FunctionType(return_type=method_type.return_type, args=method_type.args, is_bound_method=True)
def resolve_templates(ast, env): # TODO: Unify with decorators module crnt = env.translation.crnt if crnt.template_signature is not None: from numba import typesystem argnames = [name.id for name in ast.args.args] argtypes = list(crnt.func_signature.args) typesystem.resolve_templates(crnt.locals, crnt.template_signature, argnames, argtypes) crnt.func_signature = minitypes.FunctionType( return_type=crnt.func_signature.return_type, args=tuple(argtypes)) return ast
def map_type(cffi_type): "Map CFFI type to numba type" if cffi_type.kind in ('struct', 'union'): if cffi_type.kind == 'union': result = None else: result = struct([(name, map_type(field_type)) for name, field_type in cffi_type.fields]) elif cffi_type.kind == 'function': restype = map_type(cffi_type.result) argtypes = [map_type(arg) for arg in cffi_type.args] result = minitypes.FunctionType( restype, argtypes, is_vararg=cffi_type.ellipsis).pointer() else: result = type_map.get(cffi_type) if result is None: raise minierror.UnmappableTypeError(cffi_type) return result
def from_ctypes_value(value): """ Convert a ctypes value to a numba type """ from numba import typesystem if is_ctypes_type(value): # Value is a ctypes type, e.g. c_int return typesystem.CastType(from_ctypes_type(value)) elif is_ctypes_function(value): # TODO: move this to from_ctypes_type if value.argtypes is None: warnings.warn("ctypes function %s has no argument types set" % (value, )) return object_ restype = from_ctypes_type(value.restype) argtypes = [from_ctypes_type(at) for at in value.argtypes] signature = minitypes.FunctionType(return_type=restype, args=argtypes) return signature elif is_ctypes_type(type(value)) or hasattr(value, '_type_'): # Value is a ctypes value, e.g. c_int(10) result_type = from_ctypes_type(type(value)) if result_type.is_pointer: # Handle ctypes pointers try: ctypes.cast(value, ctypes.c_void_p) except ctypes.ArgumentError: pass else: addr_int = ctypes.cast(value, ctypes.c_void_p).value result_type = typesystem.KnownPointerType( result_type.base_type, addr_int) return result_type else: raise NotImplementedError(value)
def function(return_type, argtypes): return minitypes.FunctionType(return_type, argtypes)
def sep201_signature_string(functype, name): functype = minitypes.FunctionType(functype.return_type, functype.args, name) return str(functype)
def signature(self): return minitypes.FunctionType(return_type=self.return_type, args=self.arg_types, is_vararg=self.is_vararg)
def __init__(self, ctypes_func, restype, argtypes, **kwds): super(CTypesFunctionType, self).__init__(**kwds) self.ctypes_func = ctypes_func self.signature = minitypes.FunctionType(return_type=restype, args=argtypes)
def _infer_types(context, func, restype=None, argtypes=None, **kwargs): ast = functions._get_ast(func) func_signature = minitypes.FunctionType(return_type=restype, args=argtypes) return run_pipeline(context, func, ast, func_signature, **kwargs)