Abstract: A computer implemented transaction processing system is presented for processing transactions between an application and one or more transaction processors. The system utilizes a first communication link between the application and a transaction processor interoperability component. Then, the system determines which of the one or more transaction processors will process transactions for the application and establishes a communication link between the transaction processor interoperability component and the transaction processor that will process transactions for the application.

Abstract: A method and system for filtering a list of data elements within an object-oriented environment are disclosed. According to the present invention, a filter object is created that supports a filter method which discriminates data elements within an input list utilizing a filter criterion. A message is then sent to the filter object specifying an input list of data elements to be filtered. In response to receipt of the message, data elements within the specified input list are discriminated utilizing the filter criterion. In one embodiment, one or more filter objects are registered with a finder object such that a list of data elements satisfying a search criterion produced by the finder object are automatically furnished to the filter objects as an input list.

Abstract: An interprise computing manager in which an application is composed of a client (front end) program which communicates utilizing a network with a server (back end) program. The client and server programs are loosely coupled and exchange information using the network. The client program is composed of a User Interface (UI) and an object-oriented framework (Presentation Engine (PE) framework). The UI exchanges data messages with the framework. The framework is designed to handle two types of messages: (1) from the UI, and (2) from the server (back end) program via the network. The framework includes a component, the mediator which manages messages coming into and going out of the framework.

Abstract: A computer system employing a microkernel executes two different tasks, e.g., operating systems, yet uses common shared libraries. Rather than each task setting up its own libraries, during compile a global offset table is set up for each task so that the tasks can use common shared libraries. An abstractions layer is established to allow the tasks to share the global offset table, and thus to use common shared libraries. Threading package related services are resolved via the abstractions mechanism. This abstractions mechanism includes services implemented as operating system abstractions, and include thread creation, exit from a thread, etc. Abstracted functions utilize pointers to runtime environment-specific functions, and are utilized by the task's runtime environment.

Abstract: A cross-domain data transfer technique is disclosed in which page remapping operations are eliminated in situations where physical memory addresses can be passed across domains. By passing physical memory addresses across domains instead of virtual memory addresses, the page remapping operations necessarily associated with passing virtual memory addresses across domains can be avoided in many cases. With the receipt of data across domains, page remapping operations are able to be deferred until the data is received in a domain that needs to touch the data. In certain cases, the transfer of data can be completed without ever having to map in the data to the receiving domain's address space. With the transmission of data across domains, where possible the pages are borrowed in their physical form. The invention can be embodied in many ways, including system, apparatus or method forms.

Abstract: A computer network is disclosed as including at least one network client memory, a network operating system executing in the network client memory for operating the computer network and for providing access to network services, and a network application executing in the network client memory for performing an application function. The computer network also has a plurality of network devices interfaced to the network operating system and available to the network application and the network operating system for performing the network services. Each network device provides at least one specific network service and has an object component in the network client memory representative of the network device. Each object component includes an interface such that the network application is in direct communication with the interface of each object component. Accordingly, the network application communicates directly with each of the object components.

Abstract: Disclosed is a method for providing synchronization of a transaction in a data processing system where the transaction involves a plurality of agents participating in the transaction and one coordinator for coordinating the transaction. The agents include at least a middleman which coordinates a set of at least one of the agents. A vote is sent indicating the availability or non-availability to commit from each of the agents to the coordinator. The coordinator determines a commit or backout decision when all the votes are received. A Not Known decision message is sent from the middleman to each of the agents in the set available to commit if the decision is not available at the middleman because of a failure. The Not Known decision message stops resynchronization of each of the available agents. If the middleman has responsibility for resynchronization then, on availability of the decision at the middleman, a resynchronization message is sent to each of the available agents.

Abstract: A system and method for adding a queue entry containing message data to a queue shared by communicating, sequential processes includes an enqueue instruction. The enqueue instruction attaches a queue entry to either the tail or the head of the shared queue, as specified by an application programmer. Execution of the enqueue instruction includes blocking access to the queue by other processes, updating queue linkages, activating processes waiting on entries being made to the queue, monitoring interrupts, and validating the appropriate queue data structures. If desired, in lieu of adding a queue entry containing message data to the queue, the enqueue instruction inserts an event indicator into the shared queue structure, thereby providing synchronization capabilities between communicating processes.

Abstract: According to the first aspect of the present invention, a communication manager is interposed between a common platform having a plurality of windows and an extensible Window-based Elaboration Language (WELL) system. The communication manager uses a template to convert data between a visible object rendered in the common platform and a data structure discernible by a computer. An extensible WELL kernel activates a required service module in response to an instruction entered by a user through the common platform and transmitted via the communication manager. According to the second aspect of the present invention, an agent-role server having the foregoing configuration is installed as a client of specific role servers each having the foregoing configuration. Thus, an interactive information system having an agent capability is constructed.

Abstract: In summary, the present invention is a multithreaded computer system having a memory that stores a plurality of objects and a plurality of procedures. The system uses a first global hashing procedure to service requests for the hashcodes of objects that do not have hashcodes, a local object-specific hashing procedure to service requests for hashcodes that have a recently generated hashcode, and a second global hashing procedure to service requests for the hashcodes of objects that have their hashcodes stored with the object. The global object hashing procedure has instructions for creating for each object a local object-specific hashing procedure. The local object hashing procedure includes as private data a hashcode and instructions for retrieving the hashcode. The second global hashing procedure includes instructions for retrieving the hashcode from the object.

