Mailman 3 September 2011 - pypy-dev

Realtime communication and webserver to use with pypy?
by John Anderson 30 Sep '11

30 Sep '11

In cpython I deploy using gevent or gunicorn for high performance/low memory usage with the ability to be non-blocking for realtime communication using socket.io. If I want to move to using PyPy... what are my options for this type of setup? Is there a non-blocking webserver in python that works well with PyPy?

4 4

Re: [pypy-dev] [pypy-commit] pypy default: Merge a branch that makes space.isinstance(w_obj, <a constant>) do a fastpath
by Carl Friedrich Bolz 29 Sep '11

29 Sep '11

Hi Maciek, The objspace part of this merge really needs tests! You should write tests that the .interplevel_cls attribute is set, and that calling isinstance_w actually goes through the fast path. Cheers, Carl Friedrich On 09/29/2011 04:40 AM, fijal wrote: > Author: Maciej Fijalkowski<fijall(a)gmail.com> > Branch: > Changeset: r47667:ffbf1bcf89d6 > Date: 2011-09-28 23:39 -0300 > http://bitbucket.org/pypy/pypy/changeset/ffbf1bcf89d6/ > > Log: Merge a branch that makes space.isinstance(w_obj,<a constant>) do a > fastpath with isinstance(w_obj,<an RPython class representing the > constant>) > > diff --git a/pypy/annotation/policy.py b/pypy/annotation/policy.py > --- a/pypy/annotation/policy.py > +++ b/pypy/annotation/policy.py > @@ -1,6 +1,6 @@ > # base annotation policy for specialization > from pypy.annotation.specialize import default_specialize as default > -from pypy.annotation.specialize import specialize_argvalue, specialize_argtype, specialize_arglistitemtype > +from pypy.annotation.specialize import specialize_argvalue, specialize_argtype, specialize_arglistitemtype, specialize_arg_or_var > from pypy.annotation.specialize import memo, specialize_call_location > # for some reason, model must be imported first, > # or we create a cycle. > @@ -73,6 +73,7 @@ > default_specialize = staticmethod(default) > specialize__memo = staticmethod(memo) > specialize__arg = staticmethod(specialize_argvalue) # specialize:arg(N) > + specialize__arg_or_var = staticmethod(specialize_arg_or_var) > specialize__argtype = staticmethod(specialize_argtype) # specialize:argtype(N) > specialize__arglistitemtype = staticmethod(specialize_arglistitemtype) > specialize__call_location = staticmethod(specialize_call_location) > diff --git a/pypy/annotation/specialize.py b/pypy/annotation/specialize.py > --- a/pypy/annotation/specialize.py > +++ b/pypy/annotation/specialize.py > @@ -353,6 +353,16 @@ > key = tuple(key) > return maybe_star_args(funcdesc, key, args_s) > > +def specialize_arg_or_var(funcdesc, args_s, *argindices): > + for argno in argindices: > + if not args_s[argno].is_constant(): > + break > + else: > + # all constant > + return specialize_argvalue(funcdesc, args_s, *argindices) > + # some not constant > + return maybe_star_args(funcdesc, None, args_s) > + > def specialize_argtype(funcdesc, args_s, *argindices): > key = tuple([args_s[i].knowntype for i in argindices]) > for cls in key: > diff --git a/pypy/annotation/test/test_annrpython.py b/pypy/annotation/test/test_annrpython.py > --- a/pypy/annotation/test/test_annrpython.py > +++ b/pypy/annotation/test/test_annrpython.py > @@ -1194,6 +1194,20 @@ > assert len(executedesc._cache[(0, 'star', 2)].startblock.inputargs) == 4 > assert len(executedesc._cache[(1, 'star', 3)].startblock.inputargs) == 5 > > + def test_specialize_arg_or_var(self): > + def f(a): > + return 1 > + f._annspecialcase_ = 'specialize:arg_or_var(0)' > + > + def fn(a): > + return f(3) + f(a) > + > + a = self.RPythonAnnotator() > + a.build_types(fn, [int]) > + executedesc = a.bookkeeper.getdesc(f) > + assert sorted(executedesc._cache.keys()) == [None, (3,)] > + # we got two different special > + > def test_specialize_call_location(self): > def g(a): > return a > diff --git a/pypy/objspace/descroperation.py b/pypy/objspace/descroperation.py > --- a/pypy/objspace/descroperation.py > +++ b/pypy/objspace/descroperation.py > @@ -6,6 +6,7 @@ > from pypy.interpreter.typedef import default_identity_hash > from pypy.tool.sourcetools import compile2, func_with_new_name > from pypy.module.__builtin__.interp_classobj import W_InstanceObject > +from pypy.rlib.objectmodel import specialize > > def object_getattribute(space): > "Utility that returns the app-level descriptor object.__getattribute__." > @@ -507,6 +508,7 @@ > def issubtype(space, w_sub, w_type): > return space._type_issubtype(w_sub, w_type) > > + @specialize.arg_or_var(2) > def isinstance(space, w_inst, w_type): > return space.wrap(space._type_isinstance(w_inst, w_type)) > > diff --git a/pypy/objspace/std/objspace.py b/pypy/objspace/std/objspace.py > --- a/pypy/objspace/std/objspace.py > +++ b/pypy/objspace/std/objspace.py > @@ -7,7 +7,7 @@ > from pypy.objspace.std import (builtinshortcut, stdtypedef, frame, model, > transparent, callmethod, proxyobject) > from pypy.objspace.descroperation import DescrOperation, raiseattrerror > -from pypy.rlib.objectmodel import instantiate, r_dict, specialize > +from pypy.rlib.objectmodel import instantiate, r_dict, specialize, is_constant > from pypy.rlib.debug import make_sure_not_resized > from pypy.rlib.rarithmetic import base_int, widen > from pypy.rlib.objectmodel import we_are_translated > @@ -83,6 +83,12 @@ > if self.config.objspace.std.withtproxy: > transparent.setup(self) > > + for type, classes in self.model.typeorder.iteritems(): > + if len(classes) == 3: > + # W_Root, AnyXxx and actual object > + self.gettypefor(type).interplevel_cls = classes[0][0] > + > + > def get_builtin_types(self): > return self.builtin_types > > @@ -567,10 +573,19 @@ > return self.wrap(w_sub.issubtype(w_type)) > raise OperationError(self.w_TypeError, self.wrap("need type objects")) > > + @specialize.arg_or_var(2) > def _type_isinstance(self, w_inst, w_type): > - if isinstance(w_type, W_TypeObject): > - return self.type(w_inst).issubtype(w_type) > - raise OperationError(self.w_TypeError, self.wrap("need type object")) > + if not isinstance(w_type, W_TypeObject): > + raise OperationError(self.w_TypeError, > + self.wrap("need type object")) > + if is_constant(w_type): > + cls = w_type.interplevel_cls > + if cls is not None: > + assert w_inst is not None > + if isinstance(w_inst, cls): > + return True > + return self.type(w_inst).issubtype(w_type) > > + @specialize.arg_or_var(2) > def isinstance_w(space, w_inst, w_type): > return space._type_isinstance(w_inst, w_type) > diff --git a/pypy/objspace/std/typeobject.py b/pypy/objspace/std/typeobject.py > --- a/pypy/objspace/std/typeobject.py > +++ b/pypy/objspace/std/typeobject.py > @@ -115,6 +115,9 @@ > # of the __new__ is an instance of the type > w_bltin_new = None > > + interplevel_cls = None # not None for prebuilt instances of > + # interpreter-level types > + > @dont_look_inside > def __init__(w_self, space, name, bases_w, dict_w, > overridetypedef=None): > diff --git a/pypy/rlib/objectmodel.py b/pypy/rlib/objectmodel.py > --- a/pypy/rlib/objectmodel.py > +++ b/pypy/rlib/objectmodel.py > @@ -46,6 +46,17 @@ > > return decorated_func > > + def arg_or_var(self, *args): > + """ Same as arg, but additionally allow for a 'variable' annotation, > + that would simply be a situation where designated arg is not > + a constant > + """ > + def decorated_func(func): > + func._annspecialcase_ = 'specialize:arg_or_var' + self._wrap(args) > + return func > + > + return decorated_func > + > def argtype(self, *args): > """ Specialize function based on types of arguments on given positions. > > @@ -165,6 +176,22 @@ > def keepalive_until_here(*values): > pass > > +def is_constant(thing): > + return True > + > +class Entry(ExtRegistryEntry): > + _about_ = is_constant > + > + def compute_result_annotation(self, s_arg): > + from pypy.annotation import model > + r = model.SomeBool() > + r.const = s_arg.is_constant() > + return r > + > + def specialize_call(self, hop): > + from pypy.rpython.lltypesystem import lltype > + return hop.inputconst(lltype.Bool, hop.s_result.const) > + > # ____________________________________________________________ > > class FREED_OBJECT(object): > diff --git a/pypy/rlib/test/test_objectmodel.py b/pypy/rlib/test/test_objectmodel.py > --- a/pypy/rlib/test/test_objectmodel.py > +++ b/pypy/rlib/test/test_objectmodel.py > @@ -339,6 +339,19 @@ > res = self.interpret(f, [42]) > assert res == 84 > > + def test_isconstant(self): > + from pypy.rlib.objectmodel import is_constant, specialize > + > + @specialize.arg_or_var(0) > + def f(arg): > + if is_constant(arg): > + return 1 > + return 10 > + > + def fn(arg): > + return f(arg) + f(3) > + > + assert self.interpret(fn, [15]) == 11 > > class TestLLtype(BaseTestObjectModel, LLRtypeMixin): > > @@ -451,5 +464,4 @@ > if llop.opname == 'malloc_varsize': > break > assert llop.args[2] is graph.startblock.inputargs[0] > - > > _______________________________________________ > pypy-commit mailing list > pypy-commit(a)python.org > http://mail.python.org/mailman/listinfo/pypy-commit

