# Patent

## Title
Lightweight reference counting using single-target synchronization

## Abstract

We have developed a methodology for transforming garbage collection-dependent algorithms, shared object implementations and/or concurrent software mechanisms into a form that does not presume the existence of an independent, or execution environment provided, garbage collector. Algorithms, shared object implementations and/or mechanisms designed or transformed using techniques described herein provide explicit reclamation of storage using lock-free pointer operations. Transformations can be applied to lock-free algorithms and shared object implementations and preserve lock-freedom of such algorithms and implementations. As a result, existing and future lock-free algorithms and shared object implementations that depend on a garbage-collected execution environment can be exploited in environments that do not provide garbage collection. Furthermore, algorithms and shared object implementations that employ explicit reclamation of storage using lock-free pointer operations such as described herein may be employed in the implementation of a garbage collector itself.

## Background
CROSS-REFERENCE TO RELATED APPLICATION(S)
This application is a continuation-in-part of U.S. application Ser. No. 09/837,671, filed Apr. 18, 2001, entitled “LOCK FREE REFERENCE COUNTING,” which itself claims benefit under 35 U.S.C. §119(e) of U.S. Provisional Application No. 60/261,633. Application Ser. No. 09/837,671 is incorporated herein by reference.
In addition, this application is related to commonly-owned U.S. patent application Ser. No. 10/340,150, filed Jan. 10, 2003, entitled “SINGLE-WORD LOCK-FREE REFERENCE COUNTING,” and naming Moir, Luchangco and Herlihy as inventors, and to commonly-owned U.S. patent application Ser. No. 11/026,849, filed Dec. 30, 2004, entitled “PRACTICAL IMPLEMENTATION OF ARBITRARY-SIZED LL/SC VARIABLES,” and naming Moir, Doherty, Luchangco and Herlihy as inventors. Application Ser. No. 11/026,849 is also incorporated herein by reference.


BACKGROUND
The present invention relates generally to coordination amongst execution sequences in a multiprocessor, and more particularly, to techniques for coordinating access to shared data and pointer encodings.
Use (at runtime) of an automatic dynamic memory management facility, e.g., a garbage collector (GC), can greatly simplify the design of a sequential implementation of a data structure or software mechanism by largely relieving the programmer of the burden of determining when memory can (or should) be deallocated. Moreover, by assuming the existence of an automatic dynamic memory management facility or garbage collector, certain additional complexities of concurrent data structures and software can also be avoided. In particular, it is often possible to defer to the garbage collector the significant additional complexity of coordinating deallocation of memory with potential concurrent accesses thereto.
Furthermore, concurrent data structure implementations and/or software mechanisms for an execution environment that provides garbage collection can (in essence) benefit from a free solution to the so-called ABA problem. In general, the ABA problem arises when a data system fails to detect that a value changes (e.g., from A to B) and then changes back to its original value (i.e., A). For example, if a compare-and-swap-type operation (e.g., a CAS or DCAS operation) is about to operate on a pointer and the object to which it points is freed and then reallocated, then it is possible for the CAS or DCAS to succeed even though it should fail. In a proper implementation, this possibility should be prevented by ensuring that an object is not freed while an execution thread has pointers to it. Garbage collector implementations typically ensure such behavior, e.g., by stopping a thread and inspecting its registers and stack for pointers. However, in the absence of a garbage collector, responsibility for handling the ABA problem generally falls to the concurrent data structure implementation itself.
For these and other reasons, deferring complexity to a runtime garbage collection facility can be quite attractive. However, such a facility is not always available or practical. For example, many common programming and execution environments do not support garbage collection. Second, even those environments that do support garbage collection often employ excessive synchronization, such as locking and/or stop-the-world mechanisms, which impair scalability and may be impractical for certain applications. Worse still, some software systems (notably implementations of a garbage collector itself) simply cannot defer the complexity to a runtime garbage collection system. For example, concurrent shared object implementations that depend on the existence of a garbage collection facility are generally not suitable for use in the implementation of the garbage collector itself. Accordingly, for some software systems, concurrent data structures and mechanisms, direct solutions to the difficult problem of coordinating concurrent access to shared, storage are necessary or desirable.
The difficulty of achieving correct solutions should not be underestimated, particularly for dynamically-sizable shared data structures. Indeed, despite the fact that use of locks in concurrent programs gives rise to a host of problems including deadlock, starvation and intolerance to thread failure, many concurrent or cooperative software systems in use today employ lock-based techniques.
Significant research attention has been paid to “nonblocking” synchronization, i.e., synchronization that does not depend on locks. Unfortunately, both the design and verification of nonblocking algorithms are very challenging. Accordingly, much of the early work in this area has focused on what can be achieved in principle, yet has yielded relatively few practical results. In particular, work on nonblocking shared data structures has typically ignored the important issues of managing memory for dynamic-sized shared data structures. Indeed, much of the work that has been done before a few years ago is either incorrect (i.e., inoperative despite its surface appeal) or has serious drawbacks.
In view of the above, nonblocking structures and techniques are desired that would allow programmers to exploit the advantages of a garbage collected execution environment in the design of data structure implementations despite the absence of a garbage collection facility.
SUMMARY
Accordingly, we have developed a methodology for transforming garbage collection-dependent algorithms, shared object implementations and/or concurrent software mechanisms into a form that does not presume the existence of an independent, or execution environment provided, garbage collector. Algorithms, shared object implementations and/or mechanisms designed or transformed using techniques described herein provide explicit reclamation of storage using lock-free pointer operations. Transformations can be applied to lock-free algorithms and shared object implementations and preserve lock-freedom of such algorithms and implementations. As a result, existing and future lock-free algorithms and shared object implementations that depend on a garbage-collected execution environment can be exploited in environments that do not provide garbage collection. Furthermore, algorithms and shared object implementations that employ explicit reclamation of storage using lock-free pointer operations such as described herein may be employed in the implementation of a garbage collector itself.
While some realizations of the present invention include transformation techniques or facilities, others realizations include the lock-free implementations themselves (whether or not derived through such transformations). For example, some realizations include a shared object or data structure that employs lock-free pointer operations. Some realizations include multiprocessor systems and/or computer program products (e.g., computer readable storage media such as disks, tapes or other magnetic, optical or electronic storage media storing program instructions executable to realize the invention) incorporating explicit reclamation of storage using lock-free pointer operations. In some multiprocessor environments, algorithms and/or shared object implementations employed by operating system or execution environment facilities (including, without limitation, garbage collection or other automatic dynamic memory management facilities) may exploit the techniques described herein to explicitly reclaim storage.



