Abstract: A method for processing a first error message to produce a second error message in a component-based architecture. The component-based architecture includes a framework which is associated with a first lookup handler and is capable of embedding a first component associated with a first executable unit for handling data of the first component. The method includes the step of generating a hierarchy of lookup handlers, the hierarchy including the first lookup handler and a second lookup handler associated with the first executable unit when the first component comes into focus. Further, the method includes the step of processing the first error message through the hierarchy of lookup handlers to generate the second error message. Through the hierarchy, the first error message is first processed through the second lookup handler. If the second lookup handler is unable to process the first error message, the first error message is then processed through the first lookup handler.

Abstract: A system and method for expediting the replication of at least one specified object to a replica in a distributed computer system. A source object of a source replica determines that it has an urgent change to propagate through the distributed system, and informs a replication facility at the source replica of the urgent change. The facility extracts, or is provided with, the change information from that object, and the source replica communicates information representative of the change to a destination replica. A replication facility at the destination replica provides the change information to a destination replica object, which uses the information to make itself consistent with the source replica object.

Abstract: In scripting connections between objects within a component software architecture, a generic event processing module is provided to listen to all possible events. Objects registered for scripting are introspected to determine all events which may be fired by the object. In the case of the Java beans specification, this includes both Java-defined and user-defined events. One or more event listener classes for user-defined events may then be created, instantiated and added to the registered objects at runtime. When an event is fired and detected by a system listener, the appropriate event listener notifies the client, which may be a scripting component. The client may then take appropriate action. With an event processing module as described, event sinks need not be wrapped to become event listeners and event sources need not be wrapped to generate events in a specific manner. Events may be passed between sources and sinks without either knowing of the existence of the other.

Abstract: In a heterogeneous computer system including at least one Client CPU, at least one Server CPU and a common memory disposed therebetween for storing first and second operating systems that control operation of the Client and Server CPUs, respectively. There is provided Client and Server Programs, both of which are stored in the same common memory. The Client Program is executed by the Client CPU and the Server Program is executed by the Server CPU. A method and system is disclosed wherein the Server Program is adapted for making function calls to the Client Program and the Client Program is adapted for returning results of the called function to the Server Program. The Server Program includes Procedures for invoking a Client Program function, converting parameters and result data from a format compatible with the first operating system to one compatible with the second operating system.

Abstract: A software-implemented method for validating the correctness of parallel computer programs, written in various programming languages, with respect to these programs' corresponding sequential computer programs. Validation detects errors that could cause parallel computer programs to behave incorrectly or to produce incorrect results, and is accomplished by transforming these parallel computer programs under the control of a general purpose computer and sequentially executing the resulting transformed programs. The validation method is system-independent and is portable across various computer architectures and platforms since validation is accomplished via program transformation; thus, the method does not depend on the features of a particular hardware architecture or configuration, operating system, compiler, linker, or thread environment. The input to the validation method is a parallel computer program.

Abstract: A method of scheduling distributed transactions, on each initiation of a current transaction, identifies, among older transactions in process of execution, operations activated or waiting to be activated of the transactions that conflict with a particular operation of the current transaction. For each particular operation of the current transaction for which a particular number of conflicting operations have been identified, the method associates with the particular operation a counter the value of which is indicative of the number of operations conflicting with the particular operation. It decrements the value of the counter as and when operations conflicting with the particular operation terminate so as to activate the particular operation only when its counter indicates that there are no longer any operations conflicting with it.

Abstract: A method and apparatus for passing generic objects in a distributed system is disclosed. At the receiving process, the generic object is unmarshaled. However, the object of type T is maintained in its marshaled form. If the generic object is subsequently passed to another process, a copy of the marshaled form of the object of type T is passed. The object of type T is not unmarshaled until the generic object is received by a process that narrows the generic object into the object of type T.

Abstract: The invention noninvasively provides information relating to memory space allocation. Memory space allocation information is maintained in a location that is known or identifiable outside of the process for which the memory space has been allocated. A memory space allocator maintains the information in a descriptor block. The descriptor block is updated with every allocation or deallocation of memory space. In the preferred embodiment of the invention, the descriptor block exists on a page of memory having a size equal to the native page size of the machine on which it is operating. The memory allocator allocates memory space in units referred to as buckets that exist within a memory block. The descriptor block contains an identifier that identifies the memory space allocation information stored in that descriptor block as being controlled by a particular memory space allocator. The descriptor block also contains information that indicates how many pages are used and how many pages are free.

Abstract: A method and apparatus for communicating information. In particular, a method of communicating data between a plurality of applications, comprising the following steps. A first list is encoded. The first encoded list includes a first set of data objects. Each of the data objects includes data to be communicated. Next, the first encoded list is transmitted to a first of the plurality of applications and decoded for the first application. The first application accesses a first subset of data objects from the first encoded list. The first subset of data objects does not necessarily include all data objects in the first set of data objects. Next, the first application generates a second encoded list, where the second encoded list corresponds to the first encoded list. Then, the first application causes the second encoded list to be transmitted to a second application and decoded for the second application.

Abstract: A method and apparatus for accessing resource objects contained in a distributed memory space in a communications network, including dividing the distributed memory space into a plurality of memory pools, each pool containing a collection of resource objects, providing a plurality of resource manager objects, each resource manager object having an associated set of memory pools and a registry of network unique identifiers for the resource objects in those pools, and accessing a given resource object via its network identifier. Another aspect of the invention is to provide a relativistic view of state of a plurality of objects, each object generating a state vector representing that object's view of its own state and the state of all other objects, each object sending its state vector to other objects, and each object maintaining a state matrix of the state vectors.

