Fix a memory leak in the Operator base class (#1632)

* Fix a memory leak in the Operator base class

References to operator *class* definitions were cached in the argument cache of
`_dispatch_call_args` function, hence GC couldn't collect them. Normally that's not
an issue, as class definitions don't consume much memory. However, a typical
pattern of defining adjoint operators in ODL is using nested classes with
references back to their encapsulating *objects*. Depending on the Operator, it
may cause considerable memory leaks. For example, `RayTransform` objects hold
references to space and geometry objects, preventing them from being reaped by
GC and leading to considerable memory leaks.

The fix I've implemented is moving away from an argument cache in favor of caching
the returned values on the class itself. This ensures no class object references are
held permanently in the cache_arguments() decorator.

Author: peterisr

odl/operator/operator.py

@@ -17,7 +17,6 @@
 
 from odl.set import Field, LinearSpace, Set
 from odl.set.space import LinearSpaceElement
-from odl.util import cache_arguments
 
 __all__ = (
     'Operator',
@@ -122,7 +121,6 @@ def _function_signature(func):
     return '{}({})'.format(func.__name__, argstr)
 
 
-@cache_arguments
 def _dispatch_call_args(cls=None, bound_call=None, unbound_call=None,
                         attr='_call'):
     """Check the arguments of ``_call()`` or similar for conformity.
@@ -420,20 +418,21 @@ class described in the following.
 
     def __new__(cls, *args, **kwargs):
         """Create a new instance."""
-        call_has_out, call_out_optional, _ = _dispatch_call_args(cls)
-        cls._call_has_out = call_has_out
-        cls._call_out_optional = call_out_optional
-        if not call_has_out:
-            # Out-of-place _call
-            cls._call_in_place = _default_call_in_place
-            cls._call_out_of_place = cls._call
-        elif call_out_optional:
-            # Dual-use _call
-            cls._call_in_place = cls._call_out_of_place = cls._call
-        else:
-            # In-place-only _call
-            cls._call_in_place = cls._call
-            cls._call_out_of_place = _default_call_out_of_place
+        if '_call_out_of_place' not in cls.__dict__:
+            call_has_out, call_out_optional, _ = _dispatch_call_args(cls)
+            cls._call_has_out = call_has_out
+            cls._call_out_optional = call_out_optional
+            if not call_has_out:
+                # Out-of-place _call
+                cls._call_in_place = _default_call_in_place
+                cls._call_out_of_place = cls._call
+            elif call_out_optional:
+                # Dual-use _call
+                cls._call_in_place = cls._call_out_of_place = cls._call
+            else:
+                # In-place-only _call
+                cls._call_in_place = cls._call
+                cls._call_out_of_place = _default_call_out_of_place
 
         return object.__new__(cls)