BRIEF DESCRIPTION OF THE DRAWINGS
The present invention may be better understood, and its numerous objects, features, and advantages made apparent to those skilled in the art by referencing the accompanying drawings.
FIGS. 1A and 1B illustrate before and after states of a simple data structure in which reference counts are provided.
FIG. 2 depicts a shared memory multiprocessor configuration that serves as a useful illustrative environment for describing operation of some shared object implementations in accordance with some embodiments of the present invention.
FIG. 3 illustrates organization and functional relationships amongst elements of a reference count encoding in accordance with some embodiments of the present invention. The encoding distributes reference count contributions amongst certain elements of the encoding.
FIGS. 4 and 5 illustrate states of a data structure encoding in accordance with some embodiments of the present invention. FIG. 4 illustrates an initial state in which a shared object and a shared reference thereto are instantiated in shared memory. FIG. 5 illustrates a state (including a distributed representation of reference count state) after the shared reference is copied to a private variable.
FIGS. 6, 7A, 7B and 7C illustrate states of a data structure encoding in accordance with some embodiments of the present invention. FIG. 6 illustrates a state in which two shared pointers and a private pointer (copied from one of the shared pointers) all reference a shared object. FIG. 7A illustrates a state (including an updated reference count state) after one of the shared references is destroyed. FIG. 7B illustrates a state (including an updated reference count state) after the private reference is destroyed. FIG. 7C illustrates a state (including an updated reference count state) after the other one of the shared references is destroyed.
FIGS. 8 and 9 illustrate states of a data structure encoding in accordance with some embodiments of the present invention. FIG. 8 illustrates a state in which both a shared pointer and a private pointer have been destroyed. FIG. 9 illustrates a state in which all references to a shared object have been destroyed.



The use of the same reference symbols in different drawings indicates similar or identical items.
DESCRIPTION OF THE PREFERRED EMBODIMENT(S)
Our techniques are based generally on the notion of reference counting, which persons of skill in the art will recognize as one of the classical methods of managing storage reclamation. See generally, Jones and Lins, Garbage Collection: Algorithms for Automatic Dynamic Memory Management, John Wiley & Sons Ltd. (1996), pp. 19-25 (reviewing reference counting). However, our techniques use synchronization techniques, e.g., using compare-and-swap (CAS) operations, double compare-and-swap (DCAS) operations, load-linked/store-conditional (LL/SC) operation pairs, emulations of such operations, transactional memory facilities or the like, to maintain reference counts consistent with manipulations performed in the course of a given computation, by lock-free pointer operations. In a powerful exploitation of the developed techniques, we employ a strategy of distributing contributions to a “reference count,” rather than representing the complete count of references to a shared object as a single unitary encoding.
Synchronization techniques are employed to update certain reference count contributions for an object atomically with a check that a pointer to the object still exists. Synchronization techniques are further employed, in some situations, to atomically update multiple contributions to a reference count. Advantageously, we are able perform these updates using single-target synchronizations. Of course, more powerful (and typically more expensive) synchronizations may be employed; however, our techniques facilitate lightweight (e.g., low synchronization overhead) implementations and implementations suitable for computational environments in which only single-target synchronizations (e.g., a single-target CAS operation or LL/SC operation pair) are provided.
An important challenge that our solutions address is properly maintaining a reference count representation for an object to reflect the fact that a new pointer to the object has been created by reading the pointer from a shared memory location. Most other cases, e.g., copying a pointer, are tractable because we know that there is a pointer to the object that will survive at least until we update the object's reference count. Therefore, the primary difficulty arises because, after a thread reads a pointer to an object, but before it increments the object's reference count to reflect this fact, all other pointers to the object may be destroyed, causing its reference count to fall to zero, and the object to be deallocated. Incrementing the reference count of an object after it has been deallocated can have disastrous consequences, because the memory for that object may have since been reallocated and reused for a different purpose.
By weakening the typical reference counting implementation invariant that reference counts record the exact number of pointers to an object, we are able to separate the updates of reference counts from the updates of the pointers themselves. This allows us to support strong synchronization operations on pointers. In contrast, classical reference counting implementations for concurrent environments typically require the use of locks on all objects that might be shared between threads. See generally, Jones and Lins, pp. 200-202 (reviewing concurrent reference counting methods).
We have designed our methodology to preserve lock-freedom. That is, if a GC-dependent implementation is lock-free, then so too will be a GC-independent implementation derived using our methodology. In this regard, the assertion of lock-freedom may ignore certain operating system or execution environment provided facilities such as for creation and destruction of objects. For example, in many systems, malloc and free (or other similar facilities) are provided. Unfortunately, implementations of such facilities are often not lock-free, and therefore, strictly-speaking, implementations based thereon are not themselves lock-free. However, most production-quality malloc/free implementations do attempt to avoid contention for locks—for example, by maintaining separate allocation buffers for each thread—and therefore avoid most of the problems associated with locks. As a result, while some exploitations of the present invention build upon underlying facilities, which are truly lock-free, others need not. Accordingly, even concurrent shared object implementations for execution environments in which implementations of malloc, free or similar facilities are not, strictly speaking, lock-free derive substantial benefits from our techniques.
As used herein, an implementation of a concurrent data structure is said to be lock-free if it guarantees that in any execution, after a finite number of steps of one of its operations, some operation on the data structure completes. Of course, it is possible that the operating system, execution environment or garbage collector might prevent threads from executing any instructions, in which case, no operations will be completed on the data structure. However, this does not mean that the concurrent data structure implementation is not lock-free. Thus, it is not contradictory to talk about a lock-free GC-dependent concurrent data structure implementation, even in environments in which a garbage collector, operating system or execution environment facility is blocking. Lock-free programming is increasingly important for overcoming the problems associated with locking, including performance bottlenecks, susceptibility to delays and failures, design complications, and, in real-time systems, priority inversion.
As noted above, our methodology is based on the well-known garbage collection technique of reference counting. We refer to our methodology as Lock-Free Reference Counting. In some realizations, each object includes or has an associated count of the number of pointers that reference it. Such objects are freed if and only if this count reaches zero. Persons of ordinary skill in the art will recognize that one reason that typical tracing-type garbage collectors “stop the world” (e.g., by suspending all mutator threads) is that some of these pointers can reside in registers and/or stacks and that discovery of these pointers may require operating system support. As a result, garbage collection is difficult to perform concurrently with execution of mutator threads. Accordingly, one of our goals is to enable programmers of multiprocessor systems to take advantage of the simplicity afforded by the existence of automatic dynamic memory management, without having to use locks or stop-the-world techniques.
We have previously described lock-free solutions to some of the above described problems. See e.g., commonly-owned U.S. application Ser. No. 09/837,671, filed Apr. 18, 2001, entitled “LOCK FREE REFERENCE COUNTING,” and commonly-owned U.S. patent application Ser. No. 10/340,150, filed Jan. 10, 2003, entitled “SINGLE-WORD LOCK-FREE REFERENCE COUNTING.” For at least some environments and exploitations, the present disclosure improves upon lock-free pointer operations previously disclosed, while building upon the methodologies and techniques previously disclosed. Accordingly, the present disclosure adds to the growing suite of lock-free pointer operation implementations that may be employed consistent with the teachings of our disclosure(s).
Illustrative Problem
As an initial proposition, to maintain accurate reference counts, we would like to, in effect, atomically create a pointer to an object and increment that object's reference count, and to, in effect, atomically destroy a pointer to an object and decrement its reference count. FIGS. 1A and 1B illustrate simple unitary encodings of reference counts and appropriate reference updates when a pointer value in field 111 of object 101 is changed to reference object 103 rather than object 102. FIG. 1A illustrates the pre-change states of object 101, 102 and 103, while FIG. 1B illustrates the post-change states. Reference count fields 112 and 113 of the respective objects are decremented and incremented accordingly. In this way, each object's reference count always accurately reflects the number of pointers to it. By freeing an object once (and only once) its reference count becomes zero, it is possible to ensure that objects are not freed prematurely, but that they are eventually freed when no pointers to the object remain.
A difficulty that arises in the above-described approach is the apparent need to atomically modify three separate memory locations, e.g., the pointer store and the reference count fields of the objects to which the store points both before and after update. Unfortunately, even a dual-target synchronization operation such as a double compare-and-swap (DCAS) operation is generally not strong enough to atomically update the three separate memory locations. For example, referring to the illustration of FIGS. 1A and 1B, if a pointer value in shared memory (e.g., that stored in field 111 of object 101) points to object 102, and we change the pointer value to instead point to another object 103, then we would have to atomically (i) modify the pointer (i.e., the contents of field 111), (ii) increment reference count 113 of object 103 and (iii) decrement reference count 112 of object 102.
However, it turns out that a weaker requirement on the reference counts suffices, and that this requirement can be achieved using a DCAS operation or similar facility as described in U.S. application Ser. No. 09/837,671, or using single-target synchronization as described in U.S. patent application Ser. No. 10/340,150 or herein. This weakening is based in part on the insight that reference counts do not always need to be accurate. Instead, it is sufficient that if the number of pointers to an object is non-zero, then so too is its reference count and that if the number of pointers is zero, then the reference count eventually becomes zero. These two requirements respectively guarantee that an object is never freed prematurely, and that the reference count of an object that has no pointers to it eventually becomes zero, so that it can be freed. Furthermore, based on the above insight, it is safe for a thread to increment an object's reference count before creating a new pointer to it, provided that the thread eventually either creates the pointer or, if not, decrements the reference count to compensate for the previous increment.
Unfortunately, an important hazard tends to complicate solutions. In particular, it is important to observe that when we load a pointer from a shared memory location, we need to increment the reference count of the object to which the loaded value points. If we can access this reference count only with a single-target operation, then there is a risk that the object will be freed before we increment the reference count, and that the subsequent attempt to increment the reference count will corrupt memory that has been freed, and potentially reallocated for another purpose. U.S. application Ser. No. 09/837,671 discloses solutions based on lock-free pointer operations that employ a DCAS operation to increment an object's reference count while atomically ensuring that a pointer to the object still exists. U.S. patent application Ser. No. 10/340,150 discloses additional solutions that employ lock-free pointer operations that use single-target synchronization techniques to delay deallocation of an object until we have first checked that no process (or thread) will access the object. This disclosure adds still further solutions based on lock-free pointer operation techniques that employ a strategy of distributing contributions to a “reference count,” rather than representing the complete count of references to a shared object as a single unitary encoding.
Lock-Free Reference Counting
Some lock-free reference counting (LFRC) implementations in accordance with the present invention provide a set of pointer operations that mediate access and manipulation of pointers consistent with the goals described above. For example, an LFRC implementation may provide a set of operations that support loading, storing, copying, and destroying pointers. For many of the concurrent shared object implementations of interest, additional operations may be provided. For example, to support concurrent shared object implementations in which compare-and-swap (CAS) constructs are employed to mediate concurrent access to the shared object, LFRC pointer operations that provide CAS semantics may also be provided.
The description that follows focuses on implementations, techniques and methodologies that build upon an illustrative set of pointer operations by which load, store, copy, destroy and CAS operations on pointers are supported. However, the particular set, while generally sufficient to support a wide range of concurrent data structure implementations, is merely illustrative. Based on the description herein, persons of ordinary skill in the art will appreciate implementations of suitable pointer operation sets in which access and manipulation of pointers is performed consistent with the goals described above. For example, some useful additional pointer operations include operations to facilitate passing pointers by value and operations that combine allocation and pointer initialization functions. Suitable pointer operation sets may include versions of other synchronization primitives, such as the load-linked (LL) and store-conditional (SC) synchronization primitives.
We present a methodology for transforming any garbage-collection-dependent concurrent data structure implementation (lock-free or otherwise) that satisfies the two criteria below into an equivalent implementation that does not depend on garbage collection.

    
    
        1. LFRC Compliance The implementation does not access or manipulate pointers other than through a set of pointer operations that maintain and coordinate updates to reference count states such as described herein. For example, compliance with such a criterion generally precludes the use of pointer arithmetic, unless the implementation thereof enforces the criterion. For example, in some implementations, arithmetic operations on pointers could be overloaded with compliant versions of the arithmetic operations. In an illustrative realization described below, an implementation of a concurrent shared object accesses and manipulates pointers only through a set of functions, procedures or methods that ensure compliance. Although specific sets of pointer operations may vary based on application or exploitation, we illustrate (below) using a set that implements load, store, copy, destroy and CAS operations.
        2. Cycle-Free Garbage There are no pointer cycles in garbage. Note that, cycles may exist in the concurrent data structure, but not amongst objects that have been removed from the data structure, and which should be freed.
    
    


