Abstract: A remembered set for a memory heap region in a garbage-collected computer system is modified to classify reference locations stored therein by the heap region from which the references originate so that the number of references originating from a given region can be easily determined. If the number of remembered set entries for references from a second region to a first region reaches a predetermined threshold, the second region is constrained so that it will be collected at the same time as, or before, the first region. Then, all entries in the remembered set associated with the first region for references from the second region to the first region can be deleted, and no such entries need be entered in the future thereby reducing the size of that remembered set and the time required to scan it.

Abstract: An array-based concurrent shared object implementation has been developed that provides non-blocking and linearizable access to the concurrent shared object. In an application of the underlying techniques to a deque, the array-based algorithm allows uninterrupted concurrent access to both ends of the deque, while returning appropriate exceptions in the boundary cases when the deque is empty or full. An interesting characteristic of the concurrent deque implementation is that a processor can detect these boundary cases, e.g., determine whether the array is empty or full, without checking the relative locations of the two end pointers in an atomic operation.

Abstract: In a space incremental garbage collector, remembered set information for a region is stored in a set of fixed-size data structures, each of which has a representation of the information and a level of precision that differs from other data structures in the set. Remembered set information for each other region is placed in a data structure based on the density of inter-region references between the region and the other region. The remembered set information for the other region is moved from one data structure to another data structure when the density of inter-region references between the region and the other changes. Some of the data structures use bit arrays to store the information and these arrays can be combined with bit arrays produced by the collector to facilitate the identification and removal of stale remembered set entries.

Abstract: A garbage collector treats a heap as divided into regions. From a candidate set of those regions, it selects the collection sets on which it performs collection increments from among those regions in accordance with a selection criterion separate from the ages of the objects that those regions contain. It nonetheless segregates objects according to age, placing objects in such a manner that no candidate-set region containing an object whose age is less than some predetermined maximum also contains an object of a different age.

Abstract: A heap may be marked and compacted while performing only two passes over the objects and object references in the heap. Specifically, objects and object references are traversed once during a marking phase and again during a compaction phase of split-reference, two-pass mark-compaction. Object references are updated in two steps. First, during marking, each object reference may be updated to include the relative offset within its block of the referenced object and-during compaction that offset may be added to the block's destination address resulting in a reference that points to the actual post-compaction location for the referenced object. Objects of a particular block may be rearranged, or permuted, with respect to each other within the block. However, the order between groups of objects in different blocks may be preserved across compaction.

Abstract: A garbage collector treats a garbage-collected heap as divided into heap regions, for each of which it maintains a respective remembered set, whose entries list the locations where references located in the heap outside that region refer to references inside that region. The remembered sets are used during space-incremental collection operations on collection sets of those regions; if the garbage collector determines that objects in the collection set are not referred to directly or indirectly from outside the collection set, it reclaims the memory space that they occupy. It places entries into the remembered sets independently of the locations at which the references were found, so any region can be chosen for inclusion in any collection set; no predetermined collection order is required. Instead, the garbage collector performs global marking operations and uses the results to select for collection-set membership the regions that it can most likely collect efficiently.

Abstract: A garbage collector that reclaims memory for a mutator does so space-incrementally, employing remembered sets associated with respective heap regions to keep track of where the mutator has notified it of writing references into the associated regions. The collector reserves some heap regions for objects that it has found to be “popular,” i.e., to which it has observed a large number of references. When the mutator writes such a reference, it refrains from making the kind of notification to which the garbage collector would otherwise respond by updating a remembered set. Although this deprives the garbage collector of the ability to maintain complete remembered sets for popular-object regions, those regions usually have no unreachable objects or very few, so the collector can dispense with collecting them or can collect them less frequently, in a way that does not rely on remembered sets.

Abstract: A space-incremental garbage collector performs marking operations that are usually separated by several collection increments. It uses the marking results to compute collection-efficiency metrics for regions into which it treats the heap as divided. It bases its selection of regions for successive increments' collection sets on the metrics' values, whose computations also depend on the sizes of the regions' “remembered sets,” i.e., on the lists of locations where references to objects in those regions have been observed. Although the remembered-set sizes therefore potentially change between collection increments, the collector re-computes metrics in most collection increments for only a subset of the regions. It selects the subset in accordance with a sorting of all regions that it performed at the end of the most recent completed marking operation.

Abstract: A garbage collector keeps a log of recent system usage. From that usage thus recorded, it determines whether a time slice whose duration a maximum-mutator-utilization (“MMU”) specification prescribes and whose end time is the same as a prospective future collection pause will contain more than the maximum imposed by the MMU specification on the time slice's garbage collector time. The collector uses that determination to arrive at a compliant length for a pause that is to start at a predetermined time or to find a time at which a pause of a predetermined length can start without violating the MMU specification.

Abstract: An incremental collector that employs remembered sets to identify the locations where a mutator has modified references to objects in respective heap regions employs a thread operating concurrently with the mutator to update the remembered sets in accordance with reference mutation. Specifically, when the mutator modifies a reference in one of a plurality of “cards” into which the collector treats the heap as divided, the concurrent thread ordinarily searches the card for references in accordance with which it updates the remembered set. But it selects certain cards, in which it has observed particularly high mutation activity, as ones in which reference mutation will not cause concurrent remembered-set updating. Remembered-set updating in response to those cards' references occurs only when all mutator threads have been suspended.

Abstract: A garbage collector divides the garbage-collected heap into “cards.” It maintains a table containing a card-object table entry for each card. A card's entry contains information from which the collector can determine where any references in the card are located and thereby identify objects that may be reachable. The encoding of a card's table entry is not restricted to values that indicate the location of the object in which the card begins. Instead, its possible values additionally include ones that indicate that the card begins with a certain number of references or that an object begins at a given location in the middle of the card. The collector thereby avoids consulting object's class information unnecessarily.