3 2

Re: [pypy-dev] [pypy-commit] pypy default: Merge a branch that makes space.isinstance(w_obj, <a constant>) do a fastpath
by Carl Friedrich Bolz 29 Sep '11

29 Sep '11

Hi Maciek, The objspace part of this test really needs tests! You should write tests that the .interplevel_cls attribute is set, and that calling isinstance_w actually goes through the fast path. Cheers, Carl Friedrich On 09/29/2011 04:40 AM, fijal wrote: > Author: Maciej Fijalkowski<fijall(a)gmail.com> > Branch: > Changeset: r47667:ffbf1bcf89d6 > Date: 2011-09-28 23:39 -0300 > http://bitbucket.org/pypy/pypy/changeset/ffbf1bcf89d6/ > > Log: Merge a branch that makes space.isinstance(w_obj,<a constant>) do a > fastpath with isinstance(w_obj,<an RPython class representing the > constant>) > > diff --git a/pypy/annotation/policy.py b/pypy/annotation/policy.py > --- a/pypy/annotation/policy.py > +++ b/pypy/annotation/policy.py > @@ -1,6 +1,6 @@ > # base annotation policy for specialization > from pypy.annotation.specialize import default_specialize as default > -from pypy.annotation.specialize import specialize_argvalue, specialize_argtype, specialize_arglistitemtype > +from pypy.annotation.specialize import specialize_argvalue, specialize_argtype, specialize_arglistitemtype, specialize_arg_or_var > from pypy.annotation.specialize import memo, specialize_call_location > # for some reason, model must be imported first, > # or we create a cycle. > @@ -73,6 +73,7 @@ > default_specialize = staticmethod(default) > specialize__memo = staticmethod(memo) > specialize__arg = staticmethod(specialize_argvalue) # specialize:arg(N) > + specialize__arg_or_var = staticmethod(specialize_arg_or_var) > specialize__argtype = staticmethod(specialize_argtype) # specialize:argtype(N) > specialize__arglistitemtype = staticmethod(specialize_arglistitemtype) > specialize__call_location = staticmethod(specialize_call_location) > diff --git a/pypy/annotation/specialize.py b/pypy/annotation/specialize.py > --- a/pypy/annotation/specialize.py > +++ b/pypy/annotation/specialize.py > @@ -353,6 +353,16 @@ > key = tuple(key) > return maybe_star_args(funcdesc, key, args_s) > > +def specialize_arg_or_var(funcdesc, args_s, *argindices): > + for argno in argindices: > + if not args_s[argno].is_constant(): > + break > + else: > + # all constant > + return specialize_argvalue(funcdesc, args_s, *argindices) > + # some not constant > + return maybe_star_args(funcdesc, None, args_s) > + > def specialize_argtype(funcdesc, args_s, *argindices): > key = tuple([args_s[i].knowntype for i in argindices]) > for cls in key: > diff --git a/pypy/annotation/test/test_annrpython.py b/pypy/annotation/test/test_annrpython.py > --- a/pypy/annotation/test/test_annrpython.py > +++ b/pypy/annotation/test/test_annrpython.py > @@ -1194,6 +1194,20 @@ > assert len(executedesc._cache[(0, 'star', 2)].startblock.inputargs) == 4 > assert len(executedesc._cache[(1, 'star', 3)].startblock.inputargs) == 5 > > + def test_specialize_arg_or_var(self): > + def f(a): > + return 1 > + f._annspecialcase_ = 'specialize:arg_or_var(0)' > + > + def fn(a): > + return f(3) + f(a) > + > + a = self.RPythonAnnotator() > + a.build_types(fn, [int]) > + executedesc = a.bookkeeper.getdesc(f) > + assert sorted(executedesc._cache.keys()) == [None, (3,)] > + # we got two different special > + > def test_specialize_call_location(self): > def g(a): > return a > diff --git a/pypy/objspace/descroperation.py b/pypy/objspace/descroperation.py > --- a/pypy/objspace/descroperation.py > +++ b/pypy/objspace/descroperation.py > @@ -6,6 +6,7 @@ > from pypy.interpreter.typedef import default_identity_hash > from pypy.tool.sourcetools import compile2, func_with_new_name > from pypy.module.__builtin__.interp_classobj import W_InstanceObject > +from pypy.rlib.objectmodel import specialize > > def object_getattribute(space): > "Utility that returns the app-level descriptor object.__getattribute__." > @@ -507,6 +508,7 @@ > def issubtype(space, w_sub, w_type): > return space._type_issubtype(w_sub, w_type) > > + @specialize.arg_or_var(2) > def isinstance(space, w_inst, w_type): > return space.wrap(space._type_isinstance(w_inst, w_type)) > > diff --git a/pypy/objspace/std/objspace.py b/pypy/objspace/std/objspace.py > --- a/pypy/objspace/std/objspace.py > +++ b/pypy/objspace/std/objspace.py > @@ -7,7 +7,7 @@ > from pypy.objspace.std import (builtinshortcut, stdtypedef, frame, model, > transparent, callmethod, proxyobject) > from pypy.objspace.descroperation import DescrOperation, raiseattrerror > -from pypy.rlib.objectmodel import instantiate, r_dict, specialize > +from pypy.rlib.objectmodel import instantiate, r_dict, specialize, is_constant > from pypy.rlib.debug import make_sure_not_resized > from pypy.rlib.rarithmetic import base_int, widen > from pypy.rlib.objectmodel import we_are_translated > @@ -83,6 +83,12 @@ > if self.config.objspace.std.withtproxy: > transparent.setup(self) > > + for type, classes in self.model.typeorder.iteritems(): > + if len(classes) == 3: > + # W_Root, AnyXxx and actual object > + self.gettypefor(type).interplevel_cls = classes[0][0] > + > + > def get_builtin_types(self): > return self.builtin_types > > @@ -567,10 +573,19 @@ > return self.wrap(w_sub.issubtype(w_type)) > raise OperationError(self.w_TypeError, self.wrap("need type objects")) > > + @specialize.arg_or_var(2) > def _type_isinstance(self, w_inst, w_type): > - if isinstance(w_type, W_TypeObject): > - return self.type(w_inst).issubtype(w_type) > - raise OperationError(self.w_TypeError, self.wrap("need type object")) > + if not isinstance(w_type, W_TypeObject): > + raise OperationError(self.w_TypeError, > + self.wrap("need type object")) > + if is_constant(w_type): > + cls = w_type.interplevel_cls > + if cls is not None: > + assert w_inst is not None > + if isinstance(w_inst, cls): > + return True > + return self.type(w_inst).issubtype(w_type) > > + @specialize.arg_or_var(2) > def isinstance_w(space, w_inst, w_type): > return space._type_isinstance(w_inst, w_type) > diff --git a/pypy/objspace/std/typeobject.py b/pypy/objspace/std/typeobject.py > --- a/pypy/objspace/std/typeobject.py > +++ b/pypy/objspace/std/typeobject.py > @@ -115,6 +115,9 @@ > # of the __new__ is an instance of the type > w_bltin_new = None > > + interplevel_cls = None # not None for prebuilt instances of > + # interpreter-level types > + > @dont_look_inside > def __init__(w_self, space, name, bases_w, dict_w, > overridetypedef=None): > diff --git a/pypy/rlib/objectmodel.py b/pypy/rlib/objectmodel.py > --- a/pypy/rlib/objectmodel.py > +++ b/pypy/rlib/objectmodel.py > @@ -46,6 +46,17 @@ > > return decorated_func > > + def arg_or_var(self, *args): > + """ Same as arg, but additionally allow for a 'variable' annotation, > + that would simply be a situation where designated arg is not > + a constant > + """ > + def decorated_func(func): > + func._annspecialcase_ = 'specialize:arg_or_var' + self._wrap(args) > + return func > + > + return decorated_func > + > def argtype(self, *args): > """ Specialize function based on types of arguments on given positions. > > @@ -165,6 +176,22 @@ > def keepalive_until_here(*values): > pass > > +def is_constant(thing): > + return True > + > +class Entry(ExtRegistryEntry): > + _about_ = is_constant > + > + def compute_result_annotation(self, s_arg): > + from pypy.annotation import model > + r = model.SomeBool() > + r.const = s_arg.is_constant() > + return r > + > + def specialize_call(self, hop): > + from pypy.rpython.lltypesystem import lltype > + return hop.inputconst(lltype.Bool, hop.s_result.const) > + > # ____________________________________________________________ > > class FREED_OBJECT(object): > diff --git a/pypy/rlib/test/test_objectmodel.py b/pypy/rlib/test/test_objectmodel.py > --- a/pypy/rlib/test/test_objectmodel.py > +++ b/pypy/rlib/test/test_objectmodel.py > @@ -339,6 +339,19 @@ > res = self.interpret(f, [42]) > assert res == 84 > > + def test_isconstant(self): > + from pypy.rlib.objectmodel import is_constant, specialize > + > + @specialize.arg_or_var(0) > + def f(arg): > + if is_constant(arg): > + return 1 > + return 10 > + > + def fn(arg): > + return f(arg) + f(3) > + > + assert self.interpret(fn, [15]) == 11 > > class TestLLtype(BaseTestObjectModel, LLRtypeMixin): > > @@ -451,5 +464,4 @@ > if llop.opname == 'malloc_varsize': > break > assert llop.args[2] is graph.startblock.inputargs[0] > - > > _______________________________________________ > pypy-commit mailing list > pypy-commit(a)python.org > http://mail.python.org/mailman/listinfo/pypy-commit

