Magic Optimisation

[simonwittber]

Hello People.

I've have a very tight inner loop (in a game app, so every millisecond
counts) which I have optimised below:

def loop(self):
self_pool = self.pool
self_call_exit_ funcs = self.call_exit_ funcs
self_pool_pople ft = self.pool.pople ft
self_pool_appen d = self.pool.appen d
check = self.pool.__len __
while check() > 0:
task = self_pool_pople ft()
try:
task.next()
except StopIteration:
self_call_exit_ funcs(task)
return
self_pool_appen d(task)

This style of optimisation has shaved _seconds_ from my iteration
cycle, esp. when I have many registered tasks, so this style of
optimisation is very important to me.

However, it is very ugly. Does anyone have any tips on how I could get
this optimisation to occor magically, via a decorator perhaps?

Sw.

[Paul McGuire]

This isn't much prettier, but what if you extract the try-except
overhead out from the while loop? You only expect the exception to
fire one time, at the end of the list. You can also eliminate any
localization of variables for calls that are not called in the loop,
such as self_pool (which does not seem to be used at all), and
self_call_exit_ funcs.

-- Paul

def loop(self):
self_pool_pople ft = self.pool.pople ft
self_pool_appen d = self.pool.appen d
check = self.pool.__len __
try:
while check() > 0:
task = self_pool_pople ft()
task.next()
self_pool_appen d(task)
except StopIteration:
self.call_exit_ funcs(task)
return

[Paul Rubin]

si**********@gm ail.com writes:

However, it is very ugly. Does anyone have any tips on how I could get
this optimisation to occor magically, via a decorator perhaps?

Have you tried psyco?

[simonwittber]

I guess it is hard to see what the code is doing without a complete
example.

The StopIteration is actually raised by task.next(), at which point
task is removed from the list of generators (self.pool). So the
StopIteration can be raised at any time.

The specific optimisation I am after, which will clean up the code a
lot, is a way to auto-magically create self_attribute local variables
from self.attribute instance variables.

Sw.

[simonwittber]

Yes. It slows down the loop when there are only a few iterators in the
pool, and speeds it up when there are > 2000.

My use case involves < 1000 iterators, so psyco is not much help. It
doesn't solve the magic creation of locals from instance vars either.

Sw.

[Paul Rubin]

si**********@gm ail.com writes:

My use case involves < 1000 iterators, so psyco is not much help. It
doesn't solve the magic creation of locals from instance vars either.

How about using __slots__ to put those instance vars at fixed offsets
in the pool object (self then needs to be a new-style class instance).
That might or might not avoid the dict lookups.

[simonwittber]

> def loop(self):

self_pool = self.pool
self_call_exit_ funcs = self.call_exit_ funcs
self_pool_pople ft = self.pool.pople ft
self_pool_appen d = self.pool.appen d
check = self.pool.__len __
while check() > 0:
task = self_pool_pople ft()
try:
task.next()
except StopIteration:
self_call_exit_ funcs(task)
return
self_pool_appen d(task)

Stupid me. the 'return' statement above should be 'continue'. Sorry for
the confusion.

[Tomasz Lisowski]

si**********@gm ail.com napisał(a):

def loop(self):
self_pool = self.pool
self_call_exit_ funcs = self.call_exit_ funcs
self_pool_pople ft = self.pool.pople ft
self_pool_appen d = self.pool.appen d
check = self.pool.__len __
while check() > 0:
task = self_pool_pople ft()
try:
task.next()
except StopIteration:
self_call_exit_ funcs(task)
return
self_pool_appen d(task)

Stupid me. the 'return' statement above should be 'continue'. Sorry for
the confusion.

Then you can avoid continue by writing:

while check() > 0:
task = self_pool_pople ft()
try:
task.next()
except StopIteration:
self_call_exit_ funcs(task)
else:
self_pool_appen d(task)

Tomasz Lisowski

[Paul McGuire]

I still think there are savings to be had by looping inside the
try-except block, which avoids many setup/teardown exception handling
steps. This is not so pretty in another way (repeated while on
check()), but I would be interested in your timings w.r.t. your current
code.

def loop(self):
self_pool_pople ft = self.pool.pople ft
self_pool_appen d = self.pool.appen d
self_call_exit_ funcs = self.call_exit_ funcs
check = self.pool.__len __
while check() > 0:
try:
while check() > 0:
task = self_pool_pople ft()
task.next()
self_pool_appen d(task)
except StopIteration:
self_call_exit_ funcs(task)

-- Paul

[Paul McGuire]

Raymond Hettinger posted this recipe to the Python Cookbook. I've not
tried it myself, but it sounds like what you're looking for.

http://aspn.activestate.com/ASPN/Coo.../Recipe/277940

-- Paul