Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Python > per-method jit compiler

Reply
Thread Tools

per-method jit compiler

 
 
Luis M. González
Guest
Posts: n/a
 
      04-06-2010
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
 
Reply With Quote
 
 
 
 
Irmen de Jong
Guest
Posts: n/a
 
      04-06-2010
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


 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
per-function jit compiler Luis M. González Python 3 04-06-2010 04:02 PM
Failed to load JIT compiler Ken ASP .Net 0 05-07-2007 07:28 PM
Why is a JIT compiler faster than a byte-compiler RickMuller Python 4 03-26-2005 04:30 PM
JIT Compiler drv ASP .Net 0 07-09-2003 01:35 PM
Variable JIT of ASPX files? Glen ASP .Net 2 06-26-2003 06:41 PM



Advertisments