Timely deallocation

[KubaO]

Per the Perceus precise reference counting paper:

• object liveliness can be tracked precisely: last use in a scope causes deref and possible deallocation, instead of waiting for the scope to be exited
• the object being deref'd more likely to be in the caches, so the cost of reference counter update and object traversal is lower
• deallocation is expected then to be faster, and the memory use is lower too since fewer temporary objects dwell around

I haven't checked, but I imagine that Python currently derefs locals when the scope is exited, and not at the point of last reference in the scope.

Is timely deallocation an idea that was raised before - and if not, would that be something worth doing? I presume a proof-of-concept with some reasonable benchmark indicators of improvement would be in order first.

[brandtbucher]

One tricky thing is that people generally expect code like this to work:

>>> def f():
...     spam = 42
...     print(locals()["spam"])
...     print(eval("spam"))
...     breakpoint()
... 
>>> f()
42
42
--Return--
> <stdin>(5)f()->None
(Pdb) spam
42

Implicitly deleting spam too early causes code like this to fail.

[serjflint]

Hello! I'm not an expert, I just want to add some ideas.
Can't locals() increase counters to the visible objects and by itself use some hidden from the user mechanism to keep itself until the end of the scope?

[gvanrossum]

This clearly looks like it would affect the behavior of many user programs by changing the order in which finalizers run. I don't think that we can do this without a PEP, and I honestly think such a PEP would not be acceptable, so I think I'll close this issue.

For a new language it would make sense though. Mojo has this baked into the language currently.