The transformation preserves lock-freedom. In particular, if the original implementation is lock-free, so too is the garbage-collection-independent algorithm produced by applying our methodology.
LFRC Operations—An Illustrative Set
Subject to the foregoing, an illustrative set of LFRC pointer operations is now described. As stated above, we assume that pointers in a data structure implementation under consideration are accessed only by means of LFRC pointer operations.

    
    
        1. RCL_Load (A,p)—A is a pointer to shared memory that contains a pointer, and p is a pointer to a local pointer variable. The effect is to load the value from the location pointed to by A into the variable pointed to by p.
        2. RCL_Store (A,v)—A is a pointer to shared memory that contains a pointer, and v is a pointer value to be stored in this location.
        3. RCL_Copy (p,v)—p is a pointer to a local pointer variable and v is a pointer value to be copied to the variable pointed to by p.
        4. RCL_Destroy (v)—v is the value of a local pointer variable that is about to be destroyed.
        5. RCL_CAS (A, old, new)—A is a pointer to shared memory that contains a pointer, and old and new are pointer values. The effect is to atomically compare the contents of the location pointed to by A with old and to change these contents to new and return true if the comparison succeeds; if it fails, then the contents of the location pointed to by A are left unchanged, and RCL_CAS returns false.

Illustrative Shared-Memory Multiprocessing Environment and Synchronizations

    
    


