Stackless RPython - Recursive

Got input from pypy/rpython developers, and in order to get stackless rpython it was just to add parameter stackless=True and replace parameter gc='ref' with gc='generation' to Translation() method.

# The Computer Language Shootout
# http://shootout.alioth.debian.org/
# based on bearophile's psyco program
# slightly modified by Isaac Gouy
# And adapted to RPython by Amund

def Ack(x, y):
    if x == 0: return y+1
    if y == 0: return Ack(x-1, 1)
    return Ack(x-1, Ack(x, y-1))

def Fib(n):
    if n < 2: return 1
    return Fib(n-2) + Fib(n-1)

def FibFP(n):
    if n < 2.0: return 1.0
    return FibFP(n-2.0) + FibFP(n-1.0)

def Tak(x, y, z):
    if y < x: 
 return Tak( 
  Tak(x-1,y,z), 
  Tak(y-1,z,x), 
  Tak(z-1,x,y) )
    return z

def TakFP(x, y, z):
    if y < x: 
 return TakFP( 
 TakFP(x-1.0,y,z), 
 TakFP(y-1.0,z,x),  
 TakFP(z-1.0,x,y) )
    return z

# RPython stuff starts here

from sys import argv #, setrecursionlimit
#setrecursionlimit(12345678901)

def main(argv):
    n = int(argv[1]) - 1
    print "Ack(3,%d):" % (n+1), Ack(3, n+1)
    print "Fib(" + str(28.0+n) + "," + str(FibFP(28.0+n))
    print "Tak(%d,%d,%d): %d" % (3*n, 2*n, n, Tak(3*n, 2*n, n))
    print "Fib(3):", Fib(3)
    print "Tak(3.0,2.0,1.0):", TakFP(3.0, 2.0, 1.0)
    return 0

from pypy.translator.interactive import Translation
#t = Translation(main, standalone=True, gc='ref')
t = Translation(main, standalone=True, 
 stackless=True, gc='generation')
t.source(backend='c')
path = t.compile()
print path

RPython GCLB Benchmark - Recursive

Must admit that I am a big fan of python (the programming language), and when I saw the benchmark that RPython can be faster than C (on the binary tree benchmark from the Great Computer Language Shootout - GCLS), I just had to try RPython on another problem from GCLS, so I chose the one with worst performance compared to C/gcc (266 times slower) - recursive (with various recursive methods, e.g. Ackerman, Fibonacci and Tak). Results were roughly that rpython was 50-100 and gcc/c was 100-300 times faster than python (note: I only did one run, so numbers can be somewhat bogus, but not too bad I think).



Unfortunately for the run with n=11 Ackerman had consumed all the stack, but that can be solved with Stackless RPython.