Abstract: One embodiment of the present invention provides a system that facilitates avoiding collisions between cache lines containing objects and cache lines containing corresponding object table entries. During operation, the system receives an object identifier for an object, wherein the object identifier is used to address the object in an object-addressed memory hierarchy. The system then applies a mapping function to the object identifier to compute an address for a corresponding object table entry associated with the object, wherein the mapping function ensures that a cache line containing the object table entry does not collide with a cache line containing the object.

Abstract: One embodiment of the present invention facilitates skewing a bi-directional object layout to provide good cache behavior. During operation, the system receives a request to access an object. This request includes an object identifier and an object offset that specifies the offset of a target field within the object, wherein the object has a bi-directional layout that locates scalar fields at positive offsets and reference fields at negative offsets, so that a reference field can be immediately identified from its object offset. Next, the system determines a skew value for a cache line containing the object, wherein data within the cache line is shifted based upon the skew value, so that reference fields with small negative offsets are likely to be located in the same cache line as scalar fields with small positive offsets. Next, the system uses the skew value in accessing the object.

Abstract: One embodiment of the present invention provides a system that uses references within a first object to prefetch a second object into a cache memory. During operation, the system receives a first cache line containing at least a portion of the first object. Next, the system locates a reference to the second object within the first cache line, and uses the reference to perform a prefetching operation for the second object. In a variation on this embodiment, while performing the prefetching operation for the second object, the system examines the cache memory to determine if the second object is already present within the cache memory. If not, the system performs the prefetching operation for the second object.

Abstract: One embodiment of the present mechanism provides a system to facilitate testing of garbage collection implementations. The system operates by first receiving a trace of valid memory transactions at a test harness. This trace of valid memory transactions is replayed through the test harness into a memory manager, which includes a garbage collection implementation under test. The results of replaying this trace are then observed to verify that the garbage collection implementation under test does not erroneously change the contents of the memory.

Abstract: One embodiment of the present invention provides a system that facilitates implementing multi-mode specification-driven disassembler. During operation, the disassembler receives a machine-code version of a computer program. In order to disassemble a specific machine-code instruction from this machine-code version, the system compares the machine-code instruction against a set of instruction templates for assembly code instructions to identify a set of matching templates. Next, the system selects a matching template from the set of matching templates based on the state of a mode variable, which indicates a specificity mode for the disassembler. The system then disassembles the machine-code instruction using the operand fields defined by the matching template to produce a corresponding assembly code instruction.

Abstract: One embodiment of the present invention provides a system that uses references within a first object to prefetch a second object into a cache memory. During operation, the system receives a first cache line containing at least a portion of the first object. Next, the system locates a reference to the second object within the first cache line, and uses the reference to perform a prefetching operation for the second object. In a variation on this embodiment, while performing the prefetching operation for the second object, the system examines the cache memory to determine if the second object is already present within the cache memory. If not, the system performs the prefetching operation for the second object.

Abstract: A computer system providing hardware states for garbage collection including a plurality of processors, an object cache operatively connected to at least one of the plurality of processors, and a warden operatively connected to the object cache, wherein the warden broadcasts a non-local command to the object cache.

Abstract: A computer system including a processor, an object cache operatively connected to the processor, a memory, and a translator interposed between the object cache and the memory, wherein the translator maps an object address to a physical address within the memory.

Abstract: One embodiment of the present invention provides a system to facilitate testing of garbage collection implementations. The system operates by first receiving a trace of valid memory transactions at a test harness. This trace of valid memory transactions is replayed through the test harness into a memory manager, which includes a garbage collection implementation under test. The results of replaying this trace are then observed to verify that the garbage collection implementation under test does not erroneously change the contents of the memory.