FIG. 2 depicts a shared memory multiprocessor configuration in which the illustrated set of LFRC pointer operations may be employed. In particular, FIG. 2 depicts a pair of processors 211 and 212 that access storage 240. Storage 240 includes a shared storage portion 230 and local storage portions 221 and 222, respectively accessible by execution threads executing on processors 211 and 212. In general, the multiprocessor configuration is illustrative of a wide variety of physical implementations, including implementations in which the illustrated shared and local storage portions correspond to one or more underlying physical structures (e.g., memory, register or other storage), which may be shared, distributed or partially shared and partially distributed.
Accordingly, the illustration of FIG. 2 is meant to exemplify an architectural view of a multiprocessor configuration from the perspective of execution threads, rather than any particular physical implementation. Indeed, in some realizations, data structures encoded in shared storage portion 230 (or portions thereof) and local storage (e.g., portion 221 and/or 222) may reside in or on the same physical structures. Similarly, shared storage portion 230 need not correspond to a single physical structure. Instead, shared storage portion 230 may correspond to a collection of sub-portions each associated with a processor, wherein the multiprocessor configuration provides communication mechanisms (e.g., message passing facilities, bus protocols, etc.) to architecturally present the collection of sub-portions as shared storage. Furthermore, local storage portions 221 and 222 may correspond to one or more underlying physical structures including addressable memory, register, stack or other storage that are architecturally presented as local to a corresponding processor. Persons of ordinary skill in the art will appreciate a wide variety of suitable physical implementations whereby an architectural abstraction of shared memory is provided. Realizations in accordance with the present invention may employ any such suitable physical implementation.
In view of the foregoing and without limitation on the range of underlying physical implementation of the shared memory abstraction, LFRC pointer operations may be better understood as follows. Shared pointer A is encoded in a shared memory location 231 and references an object 232 in shared memory. One or more pointers such as shared pointer A is (are) employed as operands of the RCL_Load, RCL_Store and RCL_CAS operations described herein. Pointer p1 is encoded in local storage 234 and references an object (e.g., object 232) in shared memory. Pointer p2 is encoded in local storage 235 and also references object 232. In this regard, FIG. 2 illustrates a state, *p1==*A && *p2==*A, consistent with successful completion of load-type operations (e.g., RCL_Load pointer operations) that bring copies of pointer value A into local storage of two threads of a multithreaded computation. The illustrated state is, of course, also consistent with successful completion of other operations including store-type operations (e.g., RCL_Store and RCL_CAS pointer operations).
In the illustration of FIG. 2, a reference count state for object 232 includes at least three references corresponding to pointers A, p1 and p2. Maintaining and coordinating updates to such a reference count state in correspondence with operations on shared storage 232 and local storage 234 and 235 is an important challenge. In the description that follows, we detail a technique whereby contributions to a reference count state are distributed among certain software objects in such a way that maintenance and coordination of updates can be managed using single-target synchronization operations, such as CAS operations, or LL and SC operation pairs.
We describe in detail below implementations based on CAS operations; however, based on that description, persons of ordinary skill in the art will appreciate suitable variations for other synchronization constructs including or LL/SC constructs or emulations. As typically employed, a CAS operation, such as illustrated below, takes the address of a memory location, an expected value, and a new value.















bool CAS(a, e, n) {



 atomically {



  if (*a == e) {



   *a = n;



   return true;



  } else



   return false;



 }



}










If the location contains the expected value, then the CAS atomically stores the new value into the location and returns true. Otherwise, the contents of the location remain unchanged, and the CAS returns false. We say that the CAS succeeds if it returns true, and that it fails if it returns false.
An alternative synchronization construct involves LL and SC operations used in pairs. An SC operation is matched with the preceding LL operation by the same thread to the same variable; there must be such an LL operation for each SC operation, and no LL operation may match more than one SC operation. LL loads the value of a location, and SC conditionally stores a value to a location, succeeding (returning true) if and only if no other stores to the location have occurred since the matching LL. Note that the LL/SC semantics described above is the ideal semantics. Hardware LL/SC implementations are usually weaker, and in particular, allow SC to fail even in the absence of an intervening store.
Additional LFRC Pointer Operations
In our experience, the operations presented here are sufficient for many concurrent shared object implementations, but can result in somewhat non-transparent code. Accordingly, we have also implemented some extensions that allow more elegant programming and handle issues such as the pointer created by passing a pointer by value transparently. For example, the following variant operations may also be provided, if desired:

    
    
        1. p=RCL_Load2 (A)—A is a pointer to shared memory that contains a pointer, and p is a local pointer variable, where p is known not to contain a pointer (e.g., it has just been declared) and ordinary reference count state updates for an overwritten pointer may be omitted. The effect is to load the value from the location pointed to by A into p.
        2. RCL_StoreAlloc (A, v)—A is a pointer to shared memory that contains a pointer, and v is a pointer value that will not be used (or destroyed) again. Accordingly, there is no need to update a reference count state corresponding to v. This variation is useful when we want to invoke an allocation routine directly as the second parameter, e.g., as RCL_StoreAlloc(&X,allocate_structure( )).
        3. RCL_Pass (p) p is a pointer value to be passed by value and for which a reference count state should be updated. This variation is useful when we want to pass p to a routine, e.g., as Example ( , , . . . , RCL_Pass (p)).
    
    


Based on the description herein, persons of ordinary skill in the art will appreciate variations of the described implementations, which may employ these and other extensions and/or variations on a set of supported pointer operations.
LFRC Methodology
Building on the previously described illustrative set of pointer operations, we describe now steps of a methodology for transforming a GC-dependent implementation into a GC-independent implementation. In general, these steps (with the possible exception of step 4) can be automated using facilities of an object-oriented language such as C++. Based on the description herein, persons of ordinary skill in the art will appreciate a variety of facilities that could be employed. See e.g., Detlefs, Garbage Collection and Run-Time Typing as a C++ Library, in Proceedings of the 1992 Usenix C++ Conference, pp. 37-56, 1992 (describing a suitable “smart pointer” technique). Nonetheless, presenting these steps explicitly makes our presentation clearer, and serves as a roadmap for exploitation of our methodology in non-object-oriented languages as well. Accordingly, one suitable transformation is as follows:

    
    
        1. Add reference count contributions for objects: Associate a pair of reference count contributions with each object used by the implementation. For example, add a status field, shown as 311 in FIG. 3, (including a reference count refCount 311.1 and an exit count exitCount 311.2) to each object type used by the implementation. In exploitations that employ such fields as described more completely below, an object can be freed only when its reference count and its exit count are both zero. Status should be set to {1, 0} in a newly-created object. Of course, in an object-oriented language such as C++, initialization may be achieved though object constructors.
        2. Add reference count contributions for shared pointers: Associate a reference count contribution with each shared variable that contains a pointer to an object. For example, add a hold count holdCount to each shared reference used by the implementation. Such a hold count tracks private references copied from the shared reference. Upon destruction of given shared pointer, the hold count associated therewith is transferred to the object referenced by the pointer. In exploitations that employ status fields such as described above, hold count can be transferred to the exitCount associated with the object referenced by the to-be-destroyed shared pointer. Hold count should be set to 0 in a newly-created shared pointer.
        3. Provide a Destroy_object(v) function: Once an object's status (e.g., <refCount, exitCount>) indicates that no references to the object remain (e.g., a reference count state coded as <0, 0>), it is appropriate to free storage associated with the object. In some realizations, we provide object-type-specific implementations of the Destroy_object( ) function. We illustrate such a function only because it is the most convenient and language-independent way to iterate over all pointers in an object. However, persons of ordinary skill in the art will appreciate that other implementations (particularly object-oriented implementations) may provide similar facility using language-specific constructs, e.g., an object destructor method.
        
            In any case, an implementation of a destroy_object( ) function or method provides a mechanism to destroy each shared object identifying pointer encoded in the to-be-destroyed object, triggering atomic decrement of an exit count exitCount associated with each such identified shared object.
            After all shared object pointers in the object whose reference count state is <0, 0> have been destroyed, that object can be freed. Some program sequences will trigger a recursive chaining of object destructions. For example, in an illustrative implementation described below, we provide a function (UpdateStatus) that is employed by various lock-free pointer operations of the implementation for the atomic decrement of an exitCount field. The UpdateStatus function, in turn, invokes Destroy_object if <refCount,exitCount> reaches <0, 0>. Destroy_object, in turn, traverses the to-be-destroyed object and employs lock-free pointer operations to destroy certain pointers included therein and to correspondingly update <refCount, exitCount> state using the UpdateStatus function.
        
        
        4. Ensure no garbage cycles: Ensure that the implementation does not result in referencing cycles in or among garbage objects. This step may be non-trivial or even impossible for some concurrent data structure implementations. If this property cannot be achieved for a particular data structure, then it is not a candidate for applying our methodology. Note that, as illustrated below, the concurrent data structure may include cycles. However, storage no longer reachable should not.
        5. Replace pointer operations: Replace each pointer operation with its LFRC pointer operation counterpart. For example, if A0 and A1 are pointers to shared pointer variables, and x, x0, x1, old and new are pointer variables, then replacements may be made as follows:
    
    
















