Stackless vs GIL: It's a draw, cont.

I decided to double check my assumptions about Stackless and the GIL on a multicore machine, using the same example provided by David Beazley in his slides, which highlights the GIL contention issue. It's probably a better example than my previous test.

import stackless
import time
import threading

def count(n): 
    while n > 0:  
        n -= 1 

T = time.clock()
count(100000000) 
count(100000000) 
print time.clock() - T

>>> 17.37

A normal sequential execution takes about 17 seconds.

T = time.clock()
t1 = threading.Thread(target=count,args=(100000000,)) 
t1.start() 
t2 = threading.Thread(target=count,args=(100000000,)) 
t2.start() 
t1.join(); t2.join()
print time.clock() - T

>>> 53.22

This confirms David's experiment. It takes much longer due to threads fighting over the GIL.

T = time.clock()
stackless.tasklet(count)(100000000)
stackless.tasklet(count)(100000000)
while stackless.getruncount() > 1:
    task = stackless.run(100)
    if task:
        task.insert()
print time.clock() - T

>>> 25.34

Twice as fast as the threaded solution, and roughly 50% slower than than the sequential solution. Cool.

We can get much better results by increasing the granularity of the scheduler. If we change the tick count to 1000, the Stackless solution takes 17.71 seconds, and the threaded solution takes 22.25 seconds. This is interesting behavior, which I can't yet explain.