1 0

thoughts on built-in support for coroutine suspension on lowlevel io
by Ronny Pfannschmidt 28 Sep '11

28 Sep '11

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 Hi, I’d like to collect thoughts on having built-in primitives for co-routine suspension it would greatly simplify the work for tool-kits like eventlet/gevent, since no longer they would need to monkey-patch all parts of the std-lib instead they could use a simple built-in primitive to integrate the std-lib with co-routine based async io - -- Ronny -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.11 (GNU/Linux) Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/ iQIcBAEBAgAGBQJOgj/SAAoJEE8uAqxPKbjkDoIP/1Wy6X0g194fHpqK18PClw/K iD0fcMe3by758TEzqLe3moUwGJilkXqjSNntVZAmBp8QNGdiSWfuq5bxx/pqJlpQ X87kTEOpd5JyNIpQY9/adUGZFzjaqinbUinhmZB8Vm6Kfb7JV95TR0TheborrrDW GEttnPc/CcSv97/AqsvzIJWUDzPvlZ5F66zgKumijBlFv6ja/aRCbsRMozVlEeFx Mshxazuu9F4y6JYZee/UzESzHyByFd3sClWt8CwUgHftZwrdgoyVGM2zvlMVzzdr u7ct44p2PqDw1S634LAgJrghBEUiK3nLiQs8l/3zazti8FKesN8yXGm5Ivaf1lgj DrnTKmMGIvePwTXXLjmwWBWIdY8v2B3Mgztne8iISSjhtY0L5xzji63CGJotr/uK hLa1avbZMhuPZcr/qNEFABYBDEhPO+WdiKUu0nqFecQtGRIw7P6CmxRp28AmBTgd 9eB8k4mczbYLWKP2TYK7Im6mhHDn0ZkuZUl6uCefODIenrJ6u5SISXXVKss2R3kz fOm5eLQ59LVaoClE7+d8K9ckMiO3dAwD5qsfk7+7laKCO3RfSQI2OcxnA4555BUz LxjdOz3r2DJc6yub9eMl07Ox+Kr22XL47I/w2tL2MM+2tNg7pAaiSrzN8bAeDJf3 IODEj++L8hNttf1XSGnE =1hkn -----END PGP SIGNATURE-----

