Abstract:
In accordance with the present invention a method is provided for managing objects during a garbage collection operation. The process comprises the steps of compacting objects in a memory, allocating an available memory location for a surviving object and a corresponding hash field, storing the surviving object in the available memory location by copying the surviving object from a previous memory location to the available memory location, and storing a hash value for the surviving object in the hash field. The hash value includes a memory address for the previous memory location. In accordance with another aspect of the present invention, a method is provided for managing objects stored in memory. The method comprises the steps of receiving an instruction to allocate an object, locating space in a memory for the object, storing the object at the located space, and including in the stored object a header portion reflecting a hash status. The hash status is used to indicate (i) whether the object has been hashed and (ii) whether the object has a hash field.

Description:
BACKGROUND OF THE INVENTION 
     A. Field of the Invention 
     This invention generally relates to memory management for computer systems and, more particularly, to a method and apparatus for managing hashed objects. 
     B. Description of the Related Art 
     (1) The Java™ programming language &#34;hashCode&#34; Method 
     The Java™ programming language is an object-oriented computer programming language. The language is described in many texts, including one that is entitled &#34;The Java Language Specification&#34; by James Goslin, Bill Joy, and Guy Steele, Addison-Wesley, 1996. Java and all Java-based trademarks are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other countries. In an object oriented system, such as one or more related programs written in this language, a &#34;class&#34; provides a template for the creation of &#34;objects&#34; (which represent items or instances manipulated by the system) having characteristics of that class. The term template denotes that the objects (i.e., data items) in each class, share certain characteristics or attributes determined by the class. Objects are typically created dynamically during system operation. Methods associated with a class generally operate on the objects of the same class. The Java language was designed to run on computing systems with characteristics that are specified by the Java Virtual Machine (JVM) Specification. The JVM specification is described in detail in a text entitled &#34;The Java Virtual Machine Specification&#34;, by Tim Lindholm and Frank Yellin, Addison Wesley, 1996. 
     The Java language defines a method referred to as &#34;hashCode()&#34; in the topmost class Object that defines properties shared by all objects in a Java language system. The hashCode() method causes the JVM, or some other runtime system that supports the Java language, to return an integer hash value corresponding to a selected object. The Java language hash code() operation has the following properties: (1) It ensures that an object&#39;s hash value remains constant throughout its life-time. (2) It ensures a good distribution of hash values such that different objects to a great extent have different hash values. Using such a hashCode() operation, programmers can build data structures, known as hash tables, that support efficient lookup (search and retrieval) of data. Hash tables require the former property to ensure correctness and the latter property to achieve high efficiency. 
     For example, a hashCode() implementation that always returns &#34;0&#34;, while allowing correct operation of hash tables, would be a poor choice because the lack of distribution degrades performance of hash table lookup operations. An alternative implementation of the hashCode() operation may use the address of the object as its hash code. Because different objects are located at different addresses in memory, this implementation provides excellent distribution. However, it only applies to systems where hashed objects never move, because if an object moved to a different address, its hash code would change, violating the first property. 
     In most object-oriented languages, it is possible to override the virtual machine hashCode() method for specific classes. For example, the String class in the Java language overrides hashCode() to compute a hash value based on the characters in the string. Thus, the hashCode() operation on two &#34;equal&#34; strings that contain the same characters in the same order will produce the same hash value. 
     For most programs the vast majority of objects are never hashed using the virtual machine&#39;s implementation of hashCode(). First, not all programs use hash tables, and those that do use hash tables do not include each and every object in a hash table. Second, as explained above, important classes of objects override the virtual machine&#39;s hashCode() implementation. 
     The desirable properties of the virtual machine hashCode() operation are thus summarized as follows: 
     1. It must ensure that a hash value for an object remains constant throughout the life-time of the object. 
     2. It must provide a good distribution of hash values. 
     3. It must be efficient to compute hash values. 
     4. It must maintain low storage requirements. 
     Since most objects are never hashed, to ensure low space overhead it is essential to use as little space as possible for non-hashed objects. The problem is, of course, that it is typically difficult to predict whether the hashCode() operation will be applied to a given object. 
     (2) Garbage Collection 
     One of the most important resources within a data processing system is the amount of memory directly available for utilization by tasks during execution. Accordingly, much interest has been directed to efficient utilization of memory and memory management strategies. An important concept in memory management is the manner in which memory is allocated to a task, deallocated and then reclaimed. 
     Memory deallocation and reclamation may be explicit and controlled by an executing program, or may be carried out by another special purpose program which locates and reclaims memory which is unused, but has not been explicitly deallocated. &#34;Garbage collection&#34; is the term used in technical literature and the relevant arts to refer to a class of algorithms utilized to carry out storage management, specifically automatic memory reclamation. There are many known garbage collection algorithms, including reference counting, mark-sweep, and generational garbage collection algorithms. These, and other garbage collection techniques, are described in detail in a book entitled &#34;Garbage Collection, Algorithms For Automatic Dynamic Memory Management&#34; by Richard Jones and Raphael Lins, John Wiley &amp; Sons, 1996. 
     An object may be located by a &#34;reference&#34;, or a small amount of information that can be used to access the object. One way to implement a reference is by means of a &#34;pointer&#34; or &#34;machine address,&#34; which uses multiple bits of information, however, other implementations are possible. General-purpose programming languages and other programmed systems often use references to locate and access objects. Such objects can themselves contain references to data, such as integers or floating-point numbers and to yet other objects. In this manner, a chain of references can be created, each reference pointing to an object which, in turn, points to another object. 
     Garbage collection techniques determine when an object is no longer reachable by an executing program, either directly or through a chain of pointers. When an object is no longer reachable, the memory that the object occupies can be reclaimed and reused even if it has not been explicitly deallocated by the program. To be effective, garbage collection techniques should be able to, first, identify references that are directly accessible to the executing program, and, second, given a reference to an object, identify references contained within that object, thereby allowing the garbage collector to trace transitively chains of references. 
     A subclass of garbage collectors known as &#34;relocating&#34; garbage collectors, relocates objects that are still reachable by an executing program. Relocation of an object is accomplished by making a copy of the object in another region of memory, then replacing all reachable references to the original object with references to the new copy. The memory occupied by the original object may then be reclaimed and reused. Relocating garbage collectors have the desirable property that they compact the memory used by the executing program and thereby reduce memory fragmentation, which is typically caused by non-compacting garbage collectors. 
     In systems that use a non-compacting garbage collector, objects never move. Once they are allocated a certain address, they remain there until they become garbage. It is therefore possible to use the address of the object as its hashCode(). This solution is fast and has no space overhead. It also has good distribution of hash values. However, few implementations of object-oriented languages use non-compacting memory systems, since the induced fragmentation affects performance negatively. 
     (3) Handle-based memory systems 
     The original Java programming language used indirect pointers or &#34;handles&#34; to refer to objects. Handles were introduced to allow easy relocation of objects during garbage collection. With handles, it is easy to move objects because there is only one direct pointer to each object: the one in its handle. In such handle-based memory systems, while the object address is non-constant over the life-time of the object and therefore cannot be used for hashing, the handle address remains constant. Thus, the hashCode() function returned the address of the handle. 
     This implementation, like the object address implementation in non-compacting systems, is fast, has no space overhead, and gives a good distribution. However, other concerns, including execution efficiency, favor non-handle-based memory systems. Consequently, the use of an object&#39;s handle as its hash value is not desirable. 
     (4) Direct-pointer, no-handle memory systems 
     For performance reasons, one would want to implement object-oriented languages using compacting garbage collection algorithms that work with direct pointers. Consequently, hash codes must be implemented in a different way than by using addresses. Because objects move, their address is no longer an acceptable hash value, and there are no handles in systems using direct pointers. 
     The known implementation of the object-oriented language called &#34;&#39;Self&#34; illustrates the most common solution. The Self implementation reserves 22 bits in a header word of every object to hold its hash value. The bits are set to a 22 bit pseudo-random value. Since most objects are never hashed, the computation of hash values is done on demand: The Self implementation does not assign the 22 bit hash value at object allocation time, but defers it until the object is first hashed. While this slows down all hash retrieval operations by an extra test, such a solution is acceptable because object allocation is more frequent than hashing for most programs. 
     This solution also has fast retrieval and a reasonable distribution, although the hash values in the specific case of the Self implementation are compressed into a 22 bit space, even though computers provide larger number bit words, such as 32 bits. The solution also has low storage overhead, but only if the header word can accommodate the 22 bits required to hold the hash value. However, not all systems have spare bits in a header word, let alone the 22 bits required by the aforementioned Self implementation. If hashing necessitates adding an extra header word to every object, the space cost of such an implementation may not be acceptable. 
     Accordingly, there is a need for a system that provides a satisfactory, space-efficient hashCode() function for use with a compacting garbage collector in a system that does not use handles. 
     SUMMARY OF THE INVENTION 
     In accordance with the present invention, as embodied and broadly described herein, a method for managing objects during a garbage collection operation comprises the steps of compacting objects in a memory, allocating an available memory location for a surviving object and a corresponding hash field, storing the surviving object in the available memory location, and storing a hash value for the surviving object in the hash field. 
     In accordance with another aspect of the present invention, as embodied and broadly described herein, a method for managing objects comprises the steps of receiving an instruction to allocate an object, locating space in a memory for the object, storing the object at the located space, and including in the stored object a header portion reflecting a hash status. The hash status is used to indicate (i) whether the object has been hashed and (ii) whether the object has a hash field. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate an embodiment of the invention and, together with the description, serve to explain the advantages and principles of the invention. In the drawings, 
     FIG. 1 is a schematic block diagram illustrating a computer architecture suitable for use with the present invention; 
     FIG. 2 is a flow chart of the steps used to allocate an object in accordance with an implementation of the present invention; 
     FIG. 3 is a block diagram of a memory including multiple objects; 
     FIG. 4 is a flow chart of the steps of a hashCode( ) operation in accordance with an implementation of the present invention; 
     FIG. 5 is a flow chart of the steps of a compacting garbage collector in accordance with an implementation of the present invention; and 
     FIGS. 6A and 6B are block diagrams of a memory including multiple objects before and after execution of the compacting garbage collector. 
    
    
     DETAILED DESCRIPTION 
     Reference will now be made in detail to an implementation of the present invention as illustrated in the accompanying drawings. Wherever possible, the same reference numbers will be used throughout the drawings and the following description to refer to the same or like parts. 
     Introduction 
     Systems consistent with the present invention provide a hashCode() operation that is fast to compute, offers good distribution with a full 32 bit hash range, accommodates low space overhead for non-hashed objects, and does not require handles. The hashCode() function also accommodates a compacting garbage collector to ensure efficient use of memory. 
     For the purpose of this specification, the term &#34;object&#34; refers to a data structure that is represented in the memory of a computing system. This usage of the term object is distinct from the usage of the term &#34;object&#34; in &#34;object-oriented&#34; systems, wherein objects have associated &#34;methods&#34;, i.e. pieces of code associated with them, which code may be invoked through a reference to the object. However, the present invention is applicable to such object-oriented systems. 
     In general, systems consistent with the present invention initially allocate objects without a field for hash values. Under some circumstances, the object will later be expanded by an extra field designated to hold the hash value of the object. To support this expansion without incurring a large overhead or excessive garbage collection and tracing of objects, two bits in the header of objects are designated for a &#34;hasBeenHashed&#34; code and a &#34;hasHashField&#34; code. At object allocation time, both bits are set to &#34;0&#34;. The bits remain &#34;0&#34; until the first time the hashCode() method is invoked on the object. When initiated by a program the hashCode() method sets the hasBeenHashed bit to &#34;1&#34; and returns the address of the object as the hash value. As long as the hasBeenHashed bit is &#34;1&#34; and the hasHashField bit is &#34;0&#34;, the hashCode() operation continues to return the address of the object as its hash value. 
     Systems consistent with the present invention further invoke a garbage collector to collect &#34;dead&#34; objects, which are no longer referenced by at least one executing program, and to relocate &#34;surviving&#34; objects, which are still referenced by at least one executing program. Collecting dead objects involves freeing the space in memory corresponding to dead objects, and relocating surviving objects involves compacting the surviving objects in memory to reduce fragmentation. The garbage collection process inspects the hash bits of each surviving object. If the hasBeenHashed bit is &#34;0&#34;, nothing special needs to be done to the object. If, however, the hasBeenHashed bit is set to &#34;1&#34; and the hasHashField is set to &#34;0&#34;, then the object has been hashed, but it has no added hash field. The garbage collector thus allocates an extra field at a new location in memory where the object will be relocated, stores the object&#39;s hash value in the new field, copies the object to the new location, and sets the hasHashField to &#34;1&#34;. The object&#39;s hash value is the same as the object&#39;s old memory address. From then on, the object is one field larger than when it was originally allocated or &#34;born&#34;, and the hash value is &#34;internalized&#34;. The new field for the hash value is located at the end of the object. This maintains the structure of the original object and ensures that field offsets of the object&#39;s fields remain the same. 
     For objects with a hasHashField set to &#34;1&#34;, the hashCode() operation simply returns the contents of the hash field. Otherwise, the hashCode() operation returns the object&#39;s memory address. 
     Computer System 
     FIG. 1 illustrates the system architecture for a computer system with which the invention may be implemented. The exemplary computer system of FIG. 1 is for descriptive purposes only. Although the description may refer to terms commonly used in describing particular computer systems, such as in IBM PS/2 personal computer, the description and concepts equally apply to other computer systems such as network computers, workstation and even mainframe computers having architectures dissimilar to FIG. 1. 
     Furthermore, the implementation is described with reference to a computer system implementing the Java programming language and Java Virtual Machine specifications, although the invention is equally applicable to other computer systems having similar requirements. Specifically, the present invention may be implemented with both object oriented and non-object oriented programming systems. 
     Computer system 100 includes a central processing unit (CPU) 105, which may be implemented with a conventional microprocessor, a random access memory (RAM) 110 for temporary storage of information, and a read only memory (ROM) 115 for permanent storage of information. A memory controller 120 is provided for controlling RAM 110. 
     A bus 130 interconnects the components of computer system 100. A bus controller 125 is provided for controlling bus 130. An interrupt controller 135 is used for receiving and processing various interrupt signals from the system components. 
     Mass storage may be provided by diskette 142, CD ROM 147, or hard drive 152. Data and software may be exchanged with computer system 100 via removable media such as diskette 142 and CD ROM 147. Diskette 142 is insertable into diskette drive 141 which is, in turn, connected to bus 130 by a controller 140. Similarly, CD ROM 147 is insertable into CD ROM drive 146 which is, in turn, connected to bus 130 by controller 145. Hard disk 152 is part of a fixed disk drive 151 which is connected to bus 130 by controller 150. 
     User input to computer system 100 may be provided by a number of devices. For example, a keyboard 156 and mouse 157 are connected to bus 130 by controller 155. It will be obvious to those reasonably skilled in the art that other input devices, such as a pen and/or tablet may be connected to bus 130 and an appropriate controller and software, as required. DMA controller 160 is provided for performing direct memory access to RAM 110. A visual display is generated by video controller 165 which controls video display 170. 
     Computer system 100 also includes a communications adaptor 190 which allows the system to be interconnected to a local area network (LAN) or a wide area network (WAN), schematically illustrated by bus 191 and network 195. 
     Operation of computer system 100 is generally controlled and coordinated by operating system software. The operating system controls allocation of system resources and performs tasks such as processing scheduling, memory management, networking, and services, among things. 
     Allocating Objects 
     FIG. 2 is a flow chart of the steps used to allocate an object. This object allocation process will be explained with reference to FIG. 3, which is a block diagram of a memory 310, including multiple objects 320, 330, and 340, and a free space 350. As shown, each object, such as object 320, includes a header portion 360 and a data portion 370. The header 360 holds two bit fields 364 and 366 for the &#34;hasBeenHashed&#34; and &#34;hasHashField&#34; codes, respectively. 
     When system 100 receives an instruction to allocate an object (step 210), it first determines an available location or space for the object in memory 310, such as RAM 110 (step 220). Once a location is identified, system 100 allocates the location for the object and assigns the object to that location (step 240). System 100 (step 260) also adds to the header for the object two bit fields for the &#34;hasBeenHashed&#34; and &#34;hasHashField&#34; codes (step 250) and initializes the bit fields to &#34;0&#34;. 
     Hashing 
     Systems consistent with the present invention perform not only a unique object allocation process, see FIG. 2, but also employ a specific hashCode() operation, which is illustrated in the steps of FIG. 4. In general, when a program initiates the hashCode() operation on a specific object, system 100 performs the following steps: 
     
         ______________________________________int hashCode(Object obj) {   obj-&gt;hasBeenHashed = 1;   if(obj-&gt;hasHashField == 0)       return address(obj);   else       return obj-&gt;hashField;______________________________________ 
    
     This pseudo-code explains that system 100 assigns a &#34;1&#34; value to the hasBeenHashed field of the object (&#34;obj→hasBeenHashed=1) (step 410). If system 100 determines that the hasHashField for the object is still set to &#34;0&#34; (&#34;if (obj→hasHashField=0)&#34;) (step 420), then system 100 returns the object&#39;s memory address (&#34;return address(obj)&#34;) (step 430). Otherwise, the object&#39;s hasHashField is &#34;1&#34; (step 420), which indicates that the object has a hash field, and system 100 returns the hash value in the object&#39;s hash field (step 440). As explained below, hashed objects that survive a garbage collection cycle acquire a hash field that contains the object&#39;s address in memory before it was relocated during the cycle. 
     Garbage Collection 
     Systems consistent with the present invention employ a compacting garbage collecting function in which the memory space for dead objects is reclaimed for later use. The system&#39;s garbage collector also relocates surviving objects to compact the used memory space and reduce fragmentation. Garbage collection generally takes place when specifically initiated by an application or when the memory is full and additional space is required for program execution. FIG. 5 is a flow chart of the steps of a compacting garbage collector in accordance with an implementation of the present invention. 
     In general, the garbage collector inspects the hash bits in the header of each surviving object in memory (step 510). If the hasBeenHashed bit is set to &#34;0&#34; (step 520), which means that the object has not been hashed, then the garbage collector determines an available location for the surviving object in the memory (step 580), and copies the surviving object to the new location and updates any program references to the object to reflect the object&#39;s new address (step 590). 
     Otherwise, the garbage collector checks the contents of the hasHashField (step 530). If it determines that the hasBeenHashed field is set to &#34;1&#34; but the hasHashField is set to &#34;0&#34; (step 530), meaning the object has been hashed but has no hash field, then the garbage collector performs steps 540 to 570. Specifically, the garbage collector determines an available location for the surviving object in the memory (step 540). The major difference between this step 540 and step 580 is that step 540 considers the object&#39;s new, larger size as a result of appending a hash field at the end of the object to hold the object&#39;s hash value, which may be the object&#39;s address before being relocated by the garbage collector. 
     After the garbage collector finds a new location for the surviving object (step 540), it allocates a hash field adjacent to the new memory location for the object (step 550 and stores the object&#39;s hash value in the new field (step 560). Then, the garbage collector sets the object&#39;s hasHashField to &#34;1&#34;, (step 570) which indicates that the object has a hash field with a value, and copies the surviving object to the new location and updates any program references to the object to reflect the object&#39;s new address (step 590). 
     If, however, both the hasBeenHashed and hasHashField field are set to &#34;1&#34; (step 530), in which case the surviving object already has a hash field with a hash value, then the garbage collector simply performs the relocating, copying, and updating steps 580 and 590. 
     With this procedure, the garbage collector relocates hashed objects while compacting all of the surviving objects in the memory. 
     FIG. 6A is a block diagram of memory 310 used to illustrate an example of the process used to relocate surviving objects and to compact the space in memory 310 for surviving objects. Initially, memory 310 includes multiple objects 610, 620, 630, and 640, with two one-bit fields (614, 624, 634, and 644) (616, 626, 636, and 646) in the header portion for a hasBeenHashed bit and a hasHashField bit. Because memory 310 is not full, it also includes free space 650. Each object is located at a particular location, which is noted in the figure by the corresponding addresses, ADDR1 for object 610, ADDR2 for object 620, ADDR3 for object 630, and ADDR4 for object 640. 
     As shown, none of the objects, except for object 640, has been hashed. Object 640 has been hashed, as indicated by the hasBeenHashed field 644 set to &#34;1&#34;, but has no hash field, as indicated by the hasHashField 646 set to &#34;0&#34;. Because in this example object 620 is no longer referenced, the garbage collector reclaims the space for that object. 
     After reclaiming the space for object 630, the garbage collector relocates object 640 to a new location at ADDR4&#39; (which is this case is the same as ADDR3), as seen in FIG. 6B. When relocating object 640, the garbage collector appends a hash field 648 for the object&#39;s old address (&#34;ADDR4&#34;) and sets the object&#39;s hasHashField to &#34;1&#34;. In this way, the garbage collector relocates surviving object 640 and compacts the objects in memory 310 to reduce fragmentation. In this way, object 640&#39;s hash value, i.e. ADDR4, remains the same despite the fact that the object was relocated to ADDR4&#39;. 
     Although this example shows the free space 650 at the bottom or behind the space occupied by objects, in practice free space may be scattered throughout memory 310. By reducing memory fragmentation, the garbage collector reduces the number of free spaces within memory 310 and compacts all surviving objects into the fewest number of memory segments. 
     Generational Systems 
     Generational memory systems allocate objects in a small &#34;young&#34; space, as opposed to &#34;old&#34; space assigned to objects that have been in existence for a sufficiently long time according to certain criteria. Such systems improve performance by keeping new and active objects in the small region of memory, which can be garbage collected more efficiently. However, restricting new objects to a small area of memory may negatively affect the distribution of hash values. In general, most objects are hashed while they are still young and therefore receive a hash value from the limited range of addresses in the young space. For example, a typical young space may be 512 kb. Assuming word-aligned objects, the maximum number of different hash values is 128 k or just 17 bits. 
     To recover a good distribution of hash values, a pseudo-random number can be combined with the object&#39;s address before returning it as the hash value. The random number expands the range of hash values to 32 bits (or another desirable size). The random number stays constant for the duration of one collection cycle of the young space. After compaction of the young space, the current random number is no longer needed because the garbage collector has internalized the hash values for all objects that used it. The garbage collector then replaces the random number by a new one so that in the next cycle through young space, an object that is hashed for the first time will receive a new hash value, even if other objects occupied the same address during a previous cycle. 
     Conclusion 
     Systems consistent with the present invention thus implement a hashCode() operation that has high efficiency and good distribution properties for handle-less compacting memory systems. The process requires only 2 bits of space in the majority of objects that have not been hashed, and 2 bits plus a word (or whatever size hash value is desired) in objects that have been hashed and subsequently relocated. 
     In summary, the object&#39;s address is its hash value for as long as possible, i.e., until the object is relocated. When relocation happens and the address of the object changes, the object is expanded to internalize the hash value, which is the object&#39;s address before relocation. Finally, in memory systems where certain (or all) areas are never compacted, this hash code implementation automatically reverts to a solution, which uses just 2 bits of additional space over the space-wise optimal technique of using object addresses in non-relocating systems. 
     The foregoing description of an implementation of the invention has been presented for purposes of illustration and description. It is not exhaustive and does not limit the invention to the precise form disclosed. Modifications and variations are possible in light of the above teachings or may be acquired from practicing of the invention. For example, the described implementation includes software but the present invention may be implemented as a combination of hardware and software or in hardware alone. The scope of the invention is defined by the claims and their equivalents.