Abstract: One embodiment of the present invention provides a system that facilitates automated isolation of native code within a computer program that has been compiled to a platform-independent code. The system operates by receiving a library containing a native code sub-routine that provides a service to the computer program. The system analyzes the library to determine the symbol name for the native code sub-routine. A proxy sub-routine is generated for each native code sub-routine exported by the native library that forms a link to the native code sub-routine. This proxy sub-routine is placed into a new library using the original name of the native code sub-routine. The system runs the native code sub-routine in one process, and executes the platform-independent code in a separate process. The system invokes the native code sub-routine in the first process by calling the proxy sub-routine from the platform-independent code in the second process.

Abstract: Apparatus, methods, systems and computer program products are disclosed describing generational garbage collection on a card-marked heap memory shared by multiple processing units. When one of the processing units detects that the free space available for node creation is below a threshold, that processing unit pauses its heap mutation processes and signals the other processing units to also pause mutation. After the other processing units pause heap mutation, the processing units then proceed to execute generational garbage collection procedures on the shared heap. The generational garbage collection procedures for each processing unit are driven by pointers stored in each processing unit's register, stack and static variables along with pointers within a specified partition of the shared card-marked heap. The processing units resume mutation of the heap once they all complete their garbage collection processes.

Abstract: Apparatus, methods, systems, and computer program products are disclosed that locate a modified pointer value in a carded heap memory. A plurality of nodes is allocated from the carded heap memory. The carded heap contains at least one structure that indicates the existence or non-existence of a node reference for each card. For those cards containing a node reference the structure also includes the offset from the start of the card to the node reference. A card index or pointer within a card (that is used to generate a card index) is given to the invention. The card index is used to specify a first card. A second card is found given the card index. The invention then follows, starting at the first node in the second card and using the node advance value for each followed node, the nodes in the carded memory area until it locates the node containing the pointer in the first card.

Abstract: Apparatus, methods, and computer program products are disclosed for improving the performance of subsequent compilations of a source program. The initial compilation of the source program journals computationally expensive intermediate compilation data. Subsequent compilations, instead of recomputing this data, uses the intermediate compilation data from the journal. Thus the compiler has improved performance during subsequent compilations of the source program. One aspect of the invention applies to dynamic compilers to reduce the startup delay caused by compiling the source program when the program is invoked.

Abstract: One embodiment of the present invention presents a method and apparatus for efficiently performing garbage collection on objects defined within an object-oriented programming system. Garbage collection typically involves following pointers to determine which objects are presently being referenced so that other objects, that are not being referenced, can be removed. To this end, the present invention maintains a bitmap for each object that indicates which variables in the object are pointer variables and which variables are non-pointer variables. A garbage collection process examines the bitmap, and on the basis of the pattern contained in the bitmap jumps to a particular routine that is tailored to garbage collect the particular pattern of pointer and non-pointer values in the object. Note that the system includes a routine tailored for each possible bitmap pattern.

Abstract: Apparatus, methods, systems, and computer program products are disclosed that use a link to access nodes in a generational garbage collected heap. The creation area of the heap is associated with a validation variable that is dependent on the number of scavenge operations performed on the creation area. The link comprises the value of the validation variable when the node was allocated and the index of the created node within the creation area. When the node is copied from the creation area an entry is made in a link-to-pointer translation table. Accesses to the node using the link succeed regardless of whether the node is in the creation area. Thus, not all references to the node need to be updated when the node is copied from the creation area allowing the copying process to be interrupted when resolving links to the copied node.

Abstract: Apparatus, methods, systems and computer program products are disclosed describing a data structure and associated processes that optimize garbage collection techniques. The disclosed data structure can be used as an instantiated object in an object-oriented programming environment. The data structure uses a data structure header to separate the portion of the data structure that contains pointer values from the portion of the data structure that contains non-pointer values. The contents of the first word of the data structure header is distinguishable from any pointer value. Thus, a garbage collection procedure can more rapidly locate the pointer values in the data structure. Another advantage of this data structure organization, when applied to instantiated objects, is that the position of an instance variable (with respect to the object header structure) remains constant for all instantiated objects including those based on subclasses of the original class.