Abstract: A system and method for managing data includes executing a set of instructions which are used for operating on compressed data and another set of instructions (e.g., different instructions) which are used for operating on uncompressed data.

Abstract: The present invention provides techniques that allow concurrent collection of cyclic garbage on reference counting systems. In general, candidate objects are found that may be part of cyclic garbage. Each candidate object has a reference count. Two tests are performed to determine if concurrent operations have affected the reference counts of the candidate objects. If concurrent operations have not affected the reference counts, the candidate objects are collected as garbage. Additionally, during garbage collection, the decrements to reference counts are delayed so that increments occur before decrements and so that decrements are held a predetermined time before being applied.

Abstract: A method (and system) for executing a task includes executing a first task in which garbage is collected using a garbage collector, and executing a second task, the garbage collector being preemptable (e.g., preempted) by the second task.

Abstract: In a virtual machine environment, a method and apparatus for the use of multiple heaps to retain persistent data and transient data wherein the multiple heaps enables a single virtual machine to be easily resettable, thus avoiding the need to terminate and start a new Virtual Machine as well as enabling a single virtual machine to retain data and objects across multiple applications, thus avoiding the computing resource overhead of relinking, reloading, reverifying, and recompiling classes. The memory hierarchy includes a System Heap, a Middleware Heap and a Transient Heap. The use of three heaps enables garbage collection to be selectively targeted to one heap at a time in between applications, thus avoiding this overhead during the life of an application.

Abstract: The present invention provides techniques that allow concurrent collection of cyclic garbage on reference counting systems. In general, candidate objects are found that may be part of cyclic garbage. Each candidate object has a reference count. Two tests are performed to determine if concurrent operations have affected the reference counts of the candidate objects. If concurrent operations have not affected the reference counts, the candidate objects are collected as garbage. Additionally, during garbage collection, the decrements to reference counts are delayed so that increments occur before decrements and so that decrements are held a predetermined time before being applied. This prevents decrementing a reference count and collecting a cycle as garbage right before a reference is added to an object in the cycle.

Abstract: Techniques are provided that speed synchronous garbage collection in systems that use reference counting. The present invention performs each of the steps of marking, scanning, and collecting on all nodes that are possibly nodes in a cycle of garbage. These nodes are referred to as “root” nodes herein. In other words, an aspect of the present invention performs the step of marking on each root node, the step of scanning on each root node, and the step of collecting on each root node. Performing one or more of these steps on all of the root nodes results in a lower number of operations than selecting single root nodes, performing these steps on each root node, and iterating until all root nodes are selected. Additionally, before root nodes are added to a buffer, they are examined to determine if they are already in the buffer. If they are, they are not added to the buffer. This prevents the same root node from being examined multiple times. Finally, nodes are examined to determine whether they are acyclic.

Abstract: The present invention analyzes an application A and computes a set reachable methods in A by determining the methods in A that may be called from another reachable method in A, or from within a class library L used by A without analyzing the classes in L. The invention may be used as an optimization to reduce application size by eliminating unreachable methods.

Abstract: The present invention analyzes an application A and computes a set reachable methods in A by determining the methods in A that may be called from another reachable method in A, or from within a class library L used by A without analyzing the classes in L. The invention may be used as an optimization to reduce application size by eliminating unreachable methods. In the alternative, the invention may be used as a basis for optimizations that reduce execution time (e.g., by means of call devirtualization), and as a basis for tools for program understanding and debugging.

Abstract: Techniques are provided that speed synchronous garbage collection in systems that use reference counting. The present invention performs each of the steps of marking, scanning, and collecting on all nodes that are possibly nodes in a cycle of garbage. These nodes are referred to as “root” nodes herein. In other words, an aspect of the present invention performs the step of marking on each root node, the step of scanning on each root node, and the step of collecting on each root node. Performing one or more of these steps on all of the root nodes results in a lower number of operations than selecting single root nodes, performing these steps on each root node, and iterating until all root nodes are selected. Additionally, before root nodes are added to a buffer, they are examined to determine if they are already in the buffer. If they are, they are not added to the buffer. This prevents the same root node from being examined multiple times.

Abstract: The present invention provides techniques that allow concurrent collection of cyclic garbage on reference counting systems. In general, candidate objects are found that may be part of cyclic garbage. Each candidate object has a reference count. Two tests are performed to determine if concurrent operations have affected the reference counts of the candidate objects. If concurrent operations have not affected the reference counts, the candidate objects are collected as garbage. Additionally, during garbage collection, the decrements to reference counts are delayed so that increments occur before decrements and so that decrements are held a predetermined time before being applied. This prevents decrementing a reference count and collecting a cycle as garbage right before a reference is added to an object in the cycle.

Abstract: A lock/unlock mechanism to control concurrent access to objects in a multi-threaded computer processing system comprises two parts: a thread pointer (or thread identifier), and a one-bit flag called a “Bacon bit”. Preferably, when an object is not locked (i.e., no thread has been granted access to the object), the thread identifier and Bacon bit are set to 0. When an object is locked by a particular thread (i.e., the thread has been granted access to the object), the thread identifier is set to a value that identifies the particular thread; if no other threads are waiting to lock the object, the Bacon bit is set to 0; however, if other threads are waiting to lock the object, the Bacon bit is set to ‘1’, which indicates the there is a queue of waiting threads associated with the object. To lock an object, a single CompareAndSwap operation is preferably used, much like with spin-locks; if the lock is already held by another thread, enqueueing is handled in out-of-line code.

Abstract: An object oriented dispatch optimization method determines statically which body of code will be executed when a method is dispatched. The program code is examined to identify all procedure bodies that can be invoked for a given class and a given method. An identified procedure body is analyzed to determine whether a method invocation on a pointer can invoke only one procedure body. Based on this analysis, either the procedure body or the invocation mechanism is changed so a unique procedure is directly called without a test or dispatch being used.