Replaced Pointer Operation
LFRC Pointer Operation









x0 = *A0;
RCL_Load(A0,&x0);



*A0 = x0;
RCL_Store(A0,x0);



x0 = x1;
RCL_Copy(&x0,x1);



CAS(A0,old,new)
RCL_CAS(A0,old,new)










    
    
        
        
            Note that the table does not contain an entry for replacing an assignment of one shared pointer value to another, for example *A0=*A1. Such assignments are not atomic. Instead, the location pointed to by A1 is read into a register in one instruction, and the contents of the register are stored into the location pointed to by A0 in a separate instruction. This approach should be reflected explicitly in a transformed implementation, e.g., with the following code:
        
        
    
    

















{



 ObjectType *x = NULL;



 RCL_Load(A1,&x);



 RCL_Store(A0,x);



 RCL_Destroy(x);



}










    
    
        
        
            or its substantial equivalent, whether included directly or using a “wrapper” function.
        
        
        6. Management of local pointer variables: Finally, whenever a thread loses a pointer (e.g., when a function that has local pointer variables returns, so its local variables go out of scope), it first calls RCL_Destroy( ) with this pointer. In addition, pointer variables are initialized to NULL before being used with any of the LFRC operations. Thus, pointers in a newly-allocated object should be initialized to NULL before the object is made visible to other threads. It is also important to explicitly remove pointers contained in a statically allocated object before destroying that object.

Implementation of LFRC Pointer Operations

    
    


In the description that follows, we describe illustrative implementations of LFRC pointer operations and explain their behavior. For many practical exploitations, the described implementations represent an improvement on techniques described in commonly-owned, co-pending U.S. application Ser. Nos. 09/837,671 and 10/340,150. As a result, use of LFRC pointer operations now detailed may provide significant advantages for some concurrent software and shared-object implementations, computational environments, etc. For some exploitations, the LFRC pointer operations now detailed represent yet another suitable implementation of LFRC pointer operations for possible use in conjunction with the LFRC methodologies described in commonly-owned, co-pending U.S. application Ser. Nos. 09/837,671 and 10/340,150 as well as herein.
Using the described techniques, we can ensure that there are no memory leaks and that memory is not freed prematurely. The LFRC pointer operations maintain a reference count state for each object, which is represented as a collection of counts some of which are encoded in association with the object itself and some of which are encoded in association with shared pointers that reference the object. Together, the reference count contributions reflect the total number of references to the object. We provide mechanisms for orderly update, transfer and interpretation and eventual consolidation of this distributed representation of reference count. When the reference count state reaches a coding for zero, there are no more pointers to the object and the object can be freed.
Aspects of our techniques will be better understood in the context of certain illustrative data structure implementations and code. Since previously disclosed implementations of lock free reference counting (LFRC) pointer operations have been described using an LFRC moniker or SLFRC (for implementations that employed single-target synchronization), we use a new acronym, RCL (for Reference Counting Light) as a naming convention for structures, operations and functions of another coherent implementation of our LFRC techniques described in greater detail below.
In an illustrative RCL implementation, we envision shared objects and shared pointers each associated with a partial representation of reference count state. For example, a shared object encoding for information of type T, may be represented as an RCL_Obj object that includes storage for a refCount and an exitCount together with storage for T. In such an implementation, a refCount field is used to encode one contribution to reference count state, namely the count of shared references to the shared object (i.e., to the RCL_Obj object or to T itself, depending on the pointer convention employed). In general, type T may be any defined (or definable) type (e.g., a simple int type, a multi-element node of a linked-list, etc.). Thus, the following type definitions provide a useful illustrative context:















typedef struct status_s {



 int refCount;



 int exitCount;



} RCL_Status;



typedef struct RCL_Obj_s {



 RCL_Status status;



 T val;



} RCL_Obj;










In addition to the refCount field, an exitCount field is used (in the illustrated coding) to facilitate tracking of private references to the shared object, as described more completely below. The illustrated coding of RCL_Status (which includes the refCount and exitCount fields) is atomically updatable using a single-target synchronization (e.g., using a 64-bit CAS operation spanning two 32-bit integer codings of refCount and exitCount fields). While the illustrated RCL_Obj type conveniently encodes RCL_Status in conjunction with storage for information of type T, more generally, an implementation need only associate the atomically-updatable RCL_Status coding with the shared object.

Shared references to the shared object are encoded in a way that associates the shared pointer coding with yet another contribution to reference count state. In an illustrative realization, shown as 312 in FIG. 3, an integer holdCount 312.1 is encoded together with a shared pointer to an RCL_Obj shared object as follows:















typedef struct RCL_Ref_s {



 RCL_Obj *ref;



 int holdCount;



} RCL_Ref;










In this way, a single-target synchronization, e.g., a 64-bit CAS operation, can atomically access both the shared pointer ref and holdcount. As described below, our techniques are not limited to CAS-based implementations, or for that matter to implementations in which a single-target synchronization operates on storage of sufficient width to encode both a shared pointer and a holdcount. Nonetheless, CAS-based access to the particular RCL_Ref coding described above provides a useful illustrative context for our techniques.