Abstract: A technique is provided for reducing the number of write barriers executed in mutator code without compromising garbage collector performance. Advantageously, a compiler generates two forms of a mutator code—a first version with write barriers and a second version substantially without write barriers. In operation, the first version of the code may be accessed by a vtable in a “mature” near-class and the second version may be accessed by a vtable in a “nascent” near-class. According to the invention, mapping of functionally equivalent points in the first and second versions of the mutator code may be facilitated by an associated pcmap. Further, each of the first and second versions may also be associated with a respective nr_map that facilitates mapping functionally equivalent points within different branches of guard code sequences corresponding to reference-writes to non-receiver objects.

Abstract: During a collection interval, if a multi-threaded generational, copying garbage collector finds that a card contains a reference to a younger generation, it gives a corresponding card table entry a youngergen value selected from a plurality of youngergen values at the beginning of the interval as the “current” youngergen value. The youngergen value chosen for a given collection interval differs from the one that was chosen for the previous collection interval. As a result, a collector thread is able to distinguish between a card in which a reference to the younger generation remained at the end of the previous interval and one identified by some other thread during the current interval as referring to a young-generation object. In that way, the thread is able to avoid unnecessary scanning.

Abstract: A garbage collector operates in multiple threads, and one thread can be parsing a region containing a free block while another thread is allocating space from that free block for an object being relocated to that region. The object being relocated may be an array object, for which the length determination is based on more than one word in the object; it may be based on a class-identifying word and a number-of-elements word. To prevent a parsing thread from parsing erroneously by reading both of those words between the relocating thread's writing one of them and writing the other, the relocating thread first writes into the classifying word a distinguished value from which a parsing thread can conclude that the values it reads in other fields of the block are not to be trusted.

Abstract: The Hat Trick deque requires only a single DCAS for most pushes and pops. The left and right ends do not interfere with each other until there is one or fewer items in the queue, and then a DCAS adjudicates between competing pops. By choosing a granularity greater than a single node, the user can amortize the costs of adding additional storage over multiple push (and pop) operations that employ the added storage. A suitable removal strategy can provide similar amortization advantages. The technique of leaving spare nodes linked in the structure allows an indefinite number of pushes and pops at a given deque end to proceed without the need to invoke memory allocation or reclamation so long as the difference between the number of pushes and the number of pops remains within given bounds. Both garbage collection dependent and explicit reclamation implementations are described.

Abstract: In a computer system that uses a generational garbage collector in which objects are promoted from a “young” generation to an “old” generation, a compiler output designates certain dynamic-allocation instructions as being ones whose resultant allocated objects will be considered “pinned.” The compiler associates with such allocation instructions respective segments of the code following the instructions and objects allocated within one of those segments are considered to remain pinned until program execution passes beyond that segment. The garbage collector refrains from promoting any pinned object, and as a consequence, an instruction that writes a reference into an object field while that object is pinned does not need to be accompanied by a write barrier.

Abstract: We present a methodology for transforming concurrent data structure implementations that depend on garbage collection to equivalent implementations that do not. Assuming the existence of garbage collection makes it easier to design implementations of concurrent data structures, particularly because it eliminates the well-known ABA problem. However, this assumption limits their applicability. Our results demonstrate that, for a significant class of data structures, designers can first tackle the easier problem of an implementation that does depend on garbage collection, and then apply our methodology to achieve a garbage-collection-independent implementation. Our methodology is based on the well-known reference counting technique, and employs the double compare-and-swap operation.

Abstract: A computer system (10) implements a memory allocator that employs a data structure (FIG. 3) to maintain an inventory of dynamically allocated memory available to receive new data. It receives from one or more programs requests that it allocate memory from a dynamically allocable memory “heap.” It responds to such requests by performing the requested allocation and removing the thus-allocated memory block from the inventory. Conversely, it adds to the inventory memory blocks that the supported program or programs request be freed. In the process, it monitors the frequencies with which memory blocks of various sizes are allocated, and it projects from those frequencies future-demand values for memory blocks of those sizes. It then splits larger blocks into smaller ones preemptively, i.e., before a request for the result of the splitting.

Abstract: A computer system (10) implements a memory allocator that employs a data structure (FIG. 3) to maintain an inventory of dynamically allocated memory available to receive new data. It receives from one or more programs requests that it allocate memory from a dynamically allocable memory “heap.” It responds to such requests by performing the requested allocation and removing the thus-allocated memory block from the inventory. Conversely, it adds to the inventory memory blocks that the supported program or programs request be freed. In the process, it monitors the frequencies with which memory blocks of different sizes are allocated, and it projects from those frequencies future demand for different-sized memory blocks. When it needs to coalesce multiple smaller blocks to fulfil an actual or expected request for a larger block, it bases its selection of which constituent blocks to coalesce on whether enough free blocks of a constituent block's size exist to meet the projected demand for them.

Abstract: A multiprocessor, multiprogram, stop-the-world garbage collection program is described. The system initially over partitions the root sources, and then iteratively employs static and dynamic work balancing. Garbage collection threads compete dynamically for the initial partitions. Work stealing double-ended queues, where contention is reduced, are described to provide dynamic load balancing among the threads. Contention is resolved by atomic instructions. The heap is broken into a young and an old generation where semi-space copying employing local allocation buffers is used to collect the reachable objects in the young section, and for promoting objects from the young to the old generations, and parallel mark-compacting is used for collecting the old generation. Efficiency of collection is enhanced by use of card tables and linking objects, and overflow conditions are efficiently handled by linking using class pointers. The garbage collection termination using a global status word is employed.