[Python-checkins] CVS: python/nondist/peps pep-0205.txt,1.2,1.3

Fred L. Drake python-dev@python.org
Tue, 7 Nov 2000 22:20:42 -0800

Update of /cvsroot/python/python/nondist/peps
In directory slayer.i.sourceforge.net:/tmp/cvs-serv20652

Modified Files:
Log Message:

Added some text describing the motivations for weak references, what is
available in Java, and pointers to previous work in Python.

There is a lot to be done before there can be a sample implementation;
issues related to implementation need to be discussed.

Index: pep-0205.txt
RCS file: /cvsroot/python/python/nondist/peps/pep-0205.txt,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -r1.2 -r1.3
*** pep-0205.txt	2000/10/30 20:48:44	1.2
--- pep-0205.txt	2000/11/08 06:20:40	1.3
*** 2,8 ****
  Title: Weak References
  Version: $Revision$
! Owner: fdrake@acm.org (Fred Drake)
  Python-Version: 2.1
  Status: Incomplete
--- 2,149 ----
  Title: Weak References
  Version: $Revision$
! Owner: Fred L. Drake, Jr. <fdrake@acm.org>
  Python-Version: 2.1
  Status: Incomplete
+ Type: Standards Track
+ Post-History: 
+ Motivation
+     There are two basic applications for weak references which have
+     been noted by Python programmers: object caches and reduction of
+     pain from circular references.
+     Caches (weak dictionaries)
+         There is a need to allow objects to be maintained to represent
+         external state, mapping a single instance to the external
+         reality, where allowing multiple instances to be mapped to the
+         same external resource would create unnecessary difficulty
+         maintaining synchronization among instances.  In these cases,
+         a common idiom is to support a cache of instances; a factory
+         function is used to return either a new or existing instance.
+         The difficulty in this approach is that one of two things must
+         be tolerated: either the cache grows without bound, or there
+         needs to be explicit management of the cache elsewhere in the
+         application.  The later can be very tedious and leads to more
+         code than is really necessary to solve the problem at hand,
+         and the former can be unacceptable for long-running processes
+         or even relatively short processes with substantial memory
+         requirements.
+         - External objects that need to be represented by a single
+           instance, no matter how many internal users there are.  This
+           can be useful for representing files that need to be written
+           back to disk in whole rather than locked & modified for
+           every use.
+         - Objects which are expensive to create, but may be needed by
+           multiple internal consumers.  Similar to the first case, but
+           not necessarily bound to external resources, and possibly
+           not an issue for shared state.  Weak references are only
+           useful in this case if there is some flavor of "soft"
+           references or if there is a high likelihood that users of
+           individual objects will overlap in lifespan.
+     Circular references
+         - DOMs require a huge amount of circular (to parent & document
+           nodes), but most of these aren't useful.  Using weak
+           references allows applications to hold onto less of the tree
+           without a lot of difficulty.  This might be especially
+           useful in the context of something like xml.dom.pulldom.
+ Weak References in Java
+     http://java.sun.com/j2se/1.3/docs/api/java/lang/ref/package-summary.html
+     Java provides three forms of weak references, and one interesting
+     helper class.  The three forms are called "weak", "soft", and
+     "phantom" references.  The relevant classes are defined in the
+     java.lang.ref package.
+     For each of the reference types, there is an option to add the
+     reference to a queue when it is invalidated by the memory
+     allocator.  The primary purpose of this facility seems to be that
+     it allows larger structures to be composed to incorporate
+     weak-reference semantics without having to impose substantial
+     additional locking requirements.  For instance, it would not be
+     difficult to use this facility to create a "weak" hash table which
+     removes keys and referents when a reference is no longer used
+     elsewhere.  Using weak references for the objects without some
+     sort of notification queue for invalidations leads to much more
+     tedious implementation of the various operations required on hash
+     tables.  This can be a performance bottleneck if deallocations of
+     the stored objects are infrequent.
+     Java's "weak" references are most like Diane Hackborn's old vref
+     proposal: a reference object refers to a single Python object,
+     but does not own a reference to that object.  When that object is
+     deallocated, the reference object is invalidated.  Users of the
+     reference object can easily determine that the reference has been
+     invalidated, or a NullObjectDereferenceError can be raised when
+     an attempt is made to use the referred-to object.
+     The "soft" references are similar, but are not invalidated as soon
+     as all other references to the referred-to object have been
+     released.  The "soft" reference does own a reference, but allows
+     the memory allocator to free the referent if the memory is needed
+     elsewhere.  It is not clear whether this means soft references are
+     released before the malloc() implementation calls sbrk() or its
+     equivalent, or if soft references are only cleared when malloc()
+     returns NULL.
+     XXX -- Need to figure out what phantom references are all about.
+     Unlike the other two reference types, "phantom" references must be
+     associated with an invalidation queue.
+ Previous Weak Reference Work in Python
+     Diane Hackborn's vref work.  'vref' objects were very similar to
+     java.lang.ref.WeakReference objects, except there was no
+     equivalent to the invalidation queues.  Implementing a "weak
+     dictionary" would be just as difficult as using only weak
+     references (without the invalidation queue) in Java.  Information
+     on this appears to have disappeared from the Web.  Original
+     discussion occurred in the comp.lang.python newsgroup; a good
+     archive of that may turn up something more.  Dianne's old Web
+     pages at Oregon State University have disappeared.  I've sent an
+     email to what appears to be a recent email address for Dianne to
+     see if any information is still available.
+     Marc-André Lemburg's mx.Proxy package.  These Web pages appear to
+     be unavailable at the moment.
+         http://starship.python.net/crew/lemburg/
+     The weakdict module by Dieter Maurer is implemented in C and
+     Python.  It appears that the Web pages have not been updated since
+     Python 1.5.2a, so I'm not yet sure if the implementation is
+     compatible with Python 2.0.
+         http://www.handshake.de/~dieter/weakdict.html
+ Possible Applications
+     PyGTK+ bindings?
+     Tkinter?
+     DOM trees?
+ Proposed Implementation
+     XXX -- Not yet.
+ Copyright
+     This document has been placed in the public domain.