Turning now to FIG. 3, we illustrate a shared object 332 encoded as previously described and instantiated in shared memory 330. Shared object 332 is referenced by a shared pointer 331 encoded as previously described and which is also instantiated in shared memory. In the illustration, a single private (i.e., non-shared) pointer 334 also references shared object 332.
An interesting part of the illustrated approach is that we count only shared references to a shared object such as shared object 332 in its refCount field (311.1), and use a different technique to keep track of private references. The idea is that when a new private reference (e.g., 334) to an object is created by reading from a shared reference (e.g., 331), rather than incrementing the object's reference count field, we instead increment the holdCount (e.g., 312.1) associated with the shared reference from which it is read. This solves the problem explained above, because we no longer need to access shared object 332 to reflect the creation of such private references.
Once a shared pointer to shared object 332, e.g., that stored in a shared reference 331, is destroyed (for example by storing a reference to a different object into that shared variable), the holdCount (e.g., 312.1) associated with the shared reference to shared object 332 is “transferred” to the exitCount of shared object 332 as part of an atomic update that also decrements the refCount of shared object 332 to reflect the destruction of the shared reference thereto.
FIGS. 4-9 illustrate as series of reference count states that correspond to operations on shared objects and pointers. In FIG. 4, a shared reference 431, encoded as an RCL_ref, includes a pointer to shared object 432, which is encoded as an RCL_Obj object. The shared reference 431 and shared object 432 are instantiated in shared memory 430. That pointer has not been copied from shared reference 431 to a private variable. Therefore, holdCount is properly zero. The refCount encoding in shared object 432 properly tracks the single shared reference thereto.
FIG. 5 illustrates results of an LFRC pointer operation that copies the pointer encoded in shared reference 431 to a private variable 534. The pointer coded in private variable 534 now references shared object 432 but that additional reference is tracked, not by shared object 432's refCount, but rather by the holdCount associated with the shared reference 431. Such an update may be performed using an RCL_Load operation as described below.
FIG. 6 depicts an illustrative state in which two shared references 631 and 633 each encode pointers to shared object 632. Shared references 631 and 633 and shared object 632 all reside in shared memory 630. An additional pointer (private reference 634), which has been copied from shared reference 633, resides in private (i.e., non-shared) storage. A refCount (of 2) for shared object 632 indicates that two shared pointers currently reference shared object 632. In addition, a holdCount (of 1) for shared reference 633 indicates that one private reference has been copied from shared reference 633 and is therefore accounted for in a reference count state for shared object 632. In short, the reference count state for shared object 632, which is represented in a distributed form, accounts for all three pointers to shared object 632.
FIGS. 7A, 7B and 7C depict updates to the reference count state illustrated in FIG. 6 for shared object 632. The illustrated updates correspond to respective operations that result in the destruction of shared reference 631 (FIG. 7A), of private reference 634 (FIG. 7B) or of shared reference 633 (FIG. 7C). Turning first to FIG. 7A, we illustrate a reference count state resulting after destruction of shared reference 631 to shared object 632. In general, a shared pointer may be destroyed by being overwritten by another pointer variable or by freeing the storage in which it resides. In either case, destruction of the shared pointer to shared object 632 triggers a reduction in refCount. Since no private copies of shared reference 631 had been made (holdCount=0, see FIG. 6), no change in exitCount is apparent.
Similarly with respect to FIG. 7B, we illustrate a reference count state resulting after destruction of private reference 634 to shared object 632. For clarity, we assume that the reference count state existing just prior to destruction of private reference 634 is consistent with that illustrated in FIG. 6. As before, destruction of a pointer may result from being overwritten by another pointer variable or by freeing the storage in which the pointer resides. In either case, destruction of the private pointer to shared object 632 triggers a reduction in exitCount for shared object 632. In the illustrated case, exitCount=−1. In effect, the reference count state for shared object 632, which is represented in a distributed form, accounts for both of the remaining pointers to shared object 632 (holdCount of shared reference 633 and exitCount of shared object 632 include offsetting components).
Turning to FIG. 7C, we illustrate a reference count state resulting after destruction of shared reference 633 to shared object 632. For clarity, we again assume that the reference count state existing just prior to destruction of shared reference 633 is consistent with that illustrated in FIG. 6. Destruction of the shared pointer to shared object 632 triggers a reduction in refCount and a transfer of the holdCount from shared reference 633. As a result, the reference count state for shared object 632, which is represented in a distributed form, accounts for both of the remaining pointers to shared object 632.
Continuing from the reference count state illustrated in FIG. 7C, we illustrate reference count states along a program trajectory in which remaining references to shared object 632 are destroyed. In FIG. 8, we illustrate a reference count state resulting after destruction of private reference 634. The exitCount of shared object 632 is decremented and resulting reference count state properly reflects a single remaining reference to shared object 632. Finally in FIG. 9, we illustrate a reference count state resulting after destruction of shared reference 631. The <refCount, exitCount> state for shared object 632, <0, 0> indicates that no references to shared object 632 remain and shared object 632 may be freed.
Illustrative RCL Set of Lock-Free Pointer Operations
We now describe a set of lock-free pointer operations based on our RCL techniques. As a set, these RCL operations are generally interchangeable with the LFRC and SLFRC operation sets previously described, but implement the distributed reference count state techniques described above and advantageously allow for implementations that build upon synchronization mechanisms no stronger than that provided by single-target synchronization operations such as CAS or LL/SC operation pairs. For clarity of description, but without loss of generality, we detail an implementation based on CAS operations. Other implementations will be understood by persons of ordinary skill in the art based on the description herein.
We begin with an implementation of RCL_Load as follows:













1
void RCL_Load(RCL_Ref *A, RCL_Obj **dest) {


2
 RCL_Ref a;


3
 RCL_Obj *olddest = *dest;


4
 do {


5
  a = *A;


6
  if (a.ref == null) {


7
   *dest = null;


8
   break;


9
  }


10
 } while(!CAS(A, a, <a.ref, a.holdCount+1>));


11
 *dest=a.ref;


12
 RCL_Destroy(olddest);


13
}









where RCL_Load accepts two parameters, a pointer to a structure A that includes a shared pointer field (ref), and a pointer dest to a local pointer variable of the calling thread. The semantics of the RCL_Load operation is to load the shared pointer value in A.ref into the private variable pointed to by dest. This has the effect of destroying one pointer (the previous value in the location pointed to by dest) and creating another (the new value of *dest). Thus, we may potentially need to update two reference count states.
The RCL_Load operation begins by recording the previous value of the pointer (line 3), so that it can be properly destroyed later. Next, the RCL_Load operation loads a pointer to A and, if the shared pointer field (a.ref) is non-NULL, increments the holdCount field of A to indicate that a private reference copy has been created. We use a CAS operation (at line 10) that covers both the ref and holdCount fields of A to perform the increment. In this way, we ensure that ref has not been updated (e.g., by another thread) and synchronize the increment with any concurrent operation. If the CAS fails, we reload and retry. If the CAS succeeds, we update (line 11) the private variable pointed to by dest and destroy (line 12) the previous value (olddest).
In our implementation, destruction of a pointer to shared object implies proper handling of reference count state for the shared object referenced by olddest. Therefore, unless olddest=null, there is additional work to be done. An illustrative implementation of the RCL_Destroy operation builds upon a more general UpdateStatus function that we employ to atomically update both refCount and exitCount fields of an RCL_Obj structure. For an RCL_Destroy operation, a current refcount remains unchanged and exitCount is decremented.
The RCL_Destroy operation and UpdateStatus function will be understood as follows:













1
void RCL_Destroy(RCL_Obj *p) {


2
 UpdateStatus(p,0,−1);


3
}


4
void UpdateStatus(RCL_Obj *a, int rcDelta, int ecDelta) {


5
 Status s, s_new;


6
 if (a==null) return;


7
 do {


8
  s = a->status;


9
  s_new = <s.refCount+rcDelta,s.exitCount+ecDelta>;


10
 } while (!CAS(a->Status,s,s_new));


11
 if (s_new=<0,0>)


12
  Destroy_object(a);


13
}









where UpdateStatus employs a CAS operation (at line 10) to synchronize an atomic update of refCount and exitCount fields of the RCL_Obj structure with any concurrent updates. In the particular case of RCL_Destroy operation use of the UpdateStatus function, rcDelta=0 and ecDelta=−1. If the CAS fails, we reload current contents of refCount and exitCount fields and retry. If the CAS succeeds, we check the status information written by the successful CAS for an indication (<refCount,exitCount>==<0, 0>) that no references (other than a) to shared object *a remain. If no such references remain, we free storage identified by a using the Destroy_object function.
















1  void Destroy_object(RCL_Obj *p) {



2   for each RCL_Ref field f in p do



3    RCL_Store(&p->f,null);



4   free(p);



5  }










As described above, we may employ an object-type-specific implementation of the Destroy_object( ) function or a more general object destructor method in some implementations. In either case, the Destroy_object( ) function (or similar destructor method) operates to destroy references (e.g., RCL_Ref type shared references) to shared objects, which themselves appear in the shared object (e.g., the RCL_Obj type shared object, p) being destroyed by the Destroy_object( ) function. To destroy the constituent shared references, we employ an LFRC pointer operation, RCL_Store, to store a null value to each constituent shared reference field and to properly handle reference count state updates for shared objects referenced. Operation of RCL_Store (which in turn employs the UpdateStatus function and may, in turn, trigger additional object destructions) is described in greater detail below. Once constituent shared pointers have been destroyed, shared object p is freed (at line 4).
An RCL_Store operation can be implemented as follows:













