+++ /dev/null
-Intro\r
-=====\r
-\r
-The basic rule for dealing with weakref callbacks (and __del__ methods too,\r
-for that matter) during cyclic gc:\r
-\r
- Once gc has computed the set of unreachable objects, no Python-level\r
- code can be allowed to access an unreachable object.\r
-\r
-If that can happen, then the Python code can resurrect unreachable objects\r
-too, and gc can't detect that without starting over. Since gc eventually\r
-runs tp_clear on all unreachable objects, if an unreachable object is\r
-resurrected then tp_clear will eventually be called on it (or may already\r
-have been called before resurrection). At best (and this has been an\r
-historically common bug), tp_clear empties an instance's __dict__, and\r
-"impossible" AttributeErrors result. At worst, tp_clear leaves behind an\r
-insane object at the C level, and segfaults result (historically, most\r
-often by setting a new-style class's mro pointer to NULL, after which\r
-attribute lookups performed by the class can segfault).\r
-\r
-OTOH, it's OK to run Python-level code that can't access unreachable\r
-objects, and sometimes that's necessary. The chief example is the callback\r
-attached to a reachable weakref W to an unreachable object O. Since O is\r
-going away, and W is still alive, the callback must be invoked. Because W\r
-is still alive, everything reachable from its callback is also reachable,\r
-so it's also safe to invoke the callback (although that's trickier than it\r
-sounds, since other reachable weakrefs to other unreachable objects may\r
-still exist, and be accessible to the callback -- there are lots of painful\r
-details like this covered in the rest of this file).\r
-\r
-Python 2.4/2.3.5\r
-================\r
-\r
-The "Before 2.3.3" section below turned out to be wrong in some ways, but\r
-I'm leaving it as-is because it's more right than wrong, and serves as a\r
-wonderful example of how painful analysis can miss not only the forest for\r
-the trees, but also miss the trees for the aphids sucking the trees\r
-dry <wink>.\r
-\r
-The primary thing it missed is that when a weakref to a piece of cyclic\r
-trash (CT) exists, then any call to any Python code whatsoever can end up\r
-materializing a strong reference to that weakref's CT referent, and so\r
-possibly resurrect an insane object (one for which cyclic gc has called-- or\r
-will call before it's done --tp_clear()). It's not even necessarily that a\r
-weakref callback or __del__ method does something nasty on purpose: as\r
-soon as we execute Python code, threads other than the gc thread can run\r
-too, and they can do ordinary things with weakrefs that end up resurrecting\r
-CT while gc is running.\r
-\r
- http://www.python.org/sf/1055820\r
-\r
-shows how innocent it can be, and also how nasty. Variants of the three\r
-focussed test cases attached to that bug report are now part of Python's\r
-standard Lib/test/test_gc.py.\r
-\r
-Jim Fulton gave the best nutshell summary of the new (in 2.4 and 2.3.5)\r
-approach:\r
-\r
- Clearing cyclic trash can call Python code. If there are weakrefs to\r
- any of the cyclic trash, then those weakrefs can be used to resurrect\r
- the objects. Therefore, *before* clearing cyclic trash, we need to\r
- remove any weakrefs. If any of the weakrefs being removed have\r
- callbacks, then we need to save the callbacks and call them *after* all\r
- of the weakrefs have been cleared.\r
-\r
-Alas, doing just that much doesn't work, because it overlooks what turned\r
-out to be the much subtler problems that were fixed earlier, and described\r
-below. We do clear all weakrefs to CT now before breaking cycles, but not\r
-all callbacks encountered can be run later. That's explained in horrid\r
-detail below.\r
-\r
-Older text follows, with a some later comments in [] brackets:\r
-\r
-Before 2.3.3\r
-============\r
-\r
-Before 2.3.3, Python's cyclic gc didn't pay any attention to weakrefs.\r
-Segfaults in Zope3 resulted.\r
-\r
-weakrefs in Python are designed to, at worst, let *other* objects learn\r
-that a given object has died, via a callback function. The weakly\r
-referenced object itself is not passed to the callback, and the presumption\r
-is that the weakly referenced object is unreachable trash at the time the\r
-callback is invoked.\r
-\r
-That's usually true, but not always. Suppose a weakly referenced object\r
-becomes part of a clump of cyclic trash. When enough cycles are broken by\r
-cyclic gc that the object is reclaimed, the callback is invoked. If it's\r
-possible for the callback to get at objects in the cycle(s), then it may be\r
-possible for those objects to access (via strong references in the cycle)\r
-the weakly referenced object being torn down, or other objects in the cycle\r
-that have already suffered a tp_clear() call. There's no guarantee that an\r
-object is in a sane state after tp_clear(). Bad things (including\r
-segfaults) can happen right then, during the callback's execution, or can\r
-happen at any later time if the callback manages to resurrect an insane\r
-object.\r
-\r
-[That missed that, in addition, a weakref to CT can exist outside CT, and\r
- any callback into Python can use such a non-CT weakref to resurrect its CT\r
- referent. The same bad kinds of things can happen then.]\r
-\r
-Note that if it's possible for the callback to get at objects in the trash\r
-cycles, it must also be the case that the callback itself is part of the\r
-trash cycles. Else the callback would have acted as an external root to\r
-the current collection, and nothing reachable from it would be in cyclic\r
-trash either.\r
-\r
-[Except that a non-CT callback can also use a non-CT weakref to get at\r
- CT objects.]\r
-\r
-More, if the callback itself is in cyclic trash, then the weakref to which\r
-the callback is attached must also be trash, and for the same kind of\r
-reason: if the weakref acted as an external root, then the callback could\r
-not have been cyclic trash.\r
-\r
-So a problem here requires that a weakref, that weakref's callback, and the\r
-weakly referenced object, all be in cyclic trash at the same time. This\r
-isn't easy to stumble into by accident while Python is running, and, indeed,\r
-it took quite a while to dream up failing test cases. Zope3 saw segfaults\r
-during shutdown, during the second call of gc in Py_Finalize, after most\r
-modules had been torn down. That creates many trash cycles (esp. those\r
-involving new-style classes), making the problem much more likely. Once you\r
-know what's required to provoke the problem, though, it's easy to create\r
-tests that segfault before shutdown.\r
-\r
-In 2.3.3, before breaking cycles, we first clear all the weakrefs with\r
-callbacks in cyclic trash. Since the weakrefs *are* trash, and there's no\r
-defined-- or even predictable --order in which tp_clear() gets called on\r
-cyclic trash, it's defensible to first clear weakrefs with callbacks. It's\r
-a feature of Python's weakrefs too that when a weakref goes away, the\r
-callback (if any) associated with it is thrown away too, unexecuted.\r
-\r
-[In 2.4/2.3.5, we first clear all weakrefs to CT objects, whether or not\r
- those weakrefs are themselves CT, and whether or not they have callbacks.\r
- The callbacks (if any) on non-CT weakrefs (if any) are invoked later,\r
- after all weakrefs-to-CT have been cleared. The callbacks (if any) on CT\r
- weakrefs (if any) are never invoked, for the excruciating reasons\r
- explained here.]\r
-\r
-Just that much is almost enough to prevent problems, by throwing away\r
-*almost* all the weakref callbacks that could get triggered by gc. The\r
-problem remaining is that clearing a weakref with a callback decrefs the\r
-callback object, and the callback object may *itself* be weakly referenced,\r
-via another weakref with another callback. So the process of clearing\r
-weakrefs can trigger callbacks attached to other weakrefs, and those\r
-latter weakrefs may or may not be part of cyclic trash.\r
-\r
-So, to prevent any Python code from running while gc is invoking tp_clear()\r
-on all the objects in cyclic trash,\r
-\r
-[That was always wrong: we can't stop Python code from running when gc\r
- is breaking cycles. If an object with a __del__ method is not itself in\r
- a cycle, but is reachable only from CT, then breaking cycles will, as a\r
- matter of course, drop the refcount on that object to 0, and its __del__\r
- will run right then. What we can and must stop is running any Python\r
- code that could access CT.]\r
- it's not quite enough just to invoke\r
-tp_clear() on weakrefs with callbacks first. Instead the weakref module\r
-grew a new private function (_PyWeakref_ClearRef) that does only part of\r
-tp_clear(): it removes the weakref from the weakly-referenced object's list\r
-of weakrefs, but does not decref the callback object. So calling\r
-_PyWeakref_ClearRef(wr) ensures that wr's callback object will never\r
-trigger, and (unlike weakref's tp_clear()) also prevents any callback\r
-associated *with* wr's callback object from triggering.\r
-\r
-[Although we may trigger such callbacks later, as explained below.]\r
-\r
-Then we can call tp_clear on all the cyclic objects and never trigger\r
-Python code.\r
-\r
-[As above, not so: it means never trigger Python code that can access CT.]\r
-\r
-After we do that, the callback objects still need to be decref'ed. Callbacks\r
-(if any) *on* the callback objects that were also part of cyclic trash won't\r
-get invoked, because we cleared all trash weakrefs with callbacks at the\r
-start. Callbacks on the callback objects that were not part of cyclic trash\r
-acted as external roots to everything reachable from them, so nothing\r
-reachable from them was part of cyclic trash, so gc didn't do any damage to\r
-objects reachable from them, and it's safe to call them at the end of gc.\r
-\r
-[That's so. In addition, now we also invoke (if any) the callbacks on\r
- non-CT weakrefs to CT objects, during the same pass that decrefs the\r
- callback objects.]\r
-\r
-An alternative would have been to treat objects with callbacks like objects\r
-with __del__ methods, refusing to collect them, appending them to gc.garbage\r
-instead. That would have been much easier. Jim Fulton gave a strong\r
-argument against that (on Python-Dev):\r
-\r
- There's a big difference between __del__ and weakref callbacks.\r
- The __del__ method is "internal" to a design. When you design a\r
- class with a del method, you know you have to avoid including the\r
- class in cycles.\r
-\r
- Now, suppose you have a design that makes has no __del__ methods but\r
- that does use cyclic data structures. You reason about the design,\r
- run tests, and convince yourself you don't have a leak.\r
-\r
- Now, suppose some external code creates a weakref to one of your\r
- objects. All of a sudden, you start leaking. You can look at your\r
- code all you want and you won't find a reason for the leak.\r
-\r
-IOW, a class designer can out-think __del__ problems, but has no control\r
-over who creates weakrefs to his classes or class instances. The class\r
-user has little chance either of predicting when the weakrefs he creates\r
-may end up in cycles.\r
-\r
-Callbacks on weakref callbacks are executed in an arbitrary order, and\r
-that's not good (a primary reason not to collect cycles with objects with\r
-__del__ methods is to avoid running finalizers in an arbitrary order).\r
-However, a weakref callback on a weakref callback has got to be rare.\r
-It's possible to do such a thing, so gc has to be robust against it, but\r
-I doubt anyone has done it outside the test case I wrote for it.\r
-\r
-[The callbacks (if any) on non-CT weakrefs to CT objects are also executed\r
- in an arbitrary order now. But they were before too, depending on the\r
- vagaries of when tp_clear() happened to break enough cycles to trigger\r
- them. People simply shouldn't try to use __del__ or weakref callbacks to\r
- do fancy stuff.]\r
projects / mirror_edk2.git / blobdiff