Abstract: A method for exchanging information between two computer processes wherein the two computer processes deposit and retrieve information into a container rather than exchanging information directly with each other. The container stores the information based on the name of the information assigned by the depositing computer process, and maintains a dictionary of the names of the information contained in the container. Information is retrieved by the retrieving computer process by querying the container for the information by information name.

Abstract: A computer system for executing a binary image conversion system which converts instructions from a instruction set of a first, non native computer system to a second, different, native computer system, includes an run-time system which in response to a non-native image of an application program written for a non-native instruction set provides an native instruction or a native instruction routine. The run-time system collects profile data in response to execution of the native instructions to determine execution characteristics of the non-native instruction. Thereafter, the non-native instructions and the profile statistics are fed to a binary translator operating in a background mode and which is responsive to the profile data generated by the run-time system to form a translated native image. The run-time system and the binary translator are under the control of a server process.

Abstract: A method for providing stand-in objects, where relationships among objects are automatically resolved in an object oriented relational database model without the necessity of retrieving data from the database until it is needed. A “fault” class is defined, as well as fault objects whose data haven't yet been fetched from the database. An object that's created for the destination of a relationship whenever an object that includes the relationship is fetched from the database. When an object is fetched that has relationships, fault objects are created to “stand-in” for the destination objects of those relationships. Fault objects transform themselves into the actual enterprise objects—and fetch their data—the first time they're accessed. Subsequently, messages sent to the target objects are responded to by the objects themselves.

Abstract: A technique, system, and computer program for enabling multiple virtual machines to execute on a single server, using virtual machine pooling. This will result in a more scalable network environment, increasing the processing capacity of the server and decreasing the amount of time a particular request waits before being processed. Further, the integrity of an application's data will be protected from inadvertent overwriting by another application, because each application can be running in a separate virtual machine. Garbage collection, crashes, and hangs will no longer temporarily or completely halt a server: when one virtual machine halts, others can continue executing. Multiple environments can now execute on a single server, including different versions of virtual machines, increasing the mix of servlets that can be supported. Further, debugging can now occur concurrently with normal application execution, by isolating the debugging function to a specific virtual machine.

Abstract: A method and apparatus for implementing object-transparent invocation operates in conjunction with a data processing system having a memory, a sender and at least one method capable of performing a function to advantageously deliver a message to the at least one method capable of performing a function, thereby (i) delivering the message without requiring the sender to have specific knowledge of the identity, address, name or existence of the at least one method capable of servicing the message, (ii) delivering the message to the at least one method capable of servicing the message, and/or (iii) delivering the message to the at least one method capable of servicing the message, without the use of identity, address or name information provided by the sender.

Abstract: An improved method and system for visualizing an object-oriented program's execution in a manner that facilitates understanding, debugging, and tuning programs of arbitrary size and complexity by visually depicting a sequence of one or more messages to an object or between objects as a tree. Each node in the tree represents an object, and each edge represents a message between the objects. To manage the complexity of what is displayed, the user may elect to collapse subtrees so that they appear in abbreviated form. The user may expand collapsed subtrees so that they are visible in full. By selectively expanding and collapsing subtrees, the user can examine only those parts of the execution that are immediately relevant. The user may specify additional criteria for classifying subtrees, i.e., the conditions under which two subtrees are deemed equivalent. The system can then consolidate equivalent subtrees automatically, replacing them with a more general execution pattern that subsumes them all.

Abstract: A method and apparatus for performing actions while selecting objects on a user interface display. A user may select a first item in an area of a display controlled by a first process and drag that item to a second area on a display controlled by a second process. The second process may negotiate with the first process to provide certain data types, and based upon those data types, the second process will determine a list of actions in hierarchical fashion which may be performed upon the data. Such actions may include, but are not limited to, printing, sending electronic mail, and performing other actions in the computer system. Alternative and primary actions may also be specified by a user, such as by selecting various keys on a keyboard or other input device. Further, a user may specify that the second process display a list of actions which may be performed upon the selected item and allow the user to select an action from a list.

Abstract: A method and apparatus for managing dependencies in a distributed environment to ensure the safety of remote procedure calls is disclosed. Each remote procedure call between a calling procedure and a target procedure includes an expected time stamp and expected signature associated with the target procedure. The expected time stamp contains the creation time of the target procedure at the time the calling procedure was last compiled. The expected signature contains data type information of the target procedure formal parameters at the time the calling procedure was last compiled. The target procedure compares the expected time stamp to an actual time stamp maintained by the target procedure. If the two time stamps do not match, the target procedure compares the expected signature and an actual signature maintained by the target procedure to determine whether the data types of the formal parameters sent by the calling procedure are compatible with the data types expected by the target procedure.

Abstract: A method and system for invoking a subroutine from within an object and an object oriented system. The object oriented system is executing on a data processing system and includes a plurality of subroutines and classes. A subroutine may be called from within the object using an address for the subroutine. Callback arrays are employed within the object, wherein each callback array belongs to different class within the plurality of classes. Additionally, each object includes at least one slot identified by an integer. Each slot includes an address for one of the subroutines. A class identifier is accepted to identify one of the callback arrays within the object. An integer is employed to select a slot within the array identified by the class identifier. The address located within the selected slots of the identified array is employed to call a subroutine, wherein the complexity of managing callbacks are reduced.

Abstract: A technique, system, and computer program for improving access to shared resources in a computing system. The shared resources are grouped into application-defined resource sets. Mutual exclusion semaphores are used. A semaphore is associated with each resource set to provide mutually-exclusive (serialized) access to the resources in the set. The number of semaphores will be smaller (typically, much smaller) than the number of resource sets, so that a given semaphore will be associated with multiple of such sets. Thus, the set of semaphores is striped across the collection of resource sets. This greatly increases allowable parallelism in accessing shared resources, while reducing the number of semaphores that are required.