1
void RCL_Store(RCL_Ref *A, RCL_Obj *v) {


2
 RCL_Ref a;


3
 if (v!=null)


4
  UpdateStatus(v,1,0);


5
 while (1) {


6
  a = *A;


7
  if (CAS(A, a, <v,0>)) {


8
   UpdateStatus(a.ref,−1,a.holdCount);


9
   return;


10
  }


11
 }


12
}









where the RCL_Store operation accepts two parameters, a pointer to a structure A that includes a shared pointer field (ref), and a pointer value v to be stored in the shared pointer field (ref). Since v is itself a pointer to a shared object, we again have two reference count states with which to be concerned, namely that for the shared object referenced by v and that for the shared object referenced by the about-to-be-overwritten shared reference, A.ref.
If v is non-null, we update (at line 4) the reference count state for the shared object referenced by v using the UpdateStatus function. In particular, we increment refCount for the shared object referenced by v to reflect an additional shared reference that is about to be created. The exitcount for the shared object referenced by v remains unchanged. As before, the UpdateStatus function employs a CAS operation to update <refcount,exitCount> state.
The RCL_Store operation next saves a copy (at line 6), a, of about-to-be-overwritten shared reference A, and attempts to update A (using the CAS at line 7) with a copy of shared pointer value v. Initially, holdCount is zero for new shared reference. If the CAS fails, we reload and retry.
If the CAS succeeds, we update (at line 8) reference count state for the shared object previously identified by A.ref. Consistent with the approach described above, we update the object previously identified by A.ref (i.e., the object now identified by temporary variable a.ref) to decrement its associated refCount and to transfer any holdCount previously associated with A (and still saved as temporary variable a.holdCount). The decrement and transfer is performed atomically using the UpdateStatus function. As before, the UpdateStatus function employs a CAS operation to update <refCount,exitCount> state. Also as before, the update may result in an indication (<refCount,exitCount>==<0, 0>) that no references (other than a) remain to the shared object previously identified by A. If no such references remain, we destroy object *a using the Destroy_object function.
Finally, an RCL_CAS operation can be implemented as follows:













1
bool RCL_CAS(RCL_Ref *A, RCL_Obj *old, RCL_Obj *new) {


2
 RCL_ref a;


3
 if (old.ref==new.ref)


4
  return (A->ref == old.ref);  // Just an optimization


5
 UpdateStatus(new,1,0);


6
 do {


7
  a = *A;


8
  if (a.ref != old) {


9
   UpdateStatus(new,−1,0);


10
   return false;


11
  }


12
 } while (!CAS(A,a,<new,0>));


13
 UpdateStatus(a.ref,−1,a.holdCount);


14
}









where the RCL_CAS operation accepts three parameters, corresponding to the CAS parameters described earlier. The illustrated implementation of the RCL_CAS operation is similar to that of the RCL_Store operation in that it updates (at line 5) reference count state for the shared object identified by new before installing a new shared reference (using the CAS at line 12) into the target (shared reference A) of the RCL_CAS operation. As a result, reference count state for the shared object identified by new is artificially high (at least temporarily). However, the RCL_CAS operation differs from the RCL_Store operation in that it does not insist on eventually updating shared reference A. If the old value check at line 8 fails, then RCL_CAS calls UpdateStatus (at line 9) to reverse the previous increment of refCount for the shared object identified by new.
Assuming that the old value check (at line 8) succeeds, we employ a CAS (at line 12) to attempt an update of shared reference A. If the CAS fails, we reload, perform the old value check again, and retry.
If the CAS succeeds, we update reference count state for the shared object previously identified by A.ref. As before, we update the object previously identified by A.ref (i.e., the object now identified by temporary variable a.ref) to decrement its associated refCount and to transfer any holdCount previously associated with A (and still saved as temporary variable a.holdCount). The decrement and transfer is performed atomically using the UpdateStatus function at line 13. As before, the UpdateStatus function itself employs a CAS operation to update <refCount,exitCount> state. Also as before, the update may result in an indication (<refCount,exitCount>==<0, 0>) that no references (other than a) remain to the shared object previously identified by A. If no such references remain, we destroy object *a using the Destroy_object function.
While the above-described RCL_Load, RCL_Store and RCL_CAS operations (together with UpdateStatus and Destroy_object functionality) are sufficient for the implementation (or transformation) of typical concurrent shared objects, other implementations and other concurrent shared objects may employ alternative or additional LFRC pointer operations. For example, in some implementations, an RCL_Copy operation may be useful. One implementation is as follows:















1  void RCL_Copy(RCL_Obj **v, RCL_Obj *w) {



2   RCL_Obj *old = *v;



3   UpdateStatus(w,0,1);



4   *v = w;



5   RCL_Destroy(old);



6  }










where the RCL_Copy operation accepts two parameters, a pointer v to a private pointer variable that references a shared object, and a value w of a private pointer variable that references a shared object. The semantics of this operation is to assign the value w to the variable pointed to by v. This will create a new private pointer to the shared object referenced by w (if w is not NULL), so RCL_Copy updates (at line 3) the reference count of that shared object using the UpdateStatus function. RCL_Copy then assigns the value w to the pointer variable pointed to by v. Finally, since the RCL_Copy operation also destroys a pointer, namely the previous contents of *v, it calls RCL_Destroy (line 5) to free storage associated with the temporary variable old and trigger an appropriate reference count state update for the shared object previously referenced by *v.
Some implementations or transformations may exploit other LFRC pointer operations such as the previously described RCL_Pass operation, which may be implemented as follows:
















1
RCL_Obj * RCL_Pass(RCL_Obj *v) {










2
UpdateStatus(v,0,1);



3
return v;










4
}










