per-method jit compiler

Luis M. González luismgz at gmail.com
Tue Apr 6 08:22:59 CEST 2010


On 4 abr, 00:09, Steven D'Aprano <st... at REMOVE-THIS-

- Ocultar texto de la cita -
cybersource.com.au> wrote:
> On Sat, 03 Apr 2010 22:58:43 +0000, kj wrote:
> > Suppose I have a function with the following signature:
> > def spam(x, y, z):
> >     # etc.
> > Is there a way to refer, within the function, to all its arguments as a
> > single list?  (I.e. I'm looking for Python's equivalent of Perl's @_
> > variable.)
> Does this help?
> >>> def spam(a, b, c=3, d=4):
> ...     pass
> ...>>> spam.__code__.co_varnames
> ('a', 'b', 'c', 'd')
> The hardest part is having the function know its own name.
> I see that you are already using the inspect module. That almost
> certainly is the correct approach. I'd be surprised if inspect is too
> heavyweight, but if it is, you can pull out the bits you need into your
> own function.
> --
> Steven


The above post gave me an idea (very naive, of couse).
What if I write a simple decorator to figure out the types of every
function, and then we use it as a base for a simple method-jit
compiler for python?
example:
def typer(f):
        def wrap(*args):
            a = f.func_code.co_varnames
            b = [type(i) for i in args]
            return dict(zip(a,b))
        return wrap
@typer
def spam(a, b, c=3, d=4):
        pass
>>> spam(8,'hello',9.9, 10)

{'a': <type 'int'>, 'c': <type 'float'>, 'b': <type 'str'>, 'd':
<type
'int'>}
So by using this information, we record all the argument types used
the first time each function/method is executed, and then we generate
optimized code for them.
>From this point on, a guard should check if all arguments remain the
same and, if so, the optimized code is run.
Otherwise, just fall back to the interpreter.
He! I have no idea how to implement it...
Any guru out there?
Luis



More information about the Python-list mailing list