3 3

Stacklets
by Armin Rigo 28 Sep '11

28 Sep '11

Hi all, Some progress report from my side: I am working on "stacklets", which is, as the name implies, similar to Stackless. It is a rewrite of tealets, which was itself a greenlet-like replacement for Stackless Python. (Yes, "tealet" because of "greenlet": green tea... last time I can do the joke, though, as tealets go away.) Basically a "stacklet" is just a one-shot continuation. The name "stacklet" is going to be internal; at app-level it's just called a continuation. It's the most basic primitive I could eventually arrive at, which is not surprising at all, given that it *is* well known to be the most basic primitive in functional programming. See for example http://en.wikipedia.org/wiki/Call-with-current-continuation. (Of course it is possible to emulate it using other primitives, e.g. http://sigusr2.net/2011/Aug/09/call-cc-for-python.html, but that's abstraction inversion, really.) In the stacklet branch you get a new built-in module called "_continuation" which has only one function: "new", also exposed under the name "callcc", for the reference to various functional programming languages. Doing "_continuation.new(func, args...)" calls "func(c, args...)" with 'c' being a new Continuation object. Calling "c.switch()" will switch back to the point where 'c' was created, and this point will return another continuation 'c2' that can be used to come back again. After a number of switches the function func() can return; it should return yet another Continuation, the one to jump to next. - Continuations are objects with a "switch()" method instead of directly callables, because that seemed more Pythonic - One shot: once you resume a continuation, the object cannot be switched to any more - Garbage collectable: if a pending continuation dies, then every resource reachable only by resuming it dies too - Support for exceptions: if func() terminates by raising an exception, the exception is propagated in the parent (see below) - Implemented like greenlets by moving around part of the C stack, which is easily compatible with the JIT - See http://en.wikipedia.org/wiki/Call-with-current-continuation for a list of what can easily be built on top of them. Once I'm done refactoring the GC to support them (in particular with shadowstack, which requires a bit of care), I will write a greenlet.py module at app-level implementing full greenlets (which should be less than 100 lines of code). It should be useful as a demo of how higher-level abstractions can be implemented on top of continuations. Ah, I should also write a CPython wrapper around the core, which is already written in C, to expose the same continuations for CPython. One (longish, sorry) word about propagating exceptions: this is not usually a concern of functional programming languages, so I had to come up with a way to define where an exception goes. It goes to the 'parent', which is defined in a greenlet-like way: the parent of a 'func' is the piece of C stack that originally started 'func'. I think that this way is the most correct one. Let me explain. One goal of stacklets is to give a "composable" concept, where "composable" is defined as: if two pieces of code independently use continuations, and if both pieces work fine when run in isolation, then they should work fine when run together too. Stackless Python's tasklets are composable: you don't have actually references to tasklets, but only to channel objects, which does the trick (I can give more details if anyone is interested). Greenlets on the other hand are not, and neither are coroutines. Basic continuations (without exceptions) are composable again. Internally, even with pypy+stacklets, continuations form a tree similar to greenlets, but this tree is not exposed to app-level, because doing so would break composability. For example, you could ask the question "what is my 'parent' piece of stack" and jump there; to see how this can be wrong, consider the following call chain: e() -> _continuation.new() -> f() -> g() -> h() where g() is in some other module but calls back your own h(). In this case the 'parent' piece of stack is not well-defined: h() would expect that it is e(), but maybe g() internally did another _continuation.new() too. However, in case of exceptions, then it is *still* the correct thing to do to propagate the exception into the parent. If h() raises, it is propagated back to g(), back to f(), and back to e(), even if g() internally did another _continuation.new(). Every level is free to capture the exception or let it propagate if it's of an unknown class, just like normally. So h() might raise an exception and expect e() to catch it, which will work just like it does in the normal case: it will work as long as g(), which is in another module, doesn't explicitly catch exceptions of the same class as well. I suppose this is already well-known, but I couldn't find an obvious reference. (For example, looking at Ruby doesn't help much because its callcc seems slightly different.) A bientôt, Armin.