Abstract: A method and system for efficiently handling events occurring in an environment in a data processing system. The data processing system includes multiple environments and objects that may be used in different environments. Each object includes an action that is triggered in response to an event. An event manager object is created for handling events from different environments. Events are registered for the objects. An action is triggered using the event manager object in response to detecting an event occurring in the data processing system, wherein events occurring in an environment are efficiently handled.

Abstract: An extensible and replaceable network-oriented component system provides a platform for developing network navigation components that operate on a variety of hardware and software computer systems. These navigation components include key integrating components along with components configured to deliver conventional services directed to computer networks, such as Gopher-specific and Web-specific components. Communication among these components is achieved through novel application programming interfaces (APIs) to facilitate integration with an underlying software component architecture. Such a highly-modular cooperating layered-arrangement between the network component system and the component architecture allows any existing component to be replaced, and allows new components to be added, without affecting operation of the network component system.

Abstract: Data structures, methods and devices for reducing computing overhead by utilizing threads which are effective to listen for requests for new connections, for new requests for services, and process requests for services in a distributed client/server-based object oriented operating system are disclosed. In one aspect of the invention, a method of processing a request for service from a client, involves listening for a request using a first server side thread which is effective to listen for and process requests on a connection, reading the header of the request using the first server side thread, and processing the request. In another aspect of the invention, a client writes a request for service on a connection between the client and a server using a first client side thread which is effective for dispatching requests and listening for replies to the request, and determines whether a reply from the server is expected in response to the request for service.

Abstract: A method and system for interfacing to type libraries are provided. In a preferred embodiment, the present invention defines an interface to a type library. The interface has a plurality of interface methods through which type information can be stored in and retrieved from the type library. A plurality of implementations of the defined interface are provided. A computer program is compiled using the defined interfaces to access the type information. When the compiled computer program is executed, it accesses the type information using one of the plurality of implementations. In a preferred embodiment, a type library contains type information to allow a compiler to bind to an instance of type at compile type (early binding).

Abstract: Methods and apparatuses for deferring, or delaying, the throwing of exceptions are disclosed. In one aspect of the present invention, an exception is raised during an invocation of a first object within an object-based system. The exception may be processed by catching the exception and making a first copy of the exception. Making the first copy of the exception includes storing the first copy of the exception in a dynamic memory. The first copy of the exception may then be processed by creating a runtime copy of the exception that is stored on an execution heap. The runtime copy of the exception may is then caught. The first copy of the exception is deleted from the dynamic memory, and the caught runtime copy of the exception is reprocessed. In one embodiment, processing the first copy of the exception includes throwing the first copy of the exception as a system exception.

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 method and system for managing data (i.e., objects) that are shared by multiple instances of a shared application program. A shared application program is an application program that is executing simultaneously on multiple computers and that has a copy of data that is being shared by each instance of the application program. In particular, each computer maintains a copy of the shared data. When an instance of the application program modifies the shared data, the modifications are sent to the other computers. Each of these other computers stores the data in its copy of the shared data, and each instance of the application program updates its user interface to reflect the modifications to the shared data. Thus, the users of the shared application program can cooperatively modify and view the shared data. For example, multiple users can be executing a word processing program on their computer and sharing a common document.

Abstract: A data processing system having shared, distributed personality neutral resources managed by a microkernel based operating system. The microkernel supports multiple personalities and manages common resources accessible to all personalities. The microkernel has a logical video buffer service that manages the creation, deletion, and maintenance of logical video buffers. Each personality uses the logical video buffers to store its character mode screen displays. The server maintains a handle to each logical video buffer that is accessible by all personalities. The microkernel also has an event window server that creates input queues and provides them to the personalities. The event window server receives all system input and places it into the appropriate personality's queue. The event window server provides APIs allowing personalities to read input queues, remove events from the queues, inject input events into the event window server, and register hot keys.

Abstract: A method, system and product for dynamically managing a pool of execution units in a server system, the pool devoted to a communication process between client and server processes. A minimum and a maximum number of execution units in the communication process poolis established. The minimum number of execution units is the number necessary to support a typical client load. The maximum number of execution units is an upper bound to support a peak client load without overloading the server system. As client requests for service are received by the server system, a number of determinations are made. It is determined whether assigning an execution unit to the request would bring a current number of execution units in the communication process pool over the maximum number of execution units. If so, the client request is rejected.

Abstract: The present invention is directed to a storage management system. More particularly if relates to a client/server library system for storing objects in the library system in batches by avoiding storing those objects in an intermediary storage, such as in a client storage space or in a cache, before storing them in the library system. The invention includes a library server, object server and library client, in which an application program interacts with the library client for storing objects, or binary large objects (blobs), in the object server under control of the library server. The present invention provides for an application program to read in objects into a memory space allocated and managed by the application program, or into an application program memory space allocated and managed by the library client.