def call_many_to_one(space, shape, func, res_dtype, in_args, out): # out must hav been built. func needs no calc_type, is usually an # external ufunc nin = len(in_args) in_iters = [None] * nin in_states = [None] * nin for i in range(nin): in_i = in_args[i] assert isinstance(in_i, W_NDimArray) in_iter, in_state = in_i.create_iter(shape) in_iters[i] = in_iter in_states[i] = in_state shapelen = len(shape) assert isinstance(out, W_NDimArray) out_iter, out_state = out.create_iter(shape) vals = [None] * nin while not out_iter.done(out_state): call_many_to_one_driver.jit_merge_point(shapelen=shapelen, func=func, res_dtype=res_dtype, nin=nin) for i in range(nin): vals[i] = in_iters[i].getitem(in_states[i]) w_arglist = space.newlist(vals) w_out_val = space.call_args(func, Arguments.frompacked(space, w_arglist)) out_iter.setitem(out_state, res_dtype.coerce(space, w_out_val)) for i in range(nin): in_states[i] = in_iters[i].next(in_states[i]) out_state = out_iter.next(out_state) return out
def call_many_to_one(space, shape, func, res_dtype, in_args, out): # out must hav been built. func needs no calc_type, is usually an # external ufunc nin = len(in_args) in_iters = [None] * nin in_states = [None] * nin for i in range(nin): in_i = in_args[i] assert isinstance(in_i, W_NDimArray) in_iter, in_state = in_i.create_iter(shape) in_iters[i] = in_iter in_states[i] = in_state shapelen = len(shape) assert isinstance(out, W_NDimArray) out_iter, out_state = out.create_iter(shape) vals = [None] * nin while not out_iter.done(out_state): call_many_to_one_driver.jit_merge_point(shapelen=shapelen, func=func, res_dtype=res_dtype, nin=nin) for i in range(nin): vals[i] = in_iters[i].getitem(in_states[i]) w_arglist = space.newlist(vals) w_out_val = space.call_args(func, Arguments.frompacked(space, w_arglist)) out_iter.setitem(out_state, res_dtype.coerce(space, w_out_val)) for i in range(nin): in_states[i] = in_iters[i].next(in_states[i]) out_state = out_iter.next(out_state) return out
def checkmodule(modname, backend, interactive=False, basepath='pypy.module'): "Compile a fake PyPy module." from pypy.objspace.fake.objspace import FakeObjSpace, W_Object from pypy.translator.driver import TranslationDriver space = FakeObjSpace() space.config.translating = True ModuleClass = __import__(basepath + '.%s' % modname, None, None, ['Module']).Module module = ModuleClass(space, space.wrap(modname)) w_moduledict = module.getdict(space) gateways = find_gateways(modname, basepath, module) functions = [gw.__spacebind__(space) for gw in gateways] arguments = Arguments.frompacked(space, W_Object(), W_Object()) dummy_function = copy(functions[0]) def main(argv): # use the standalone mode not to allow SomeObject dummy_rpython(dummy_function) for func in functions: func.call_args(arguments) return 0 patch_pypy() driver = TranslationDriver() driver.setup(main, None) try: driver.proceed(['compile_' + backend]) except SystemExit: raise except: if not interactive: raise debug(driver) raise SystemExit(1)
def checkmodule(modname, backend, interactive=False, basepath='pypy.module'): "Compile a fake PyPy module." from pypy.objspace.fake.objspace import FakeObjSpace, W_Object from pypy.translator.driver import TranslationDriver space = FakeObjSpace() space.config.translating = True ModuleClass = __import__(basepath + '.%s' % modname, None, None, ['Module']).Module module = ModuleClass(space, space.wrap(modname)) w_moduledict = module.getdict() gateways = find_gateways(modname, basepath, module) functions = [gw.__spacebind__(space) for gw in gateways] arguments = Arguments.frompacked(space, W_Object(), W_Object()) dummy_function = copy(functions[0]) def main(argv): # use the standalone mode not to allow SomeObject dummy_rpython(dummy_function) for func in functions: func.call_args(arguments) return 0 patch_pypy() driver = TranslationDriver() driver.setup(main, None) try: driver.proceed(['compile_' + backend]) except SystemExit: raise except: if not interactive: raise debug(driver) raise SystemExit(1)
def test_topacked_frompacked(self): space = DummySpace() args = Arguments(space, [1], ['a', 'b'], [2, 3]) w_args, w_kwds = args.topacked() assert w_args == (1,) assert w_kwds == {'a': 2, 'b': 3} args1 = Arguments.frompacked(space, w_args, w_kwds) assert args.arguments_w == [1] assert set(args.keywords) == set(['a', 'b']) assert args.keywords_w[args.keywords.index('a')] == 2 assert args.keywords_w[args.keywords.index('b')] == 3
def test_topacked_frompacked(self): space = DummySpace() args = Arguments(space, [1], ['a', 'b'], [2, 3]) w_args, w_kwds = args.topacked() assert w_args == (1,) assert w_kwds == {'a': 2, 'b': 3} args1 = Arguments.frompacked(space, w_args, w_kwds) assert args.arguments_w == [1] assert set(args.keywords) == set(['a', 'b']) assert args.keywords_w[args.keywords.index('a')] == 2 assert args.keywords_w[args.keywords.index('b')] == 3
def call_many_to_many(space, shape, func, res_dtype, in_args, out_args): # out must hav been built. func needs no calc_type, is usually an # external ufunc nin = len(in_args) in_iters = [None] * nin in_states = [None] * nin nout = len(out_args) out_iters = [None] * nout out_states = [None] * nout for i in range(nin): in_i = in_args[i] assert isinstance(in_i, W_NDimArray) in_iter, in_state = in_i.create_iter(shape) in_iters[i] = in_iter in_states[i] = in_state for i in range(nout): out_i = out_args[i] assert isinstance(out_i, W_NDimArray) out_iter, out_state = out_i.create_iter(shape) out_iters[i] = out_iter out_states[i] = out_state shapelen = len(shape) vals = [None] * nin while not out_iters[0].done(out_states[0]): call_many_to_many_driver.jit_merge_point(shapelen=shapelen, func=func, res_dtype=res_dtype, nin=nin, nout=nout) for i in range(nin): vals[i] = in_iters[i].getitem(in_states[i]) w_arglist = space.newlist(vals) w_outvals = space.call_args(func, Arguments.frompacked(space, w_arglist)) # w_outvals should be a tuple, but func can return a single value as well if space.isinstance_w(w_outvals, space.w_tuple): batch = space.listview(w_outvals) for i in range(len(batch)): out_iters[i].setitem(out_states[i], res_dtype.coerce(space, batch[i])) out_states[i] = out_iters[i].next(out_states[i]) else: out_iters[0].setitem(out_states[0], res_dtype.coerce(space, w_outvals)) out_states[0] = out_iters[0].next(out_states[0]) for i in range(nin): in_states[i] = in_iters[i].next(in_states[i]) return space.newtuple([convert_to_array(space, o) for o in out_args])
def test_topacked_frompacked(self): space = DummySpace() args = Arguments(space, [1], ["a", "b"], [2, 3]) w_args, w_kwds = args.topacked() assert w_args == (1,) assert w_kwds == {"a": 2, "b": 3} args1 = Arguments.frompacked(space, w_args, w_kwds) assert args.arguments_w == [1] assert set(args.keywords) == set(["a", "b"]) assert args.keywords_w[args.keywords.index("a")] == 2 assert args.keywords_w[args.keywords.index("b")] == 3 args = Arguments(space, [1]) w_args, w_kwds = args.topacked() assert w_args == (1,) assert not w_kwds
def call_many_to_many(space, shape, func, in_dtypes, out_dtypes, in_args, out_args): # out must hav been built. func needs no calc_type, is usually an # external ufunc nin = len(in_args) in_iters = [None] * nin in_states = [None] * nin nout = len(out_args) out_iters = [None] * nout out_states = [None] * nout for i in range(nin): in_i = in_args[i] assert isinstance(in_i, W_NDimArray) in_iter, in_state = in_i.create_iter(shape) in_iters[i] = in_iter in_states[i] = in_state for i in range(nout): out_i = out_args[i] assert isinstance(out_i, W_NDimArray) out_iter, out_state = out_i.create_iter(shape) out_iters[i] = out_iter out_states[i] = out_state shapelen = len(shape) vals = [None] * nin test_iter, test_state = in_iters[-1], in_states[-1] if nout > 0: test_iter, test_state = out_iters[0], out_states[0] while not test_iter.done(test_state): call_many_to_many_driver.jit_merge_point(shapelen=shapelen, func=func, in_dtypes=in_dtypes, out_dtypes=out_dtypes, nin=nin, nout=nout) for i in range(nin): vals[i] = in_dtypes[i].coerce(space, in_iters[i].getitem(in_states[i])) w_arglist = space.newlist(vals) w_outvals = space.call_args(func, Arguments.frompacked(space, w_arglist)) # w_outvals should be a tuple, but func can return a single value as well if space.isinstance_w(w_outvals, space.w_tuple): batch = space.listview(w_outvals) for i in range(len(batch)): out_iters[i].setitem(out_states[i], out_dtypes[i].coerce(space, batch[i])) out_states[i] = out_iters[i].next(out_states[i]) elif nout > 0: out_iters[0].setitem(out_states[0], out_dtypes[0].coerce(space, w_outvals)) out_states[0] = out_iters[0].next(out_states[0]) for i in range(nin): in_states[i] = in_iters[i].next(in_states[i]) test_state = test_iter.next(test_state) return space.newtuple([convert_to_array(space, o) for o in out_args])
def descr__setstate__(self, space, w_args): w_flags, w_state, w_thunk, w_parent = space.unpackiterable(w_args, expected_length=4) self.flags = space.int_w(w_flags) if space.is_w(w_parent, space.w_None): w_parent = self.w_getmain(space) self.parent = space.interp_w(AppCoroutine, w_parent) ec = self.space.getexecutioncontext() self.subctx.setstate(space, w_state) if space.is_w(w_thunk, space.w_None): if space.is_w(w_state, space.w_None): self.thunk = None else: self.bind(_ResumeThunk(space, self.costate, self.subctx.topframe)) else: w_func, w_args, w_kwds = space.unpackiterable(w_thunk, expected_length=3) args = Arguments.frompacked(space, w_args, w_kwds) self.bind(_AppThunk(space, self.costate, w_func, args))
def call(self, w_callable, w_args, w_kwds=None): args = Arguments.frompacked(self, w_args, w_kwds) return self.call_args(w_callable, args)
def slot_tp_init(space, w_self, w_args, w_kwds): w_descr = space.lookup(w_self, '__init__') args = Arguments.frompacked(space, w_args, w_kwds) space.get_and_call_args(w_descr, w_self, args) return 0
def slot_tp_init(space, w_self, w_args, w_kwds): w_descr = space.lookup(w_self, '__init__') args = Arguments.frompacked(space, w_args, w_kwds) space.get_and_call_args(w_descr, w_self, args) return 0
class AppCoroutine(Coroutine): # XXX, StacklessFlags): def __init__(self, space, state=None): self.space = space if state is None: state = AppCoroutine._get_state(space) Coroutine.__init__(self, state) self.flags = 0 self.newsubctx() def newsubctx(self): ec = self.space.getexecutioncontext() self.subctx = ec.Subcontext() def descr_method__new__(space, w_subtype): co = space.allocate_instance(AppCoroutine, w_subtype) AppCoroutine.__init__(co, space) return space.wrap(co) def _get_state(space): return space.fromcache(AppCoState) _get_state = staticmethod(_get_state) def w_bind(self, w_func, __args__): space = self.space if self.frame is not None: raise OperationError(space.w_ValueError, space.wrap("cannot bind a bound Coroutine")) state = self.costate thunk = _AppThunk(space, state, w_func, __args__) self.bind(thunk) def w_switch(self): space = self.space if self.frame is None: raise OperationError( space.w_ValueError, space.wrap("cannot switch to an unbound Coroutine")) state = self.costate self.switch() rstack.resume_point("w_switch", state, space) w_ret, state.w_tempval = state.w_tempval, space.w_None return w_ret def w_finished(self, w_excinfo): pass def finish(self, operror=None): space = self.space if isinstance(operror, OperationError): w_exctype = operror.w_type w_excvalue = operror.get_w_value(space) w_exctraceback = operror.application_traceback w_excinfo = space.newtuple([w_exctype, w_excvalue, w_exctraceback]) else: w_N = space.w_None w_excinfo = space.newtuple([w_N, w_N, w_N]) return space.call_method(space.wrap(self), 'finished', w_excinfo) def hello(self): ec = self.space.getexecutioncontext() self.subctx.enter(ec) def goodbye(self): ec = self.space.getexecutioncontext() self.subctx.leave(ec) def w_kill(self): self.kill() def _userdel(self): if self.get_is_zombie(): return self.set_is_zombie(True) self.space.userdel(self.space.wrap(self)) def w_getcurrent(space): return space.wrap(AppCoroutine._get_state(space).current) w_getcurrent = staticmethod(w_getcurrent) def w_getmain(space): return space.wrap(AppCoroutine._get_state(space).main) w_getmain = staticmethod(w_getmain) # pickling interface def descr__reduce__(self, space): # this is trying to be simplistic at the moment. # we neither allow to pickle main (which can become a mess # since it has some deep anchestor frames) # nor we allow to pickle the current coroutine. # rule: switch before pickling. # you cannot construct the tree that you are climbing. from pypy.interpreter.mixedmodule import MixedModule w_mod = space.getbuiltinmodule('_stackless') mod = space.interp_w(MixedModule, w_mod) w_mod2 = space.getbuiltinmodule('_pickle_support') mod2 = space.interp_w(MixedModule, w_mod2) w_new_inst = mod.get('coroutine') w = space.wrap nt = space.newtuple ec = self.space.getexecutioncontext() if self is self.costate.main: return nt([mod.get('_return_main'), nt([])]) thunk = self.thunk if isinstance(thunk, _AppThunk): w_args, w_kwds = thunk.args.topacked() w_thunk = nt([thunk.w_func, w_args, w_kwds]) else: w_thunk = space.w_None tup_base = [] tup_state = [ w(self.flags), self.subctx.getstate(space), w_thunk, w(self.parent), ] return nt([w_new_inst, nt(tup_base), nt(tup_state)]) def descr__setstate__(self, space, w_args): try: w_flags, w_state, w_thunk, w_parent = space.unpackiterable( w_args, expected_length=4) except UnpackValueError, e: raise OperationError(space.w_ValueError, space.wrap(e.msg)) self.flags = space.int_w(w_flags) if space.is_w(w_parent, space.w_None): w_parent = self.w_getmain(space) self.parent = space.interp_w(AppCoroutine, w_parent) ec = self.space.getexecutioncontext() self.subctx.setstate(space, w_state) self.reconstruct_framechain() if space.is_w(w_thunk, space.w_None): self.thunk = None else: try: w_func, w_args, w_kwds = space.unpackiterable( w_thunk, expected_length=3) except UnpackValueError, e: raise OperationError(space.w_ValueError, space.wrap(e.msg)) args = Arguments.frompacked(space, w_args, w_kwds) self.bind(_AppThunk(space, self.costate, w_func, args))
def call(self, w_callable, w_args, w_kwds=None): args = Arguments.frompacked(self, w_args, w_kwds) return self.call_args(w_callable, args)