6 16

swig + pypy - object reference counting
by Alex Pyattaev 28 Sep '11

28 Sep '11

Hi! I have a quite sophisticated program that can be summarized as follows: 1. Save a pypy object pointer inside C program. Here I call Py_XINCREF so that it does not get deleted. 2. Do some logic, move this reference around C code. 3. Return a python tuple via typemap, here I am probably supposed to return a borrowed reference. And in Python2 it works just fine. BUT. In pypy, for some reason, it causes segfault with following message: """ Fatal error in cpyext, CPython compatibility layer, calling PyTuple_SetItem Either report a bug or consider not using this particular extension <InvalidPointerException object at 0x14a87a8> RPython traceback: File "module_cpyext_api_1.c", line 28965, in PyTuple_SetItem File "module_cpyext_pyobject.c", line 1018, in CpyTypedescr_realize Segmentation fault """ If I call Py_XINCREF before returning the object, the crash does not happen and the memory does not seem to be leaking (at least not noticeably massive amounts of it). So it seems that PyPy is somewhat incompatible with Python2 in that matter. If you want I could send the code example that triggers the bug (it IS quite large app, which might have many more bugs apart from this, but still). Thank you, Alex.

2 3

SpaceOperation
by Łukasz Ligowski 28 Sep '11

28 Sep '11

