Abstract: Methods and apparatus provide for a busy resource encoder to allow for a finer control of spin versus yield decisions. Specifically, the busy resource encoder allows for the execution a first thread, where the first thread is using a particular resource. Additionally, the busy resource encoder allows for the execution of a second thread, where the second thread requires use of the resource which is locked due to first thread execution. The busy resource encoder creates a busy code to indicate the progress of the execution of the first thread in relation to use of the resource by the first thread. The second thread can then read the busy code to determine to execute one of a spin and a yield routine by the second thread.

Abstract: One embodiment provides a system that protects translated guest program code in a virtual machine that supports self-modifying program code. While executing a guest program in the virtual machine, the system uses a guest shadow page table associated with the guest program and the virtual machine to map a virtual memory page for the guest program to a physical memory page on the host computing device. The system then uses a dynamic compiler to translate guest program code in the virtual memory page into translated guest program code (e.g., native program instructions for the computing device). During compilation, the dynamic compiler stores in a compiler shadow page table and the guest shadow page table information that tracks whether the guest program code in the virtual memory page has been translated. The compiler subsequently uses the information stored in the guest shadow page table to detect attempts to modify the contents of the virtual memory page.

Abstract: Apparatus, methods, and computer program products are disclosed that improve management of a dynamic memory area. One aspect is a method that reclaims memory referenced by a finalizable-object that has been instantiated from a class definition that incorporates at least one parent class and one or more class-extensions into a class hierarchy. The method includes marking for retention a related memory reachable from a reference field of the finalizable-object, and adding the finalizable-object to a finalization set for subsequent invocation of a non-trivial finalize-method. The method also determines whether the portion of the finalizable-object that includes the reference field to the related memory is a class-extension that has a finalizer-free characteristic and conditions the marking for retention on that determination. Thus, a portion the finalizable-object's related memory can be more quickly reclaimed from a dynamic memory area.

Abstract: One embodiment provides a system that protects translated guest program code in a virtual machine that supports self-modifying program code. While executing a guest program in the virtual machine, the system uses a guest shadow page table associated with the guest program and the virtual machine to map a virtual memory page for the guest program to a physical memory page on the host computing device. The system then uses a dynamic compiler to translate guest program code in the virtual memory page into translated guest program code (e.g., native program instructions for the computing device). During compilation, the dynamic compiler stores in a compiler shadow page table and the guest shadow page table information that tracks whether the guest program code in the virtual memory page has been translated. The compiler subsequently uses the information stored in the guest shadow page table to detect attempts to modify the contents of the virtual memory page.

Abstract: Apparatus and methods are disclosed for a computation processor that can execute a semi-absolute branch instruction, as well as methods of operation and of generating the semi-absolute branch instruction.

Abstract: A mechanism is disclosed for storing one or more chunk-specific sets of executable instructions at one or more predetermined offsets within chunks of a chunked heap. The mechanism provides for storing a chunk-specific set of executable instructions within a portion of a chunk, where the set of executable instructions begins at a predetermined offset within the range of virtual memory addresses allocated to the chunk. The set of executable instructions, when executed, is operable to perform one or more operations that are specific to the chunk.

Abstract: A mechanism is disclosed for offset-based addressing in the chunks of a chunked heap. The mechanism provides for storing a side data structure within a portion of a chunk, where the side data structure begins at a predetermined offset within the range of virtual memory addresses allocated to the chunk. The side data structure comprises a plurality of entries, where each entry is associated with a corresponding section of the chunk. The mechanism provides for locating a particular entry in the side data structure corresponding to a particular section of the chunk by using the predetermined offset and an index derived based on the particular section, where locating the particular entry does not include performing any memory accessing operations or conditional branch operations to obtain an indirect reference to the side data structure.

Abstract: A mechanism is disclosed for offset-based addressing in the chunks of a chunked heap. The mechanism provides for storing a side data structure within a portion of a chunk, where the side data structure begins at a predetermined offset within the range of virtual memory addresses allocated to the chunk. The side data structure comprises a plurality of entries, where each entry is associated with a corresponding section of the chunk. The mechanism provides for locating a particular entry in the side data structure corresponding to a particular section of the chunk by using the predetermined offset and an index derived based on the particular section, where locating the particular entry does not include performing any memory accessing operations or conditional branch operations to obtain an indirect reference to the side data structure.

Abstract: A mechanism is disclosed for storing one or more chunk-specific sets of executable instructions at one or more predetermined offsets within chunks of a chunked heap. The mechanism provides for storing a chunk-specific set of executable instructions within a portion of a chunk, where the set of executable instructions begins at a predetermined offset within the range of virtual memory addresses allocated to the chunk. The set of executable instructions, when executed, is operable to perform one or more operations that are specific to the chunk.