where the RCL_Pass function may be employed to facilitate passing a pointer by value while appropriately maintaining a corresponding reference count. These and other variations on the illustrated set of LFRC pointer operations will be appreciated by persons of ordinary skill in the art based on the description herein.
Alternative Synchronization Support
While have illustrated in detail certain implementations of our techniques for architectures that support single-target CAS operations that are sufficient to span (on the one hand) a pointer coding and an integer coding of sufficient width to avoid saturation with holdCount values possible in any practical exploitation and, which are sufficient to span (on the other hand) a pair of integer codings of sufficient width to avoid saturation with refCount and exitCount values possible in any practical exploitation. For example, a typical 64-bit CAS (which is supported on many modern processors, including those based on the SPARCTM architecture) is generally sufficient to span relevant combinations of 32-bit pointers and realistic integer values of holdCount, ref Count and exit count. Nonetheless, other synchronizations (including CAS or CAS-type operations of differing width, LL/SC operation pairs, etc.) are also possible. Persons of ordinary skill in the art will appreciate the appropriate modifications based on the basic CAS-based implementation(s) described.
SPARC architecture based processors are available from Sun Microsystems, Inc, Palo Alto, Calif. SPARC trademarks are used under license and are trademarks or registered trademarks of SPARC International, Inc. in the United States and other countries. Products bearing SPARC trademarks are based upon an architecture developed by Sun Microsystems.
While most modern architectures support CAS or LL/SC synchronization with targets of sufficient width to span both an architectural width pointer and an integer, the present techniques are not necessarily limited to such architectures. Indeed, it is straightforward to apply the techniques of commonly-owned U.S. patent application Ser. No. 11/026,849, entitled “PRACTICAL IMPLEMENTATION OF ARBITRARY-SIZED LL/SC VARIABLES,” and naming Moir, Doherty, Luchangco and Herlihy as inventors, to provide suitable synchronization support even in architectures for which architectural primitives are of insufficient width to directly span the described RCL_Ref or RCL_Status structures. U.S. patent application Ser. No. 11/026,849 is incorporated by reference herein.
As described in the incorporated reference, load-linked, store-conditional (LL/SC) synchronization may be emulated using techniques that employ only pointer-sized single-target synchronization operations to coordinate access to pointer-referenced LL/SC variables. In one such exploitation, LL/SC variables are defined to correspond to the RCL_Ref and RCL_Status structures described above, thereby obviating the need to directly span such structures with a single-target synchronization. In this way, the present lock-free reference counting techniques may be exploited even in architectures in which an available (or desirable) synchronization primitive merely spans an architectural-width pointer. Using the techniques detailed in U.S. patent application Ser. No. 11/026,849, an LL/SC variable may be defined that encompasses the full-width of the described RCL_Ref or RCL_Status structures or similar structures.
Other Embodiments
While the invention(s) is(are) described with reference to various implementations and exploitations, it will be understood that these embodiments are illustrative and that the scope of the invention(s) is not limited to them. Terms such as always, never, all, none, etc. are used herein to describe sets of consistent states presented by a given computational system, particularly in the context of correctness proofs. Of course, persons of ordinary skill in the art will recognize that certain transitory states may and do exist in physical implementations even if not presented by the computational system. Accordingly, such terms and invariants will be understood in the context of consistent states presented by a given computational system rather than as a requirement for precisely simultaneous effect of multiple state changes. This “hiding” of internal states is commonly referred to by calling the composite operation “atomic”, and by allusion to a prohibition against any process seeing any of the internal states partially performed. Operations that “coincide” typically need not occur simultaneously, but rather through a sequence of operations that may appear to be atomic.
Many variations, modifications, additions, and improvements are possible. For example, while application to particular concurrent shared objects and particular implementations thereof have been described in detail herein, applications to other shared objects and other implementations will also be appreciated by persons of ordinary skill in the art. For example, while techniques and mechanisms have been described using CAS operations as an exemplary single-target synchronization, persons of ordinary skill in the art will recognize that it is straightforward to modify such implementations for use in architectures that support LL/SC rather than (or in addition to) CAS. Similarly, though natural (positive-sense) integer codings have been used for components of a distributed reference count state, any of a variety of other codings may be employed. In general, uses of incrementation and decrementation may be uniformly transposed in alternative implementations, if desired.
Plural instances may be provided for components, operations or structures described herein as a single instance. Finally, boundaries between various components, operations and data stores are somewhat arbitrary, and particular operations are illustrated in the context of specific illustrative configurations. Other allocations of functionality are envisioned and may fall within the scope of the invention(s). In general, structures and functionality presented as separate components in the exemplary configurations may be implemented as a combined structure or component. Similarly, structures and functionality presented as a single component may be implemented as separate components. These and other variations, modifications, additions, and improvements may fall within the scope of the invention(s).

## Claims

1. A lock-free method for managing deallocation of a shared object, the method comprising:
separately encoding at least two respective reference count values that contribute to a total count of references to the shared object;
maintaining a first one of the reference count values in correspondence with creation and destruction of shared references to the shared object; and
maintaining in association with each of the shared references to the shared object, a respective second one of the reference count values, the second reference count value maintaining being in correspondence with creation and destruction of private copies of the respective shared reference.

2. The lock-free method of claim 1, further comprising:
in correspondence with destruction of a particular one of the shared references, transferring the second reference count value maintained in association therewith to an encoding associated with the shared object referenced thereby.

3. The lock-free method of claim 2,
wherein the transferring includes an atomic update of the first reference count value and the transferred to encoding.

4. The lock-free method of claim 2,
wherein the transferred to encoding includes a third one of the reference count values, the method further comprising:
updating the third one of the reference count values together with the first reference count value using a single-target synchronization.

5. The lock-free method of claim 2, further comprising:
freeing the shared object only after the first reference count value indicates that no shared references thereto remain and the transferred to encoding indicates that no private references thereto remain.

6. The lock-free method of claim 1,
wherein, for each second reference count value, the maintaining includes using a single-target synchronization to coordinate update of the second reference count value with any concurrent access to the associated shared reference.

7. The lock-free method of claim 1,
wherein a given one of the shared references and respective one of the second reference count values maintained in association therewith are atomically updatable using a single-target synchronization.

8. A computer-readable storage medium storing program instructions that are computer-executable to implement:
a lock-free concurrent shared object that separately encodes at least two respective reference count values that contribute to a total count of references thereto;
maintaining a first one of the reference count values in association with the shared object; and
maintaining and updating a second one of the reference count values together with the shared reference to the shared object using a single-target synchronization.

9. The storage medium of claim 8, wherein the program instructions are further executable to implement:
transferring to a third one of the reference count values the second reference count value in correspondence with destruction of the shared reference.

10. The storage medium of claim 9, wherein the program instructions are further executable to implement:
atomically updating the first and third reference count values using a single-target synchronization.

11. The storage medium of claim 8, wherein the storage medium is selected from the set of a disk, a tape or another magnetic, optical or electronic storage medium.

12. The storage medium of claim 8, wherein the storage medium is memory of a multiprocessor.

13. A lock-free method for managing deallocation of a shared object, the method comprising:
creating and destroying references to the shared object;
maintaining, in correspondence with the creating and destroying, an accounting of references to the shared object, the accounting including an encoding of a count of shared references to the shared object and, for each shared reference to the shared object, a separate encoding of an associated count of private references created by reading the corresponding shared reference.

14. The method of claim 13,
wherein, for a private one of the references created by reading a shared one of the references, the maintaining includes using a single-target synchronization to coordinate update of the associated count with any concurrent access to the corresponding shared reference.

15. The method of claim 13,
wherein the accounting further includes an encoding of a count of the private references created by reading any of the shared references that have since been destroyed.

16. The method of claim 13, further comprising:
storing a representation of the accounting in memory of a multiprocessor, wherein the representation comprises at least two components,
wherein a first one of the components is encoded in association with the shared object, and
wherein respective second ones of the components are encoded in association with each shared reference to the shared object.

17. A computer-readable storage medium storing program instructions that are computer-executable to implement:
instantiating a shared object in shared memory, the shared object including a first count field for shared references thereto and a second count field;
instantiating a shared reference in the shared memory, the shared reference including a third count field for private references copied from the shared reference; and
a lock-free memory management mechanism for maintaining a reference count state for the shared object by coordinating concurrent updates to the first, second, and third count fields in correspondence with the creating and destroying of references to the shared object.

18. The storage medium of claim 17,
wherein, for a given shared object instantiation, the second count field and a set of the third count fields associated with shared references thereto together encode a net count of undestroyed private references to the shared object.

19. The storage medium of claim 17,
wherein the second count field encodes a net count of private references copied from subsequently destroyed ones of the shared references less those private references that have themselves been destroyed; and
wherein a set of the third count fields encodes a count of private references copied from undestroyed ones of the shared references.

20. The storage medium of claim 17,
wherein the lock-free memory management mechanism employs only single-target synchronizations.