Hello, I'd like to know what is the purpose of offset field on pypy.objspace.flow.model.SpaceOperation object. It is labeled as "offset in code string" but I have problem to find the right string. I tried with string that is returned by using string returned by FunctionGraph.getsource() but it didn't bring expected results. What I try to accomplish is to learn whether it is possible to map particular SpaceOperation with right line of original source file. L

3 2

Pypy jit and (meta) genetic algorithms
by David Naylor 28 Sep '11

28 Sep '11

Hi All It occurred to me that with the many options available for jit (such as inlining, function_threshold) there may be some merit to optimising those values. I would expect that the optimised values would be workload specific however if a workload takes days to run then it would be worth optimising. I recall an article that used genetic algorithms to select the best parameters (for gcc) that produces the fastest execution. Is there an equivalent program for pypy? Or if it is easy enough could someone put together such a (shell script) program? I, unfortunitely, have no experience with genetic algorithms nor know how to optimise the jit parameters. Regards,

3 2

Student project ideas
by Nick Wilson 28 Sep '11

28 Sep '11

I'm interested in volunteering my time to mentor a small group of senior Computer Science students at Oregon State University on a project relevant to the Python community. PyPy definitely qualifies, and I'm looking for project ideas. The project would be for their senior capstone class. Groups of 2-4 students vote on the list of available projects and then work from roughly mid-November to mid-May (along with all their other coursework) to complete it. The scope of a projects are similar to what you'd assign a full-time summer intern. I'm relatively new to the Python community and haven't poked around PyPy much yet. I see the potential PyPy project list [1] in the developer documentation. That's very helpful, but is anyone able to recommend some projects from that list that are about the right difficulty and size? I have a decent amount of time to work with the students and am looking for a project I could make significant contributions to as well. So I should be able to work closely with the students and take whatever they produce and work it into something usable if they are unable to complete the entire project. Any suggestions? Thanks, Nick Wilson [1] http://doc.pypy.org/en/latest/project-ideas.html