Abstract: Apparatus, methods, and computer program products are disclosed that improve management of a dynamic memory area. One aspect is a method that reclaims memory referenced by a finalizable-object that has been instantiated from a class definition that incorporates at least one parent class and one or more class-extensions into a class hierarchy. The method includes marking for retention a related memory reachable from a reference field of the finalizable-object, and adding the finalizable-object to a finalization set for subsequent invocation of a non-trivial finalize-method. The method also determines whether the portion of the finalizable-object that includes the reference field to the related memory is a class-extension that has a finalizer-free characteristic and conditions the marking for retention on that determination. Thus, a portion the finalizable-object's related memory can be more quickly reclaimed from a dynamic memory area.

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 system and method provides dynamic and static type support for multiple definitions of individual types in a distributed object environment. Fully scoped object names incorporating prefixes are used to distinguish objects. The fully scoped names are used for both dynamic type determination through an interface repository and for statically compiled types in client and server stub routines. In the interface repository, a prefix naming context is provided for each root interface definition language context, allowing multiple definitions for objects with the same interface definition language object name, where each such definition resides in a separate prefix naming context. In one embodiment, the prefix naming contexts are defined by prefix interface definition objects. In another embodiment, the fully scoped object names are embedded by an interface definition language compiler in stub and skeleton code routines. RRS.

Abstract: Data structures, methods and devices for reducing computing overhead by utilizing different invocation paths for same process and different process invocations in a distributed client/server based computing system are disclosed. In one aspect of the invention, calls to a servant that do not share the same process as the requesting client are routed through a transport layer, and calls to servants that do share the same process as the requesting client are passed directly to the servant, thereby bypassing the transport layer. In another aspect of the invention, distinct remote and local method tables are provided to facilitate intelligent routing of requests. In still another aspect of the invention, the appropriate method table for an object reference is intelligently selected based upon the location of the identified object.

Abstract: A method for enabling an application program to communicate with a network server, includes the steps of downloading a document from a document server to the application program, downloading code from a code server associated with the document server to the application program, the code including a network protocol handler for the network server, and using the network protocol handler to communicate with the network server.

Abstract: Methods and apparatus for enabling an efficient generational scavenging garbage collection to be performed on a managed memory area are disclosed. According to one aspect of the present invention, a method for reclaiming memory space uses a managed memory area that includes a first area and a second area. The first area is arranged to store recently allocated objects, while the second area being arranged to store older objects. The method includes determining when a first section of the first area in which new objects are to be allocated is substantially filled. When it is determined that the first section is substantially filled, a garbage collection is performed on a second section of the first. After the garbage collection, the second section is set to support new object allocation such that new objects are allocated in the second section, while the first section is reset such that it is no longer arranged to support new object allocation.

Abstract: A method for enabling an application program to communicate with a network server, includes the steps of downloading a document from a document server to the application program, downloading code from a code server associated with the document server to the application program, the code including a network protocol handler for the network server, and using the network protocol handler to communicate with the network server.

Abstract: A method and apparatus for providing selective object locking is provided. First, a lock object is designated. The identity of the lock object is then made available to objects in an object calling hierarchy. The first object invoked by the calling thread obtains a lock on the lock object to protect data associated with the first invoked object. Other objects in the object calling hierarchy can relock the lock object to protect their data. The invention also provides for selective object locking by providing the capability for a calling thread to specify that no object locking is to be preformed, which causes objects invoked by the calling thread to not perform object locking.

Abstract: Methods and apparatus in an object oriented programming environment for invocation of objects with interface inheritance. An object reference using mtables contains two parts, more specifically, a pointer to the data for an object and a pointer to the methods on the object. The methods on the object are represented by a collection of mtables. An mtable for a given interface consists of pointers to mtables for inherited interfaces and pointers to functions implementing the operations declared in the interface. An mtable pointer in an object reference points to an mtable for an apparent interface of the object reference. Mtables for any inherited interfaces are reached by indirection from the mtables for the apparent interface.

Abstract: Data structures, methods, and devices for facilitating servant invocation in a distributed client-server based object oriented operating system are disclosed. In one aspect of the invention, descriptor data structures, which contain a typecode indicator, a marshaling function identifier, and an unmarshaling function identifier, are used to enable modules of application code to be shared between different objects, thereby facilitating servant invocation by increasing the amount of commonized code in the operating system. In another aspect of the invention, a server invocation object is used in the execution of a method call. In still another aspect of the invention, a commonized code base is used to process typecode interpreted and compiled calls to a server process.

Abstract: Apparatus, methods, and computer program products are disclosed for determining how to compile a program at runtime. A bytecode instruction associated with the program that can be compiled in multiple ways is retrieved and compiled in a particular way, typically the default way. At runtime, a virtual machine determines whether another way of compiling the bytecode instruction is more desirable and, if so, the bytecode is then recompiled the other way. In some embodiments, the portion of the program that contains the bytecode instruction to be recompiled is placed in a queue with other instructions that are to be recompiled. The virtual machine may examine changing requirements of the program that have developed at the program's execution in which the requirements are derived from profile data on each of the multiple ways the program can be compiled. The bytecode instruction within the program may be recompiled in a more preferred way based upon the profile data.