Categories

## Leaky method references

After reading my last post regarding __del__, you should know that __del__ + reference cycle = leak.
Let’s say that you do need to use __del__, so you decide to avoid reference cycles. You write your code in such a way as to use the minimum necessary cycles, and for the ones that remain you use the weakref module.

You might still have cycles where you don’t expect it – in references to methods.
Consider the following piece of code. Can you spot the reference cycle?

```class A(object): def f(self): return   a = A() a.g = a.f```

This code has the following reference cycle: a -> a.g -> a.f -> a.
How come?
When you call a.f like so: “a.f()” two things happen:
1. A.f is bounded to a
2. The bounded A.f is called with the first parameter getting the bounded value.

You may consider that “a.f” is syntactic sugar for the partial function application, A.f gets a as a first argument but doesn’t get called yet.

When you use “a.g = a.f” what actually happens is a holding a reference to a bounded method, which holds a reference to a.

An idiom that uses these cycles is implementing state machines. Consider the following example code:

```class MyMachine(object): def __init__(self): self.next_func = self.state_a def run(self, input): for x in input: self.next_func(x) def state_a(self, value): print 'a: ', value self.next_func = self.state_b def state_b(self, value): print 'b: ', value self.next_func = self.state_a```

Of course, my code was a bit more complicated than that, but the basic idea remains. (My code usually created some kind of function table in __init__ used to lookup the next function, and lookups happened outside “state functions”). I’ve seen many state machine recipes include method references – and rightly so. It’s a clear and easy way to code a state machine. (For example, this state machine recipe).
Be careful though – once you add __del__ to these simple recipes you might end up with a memory leak.

Short note: I was going to publish this post a few days ago, but kylev beat me to it. This just goes to show that other people encountered this kind of cycle.

Categories

## Python Tidbits

Memory Leaks

With the advent of the Python’s garbage collector, it would seem that Python programs should not leak memory. However, this is not always the case. With just a bit of circular references, you can find yourself leaking quite a bit of memory.

A simple example is a bidirectional data structure, like a 2-way linked list, or a tree where the nodes have a reference to their parents. To really free those, you have to break the cycle manually. Another option is to use a weakref for some of the references. (Usually, I like to use weakref.proxy for the parent links.)

An easy way to test code for memory leaks is to run it in a loop (allocate, do job, deallocate, repeat), and call gc.collect() before and after. If the value that gc.collect() returns after the loop grows with the size of the loop, you might have a memory leak.

I found out about a special case of a potential memory leak just the other day.
Let’s say you want to implement some switch code. A common idiom is to write it like this:

```def a(x): print 'a', x def b(x): print 'b', x ... func = {0: a, 1: b}[x] func()```

This works well enough. However, if you do the same thing in a class instance, things start to get messy:

```class A(object): def __init__(self): self.lookup = {0: self.a, 1: self.b} def a(self, x): print 'a', x def b(self, x): print 'b', x def do_something(self): ... func = self.lookup[x] func(x)```

In this simple example, __init__ creates a reference cycle. This is because self.a creates a method object on the spot, with a reference to self.
So, if z is an instance of A, our cycle is: z->lookup->z.a->z.

Take heed.
(Note: Some cycles are collectible with gc.collect(). The simple cycle described here is such a case. It may get ugly though.)

Undefined
While writing the VM for vial, we needed some way to avoid testing assembly code for undefined values.

For example, after executing a div instruction, CF is undefined. We handle this in the templates by writing CF=UNKNOWN(), and we allow to VM to decide on a value. If you need the VM to just execute code, returning 0 for undefined values is fine. If, however, you are testing code, your actual CPU might return a non-zero value, and your test will fail with no real reason.

To solve this problem, our VM may be told to return a special singleton object for undefined values:

```class _UndefinedNumber(object): def __eq__(self, other): if other is self: return True return False def __ne__(self, other): return not self == other def binary_action(self, other): return self def unary_action(self): return self def __str__(self): return "Undefined" __repr__ = __str__   (__add__, __sub__, __mul__, __div__, __floordiv__, __mod__, __pow__, __and__, __xor__, __or__, __lshift__, __rshift__, __rlshift__, __rrshift__, __radd__, __rsub__, __rmul__, __rdiv__, __rfloordiv__, __rmod__, __rpow__, __rand__, __rxor__, __ror__) = 24*[binary_action]   (__neg__, __pos__, __abs__, __invert__) = 4*[unary_action]   Undefined = _UndefinedNumber()```

Now, we test only the flags that are not Undefined. Note that any operation on an Undefined returns an Undefined. This is done to allow registers to be Undefined as well. This way, if AX gets Undefined, so will AH and EAX.

Here is an example:

```In [2]: Undefined + 1 Out[2]: Undefined   In [3]: Undefined * 2 Out[3]: Undefined   In [4]: Undefined / Undefined Out[4]: Undefined```

Note that this constant might behave a bit strangely. For example, Undefined * 0 is Undefined, and Undefined – Undefined is also Undefined. Because of that, I’m not sure using this object in production circumstances is a good idea, so in the meantime, this is just a testing utility.