CPython vs PyPy Memory Usage

What Is Not Being Measured

In this example output from a run of PyPy, the AbsoluteUsage is the total growth from when the program started, while the Delta is the growth just within this function.

Memory for Point3D(1, 2, 3)
Count      AbsoluteUsage     Delta
=======================================
      100           0.02           0.02
     1000           0.03           0.03
    10000           0.51           0.51
   100000           7.20           7.20
  1000000          69.11          69.11
 10000000         691.90         691.90

This was the first of the test runs within this particular process. The second test run within this process reports higher absolute deltas since the beginning of the program, although the overall deltas are smaller. This indicates how much memory the program has allocated from the operating system but not returned to it, even though it may technically free from the standpoint of the Python runtime; this accounts for things like internal caches, or in PyPy's case, jitted code.

Memory for Point3DSlot(1, 2, 3)
Size of Point3DSlot -1
Count      AbsoluteUsage     Delta
=======================================
      100          86.09           0.00
     1000          86.12           0.03
    10000          86.56           0.46
   100000          87.33           1.23
  1000000         138.70          52.60
 10000000         692.05         605.95

Although I captured the data, this post is not about the startup or initial memory allocation of the various interpreters, nor about how much can easily be shared between forked processes, nor about how much memory is returned to the operating system while the process is still running. We're only talking about the memory size needed to allocate a given number of objects, e.g., the Delta column.

Objects with Dictionaries

Standard objects, like Point3D, have a special attribute __dict__, that is a normal Python dictionary object that is used to hold all the instance attributes for the object. We previously looked at how __getattribute__ can be used to customize all attribute reads for an object; likewise, __setattr__ can customize all attribute writes. The default __getattribute__ and __setattr__ that a class inherits from object function something like they were written to access the __dict__:

class Object:

    def __getattribute__(self, name):
        if name in self.__dict__:
             return self.__dict__[name]
        return getattr(type(self), name)

    def __setattr__(self, name, value):
        self.__dict__[name] = value

One advantage of having a __dict__ underlying an object is the flexibility it provides: you don't have to pre-declare your attributes for every object, and any object can have any attribute, so it facilitates subclasses adding new attributes, or even other libraries adding new, specialized, attributes to implement caching of expensive computed properties.

One disadvantage is that a __dict__ is a generic Python dictionary, not specialized at all [3], and as such it has overhead.

On CPython, we can ask the interpreter how much memory any given object uses with sys.getsizeof. On my machine under a 64-bit CPython 2.7.15, a bare object takes 16 bytes, while a trivial subclass takes a full 64 bytes (due to the overhead of being tracked by the garbage collector):

>>> import sys
>>> sys.getsizeof(object())
16
>>> class TrivialSubclass(object): pass
>>> sys.getsizeof(TriviasSubclass())
64

An empty dict occupies 280 bytes:

>>> sys.getsizeof({})
280

And so when you combine the size of the trivial subclass, with the size of its __dict__ you arrive at a minimum object size of 344 bytes:

>>> sys.getsizeof(TrivialSubclass().__dict__)
280
>>> sys.getsizeof(TrivialSubclass()) + sys.getsizeof(TrivialSubclass().__dict__)
344

A fully occupied Point3D object is also 344 bytes:

>>> pd = Point3D(1, 2, 3)
>>> sys.getsizeof(pd) + sys.getsizeof(pd.__dict__)
344

Because of the way dictionaries are implemented [8], there's always a little spare room for extra attributes. We don't find a jump in size until we've added three more attributes:

>>> pd.a = 1
>>> sys.getsizeof(pd) + sys.getsizeof(pd.__dict__)
344
>>> pd.b = 1
>>> sys.getsizeof(pd) + sys.getsizeof(pd.__dict__)
344
>>> pd.c = 1
>>> sys.getsizeof(pd) + sys.getsizeof(pd.__dict__)
1112

Objects With Slots

Objects with a __slots__ declaration, like Point3DSlot do not have a __dict__ by default. The documentation notes that this can be a space savings. Indeed, on CPython 2.7, a Point3DSlot has a size of only 72 bytes, only one full pointer larger than a trivial subclass (when we do not factor in the __dict__):

>>> pds = Point3DSlot(1, 2, 3)
>>> sys.getsizeof(pds)
72

If they don't have an instance dictionary, where do they store their attributes? And why, if Point3DSlot has three defined attributes, is it only one pointer larger than Point3D?

Slots, like @property, @classmethod and @staticmethod, are implemented using descriptors. For our purpose, descriptors are a way to extend the workings of __getattribute__ and friends. A descriptor is an object whose type implements a __get__ method, and when that object is found in a type's dictionary, it is called instead of checking the __dict__. Something like this [5]:

class Object:

    def __getattribute__(self, name):
        if (name in dir(type(self))
           and hasattr(getattr(type(self), name), '__get__')):
           return getattr(type(self), name).__get__(self, type(self))

        if name in self.__dict__:
             return self.__dict__[name]
        return getattr(type(self), name)

    def __setattr__(self, name, value):
        if (name in dir(type(self))
           and hasattr(getattr(type(self), name), '__set__')):
           getattr(type(self), name).__set__(self, type(self))
           return
        self.__dict__[name] = value

When the class statement (indeed, when the type metaclass) finds __slots__ in the class body (the class dictionary), it takes special steps. Most importantly, it creates a descriptor for each mentioned slot and places it in the class's __dict__. So our Point3DSlot class gets three such descriptors:

>>> dict(Point3DSlot.__dict__)
{'__doc__': None,
'__init__': <function __main__.__init__>,
'__module__': '__main__',
'__slots__': ('x', 'y', 'z'),
'x': <member 'x' of 'Point3DSlot' objects>,
'y': <member 'y' of 'Point3DSlot' objects>,
'z': <member 'z' of 'Point3DSlot' objects>}
>>> pds.x
1
>>> Point3DSlot.x.__get__
>>> <method-wrapper '__get__' of member_descriptor object at 0x10b6fc2d8>
>>> Point3DSlot.x.__get__(pds, Point3DSlot)
1

>>> object.__basicsize__
16
>>> sys.getsizeof(object())
16

>>> class NoSlots(object):
...     __slots__ = ()
...
>>> NoSlots.__basicsize__
16
>>> sys.getsizeof(NoSlots())
16

>>> class OneSlot(object):
...     __slots__ = ('a',)
...
>>> OneSlot.__basicsize__
24
>>> sys.getsizeof(OneSlot())
56

>>> Point3DSlot.__basicsize__
40
>>> Point.__basicsize__
32