2 2

Re: [pypy-dev] [pypy-commit] pypy default: graphviewer - split the dot2plain function into one for local and one for the codespeak cgi
by Maciej Fijalkowski 28 Sep '11

28 Sep '11

Can't we just kill codespeak's CGI? On Mon, Sep 26, 2011 at 7:40 AM, RonnyPfannschmidt <noreply(a)buildbot.pypy.org> wrote: > Author: Ronny Pfannschmidt <Ronny.Pfannschmidt(a)gmx.de> > Branch: > Changeset: r47606:7acf2b8fcafd > Date: 2011-09-26 12:40 +0200 > http://bitbucket.org/pypy/pypy/changeset/7acf2b8fcafd/ > > Log: graphviewer - split the dot2plain function into one for local and > one for the codespeak cgi > > diff --git a/dotviewer/graphparse.py b/dotviewer/graphparse.py > --- a/dotviewer/graphparse.py > +++ b/dotviewer/graphparse.py > @@ -36,48 +36,45 @@ > print >> sys.stderr, "Warning: could not guess file type, using 'dot'" > return 'unknown' > > -def dot2plain(content, contenttype, use_codespeak=False): > - if contenttype == 'plain': > - # already a .plain file > - return content > +def dot2plain_graphviz(content, contenttype, use_codespeak=False): > + if contenttype != 'neato': > + cmdline = 'dot -Tplain' > + else: > + cmdline = 'neato -Tplain' > + #print >> sys.stderr, '* running:', cmdline > + close_fds = sys.platform != 'win32' > + p = subprocess.Popen(cmdline, shell=True, close_fds=close_fds, > + stdin=subprocess.PIPE, stdout=subprocess.PIPE) > + (child_in, child_out) = (p.stdin, p.stdout) > + try: > + import thread > + except ImportError: > + bkgndwrite(child_in, content) > + else: > + thread.start_new_thread(bkgndwrite, (child_in, content)) > + plaincontent = child_out.read() > + child_out.close() > + if not plaincontent: # 'dot' is likely not installed > + raise PlainParseError("no result from running 'dot'") > + return plaincontent > > - if not use_codespeak: > - if contenttype != 'neato': > - cmdline = 'dot -Tplain' > - else: > - cmdline = 'neato -Tplain' > - #print >> sys.stderr, '* running:', cmdline > - close_fds = sys.platform != 'win32' > - p = subprocess.Popen(cmdline, shell=True, close_fds=close_fds, > - stdin=subprocess.PIPE, stdout=subprocess.PIPE) > - (child_in, child_out) = (p.stdin, p.stdout) > - try: > - import thread > - except ImportError: > - bkgndwrite(child_in, content) > - else: > - thread.start_new_thread(bkgndwrite, (child_in, content)) > - plaincontent = child_out.read() > - child_out.close() > - if not plaincontent: # 'dot' is likely not installed > - raise PlainParseError("no result from running 'dot'") > - else: > - import urllib > - request = urllib.urlencode({'dot': content}) > - url = 'http://codespeak.net/pypy/convertdot.cgi' > - print >> sys.stderr, '* posting:', url > - g = urllib.urlopen(url, data=request) > - result = [] > - while True: > - data = g.read(16384) > - if not data: > - break > - result.append(data) > - g.close() > - plaincontent = ''.join(result) > - # very simple-minded way to give a somewhat better error message > - if plaincontent.startswith('<body'): > - raise Exception("the dot on codespeak has very likely crashed") > +def dot2plain_codespeak(content, contenttype): > + import urllib > + request = urllib.urlencode({'dot': content}) > + url = 'http://codespeak.net/pypy/convertdot.cgi' > + print >> sys.stderr, '* posting:', url > + g = urllib.urlopen(url, data=request) > + result = [] > + while True: > + data = g.read(16384) > + if not data: > + break > + result.append(data) > + g.close() > + plaincontent = ''.join(result) > + # very simple-minded way to give a somewhat better error message > + if plaincontent.startswith('<body'): > + raise Exception("the dot on codespeak has very likely crashed") > return plaincontent > > def bkgndwrite(f, data): > @@ -148,10 +145,13 @@ > > def parse_dot(graph_id, content, links={}, fixedfont=False): > contenttype = guess_type(content) > - try: > - plaincontent = dot2plain(content, contenttype, use_codespeak=False) > - return list(parse_plain(graph_id, plaincontent, links, fixedfont)) > - except PlainParseError: > - # failed, retry via codespeak > - plaincontent = dot2plain(content, contenttype, use_codespeak=True) > - return list(parse_plain(graph_id, plaincontent, links, fixedfont)) > + if contenttype == 'plain': > + plaincontent = content > + else: > + try: > + plaincontent = dot2plain_graphviz(content, contenttype) > + except PlainParseError, e: > + print e > + # failed, retry via codespeak > + plaincontent = dot2plain_codespeak(content, contenttype) > + return list(parse_plain(graph_id, plaincontent, links, fixedfont)) > _______________________________________________ > pypy-commit mailing list > pypy-commit(a)python.org > http://mail.python.org/mailman/listinfo/pypy-commit >

2 1