per-method jit compiler

Discussion in 'Python' started by Luis M. González, Apr 6, 2010.

  1. On 4 abr, 00:09, Steven D'Aprano <st...@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
     
    Luis M. González, Apr 6, 2010
    #1
    1. Advertising

  2. On 6-4-2010 8:22, Luis M. González wrote:
    > 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


    Isn't this what Psyco (http://psyco.sourceforge.net/) does?

    -irmen
     
    Irmen de Jong, Apr 6, 2010
    #2
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. drv

    JIT Compiler

    drv, Jul 9, 2003, in forum: ASP .Net
    Replies:
    0
    Views:
    1,536
  2. RickMuller
    Replies:
    4
    Views:
    716
    Alexey Shamrin
    Mar 26, 2005
  3. Ken

    Failed to load JIT compiler

    Ken, May 7, 2007, in forum: ASP .Net
    Replies:
    0
    Views:
    938
  4. Luis M. González

    per-function jit compiler

    Luis M. González, Apr 6, 2010, in forum: Python
    Replies:
    3
    Views:
    280
    Gabriel Genellina
    Apr 6, 2010
  5. 1989lzhh
    Replies:
    0
    Views:
    50
    1989lzhh
    Jun 12, 2014
Loading...

Share This Page