Abstract: A computer system includes a global machine for providing a virtual machine for a plurality of applications programs, including a calling applications program and a called applications program which is called by said calling applications program, and further provides a global state store for storing selected global state information for controlling selected operations. The calling program conditions the global state information stored in the global state store to a calling program global state, performs predetermined calling program processing operations and calls the called applications program. The called program, upon being called by the calling program, saves the calling program global information contained in the global state store.

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: 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 systems management subsystem provides resources for managing components and allows components to be manageable. In particular, state information about managed components is encapsulated into objects that are visible in the global name space. The state of a single component may be partitioned into subcomponents that are stored in separate objects. These objects may, in turn, be encapsulated into a single container object that is associated with the managed component. By placing the state information in the global name space, local processes and remote processes may both gain access to internal state information and properly manage the component.

Abstract: A processor detects a function which includes no function call instruction and no update of the return address /calculation register from an assembler program. After the detection, the processor outputs a special return address to the end of the function detected, and executes the assembler program. The processor stores a return address not only on the stack but in the return address/calculation register. When the special return instruction has been fetched, the return address is moved from the return address/calculation register without accessing to the stack.

Abstract: A system and method provide for synchronous operation of linked command objects in a general purpose software application. The software application provides a user with a variety of operations that manipulate available data objects. The software application manages the data objects in a number of contexts. Each context manages the existence and execution of a number of command objects. Each command object operates on one or more data objects in its context. To support synchronous operations that affect the state of data objects in more than one context, command objects are linked to each other. When one command object is executed, the context of the command object identifies a command object linked to the executed command object and initiates the execution of the linked command object via the context that manages that command object. This synchronization allows for synchronous undo and redone operations. The delete states of the command objects are also synchronized.

Abstract: A variety of methods and apparatus for managing deactivation and deletion of objects and server processes are taught. According to some embodiments of the present invention, a thread of execution termed the reaper thread systematically cycles through a computer process deactivating and/or deleting objects based upon a variety of criteria. One suitable criterion for object deactivation is based upon the amount of time lapsed since a client has requested services of the object. According to the timeout criterion, the reaper thread determines the period of time since the last client requested services from the object, compares this to a timeout value which may be defined by any suitable entity, and proceeds with deactivation and/or deletion accordingly. Object deletion may have a separate criterion or be specifically requested by a client. A deletion flag may be set to indicate that object deletion is requested.

Abstract: A software package installed on a UNIX system V computer system is repaired by installing a System V software patch package. During installation of the patch package using the pkgadd utility and scripts in the patch package, a backout software package is constructed. This backout package will, when later installed on the computer system using pkgadd, operate to restore the software in the computer system to its original state before installation of the patch package.

Abstract: A task manager for operating and performing management tasks called for by a system administration manager. The task manager includes a command task manager for performing command tasks, a function task manager for performing function tasks, and a remote task execution manager for performing remote or distributed task. In addition, the task manager includes a single application program interface for interfacing the command task manager, function task manager, and remote task execution manager with the system administration manager. The task manager further performs error handling and automatic logging operations. The task manager uses a task registration manager which stores the individual task descriptions and makes them available to the task manager.

Abstract: A system and method for automatically converting a compiled program that accesses objects stored in main memory into a program that accesses and updates persistently stored objects. An initial computer program includes original instructions for accessing and updating objects in at least a first object class. The original instructions access and update objects in a computer's main memory. The system automatically revises the initial computer program to generate a revised computer program by adding to the original instructions object loading instructions and object storing instructions. During execution of the revised computer program, the object loading instructions load a copy of one of the persistently stored objects into a corresponding object in the computer's main memory when the object is accessed for a first time.

Abstract: The present invention provides a C interface program that remotely operates with an object oriented repository by making the public properties and operations of the types in the repository available to Client programs written in the C language, or accessed via DLLs, or shared objects from other languages. Hence, Client program can execute all the operations on a repository, which is operating on a remotely located Server. The Client program source code can be created on the Server and recompiled on the Client platform without the necessity of making any changes to the code.

Abstract: An initializer which is a dynamically resolved method for initializing an object in a multiple inheritance object oriented system is introduced. The initializer is introduced in an ancestor class and can be inherited and overridden by subclasses. An overridden initializer can be invoked on an instance of a subclass to initialize an object in the system.

Abstract: A computer system is provided with an operating system that has a streams mechanism for providing streams between user-space processes and drivers. This mechanism permits a user-space process to set up a multiplexer driver for multiplexing and demultiplexing streams. To facilitate the dynamic allocation of new streams to the multiplexer driver, a stream server is associated with the multiplexer driver, the stream server keeping a pool of available streams from which it satisfies any requests for more streams made by the multiplexer driver. The stream server can request a special user-space process to supply new streams to top up the pool.

Abstract: A process for the management of multiple inheritance for application in a system or language employing persistent and shared objects. According to this process, the format of an object is maintained unchanged when it is being loaded from persistent space into virtual space. Moreover, each class producing an object is associated with an identifier of the class constant in all those applications utilizing the class as well as through all the recompilations. The structure of the object is thus independent of the address of storage in memory and of the code of the class producing this object. Finally, according to the present process, an addressing path permitting the management of inheritance is imposed via different tables.

Abstract: A system and method is disclosed that provides persistent capabilities for distributed, object-oriented applications running on generally available hardware. The disclosed system and method operate in a transparent distributed object system where inter-process messaging between the program objects is effected by paired transport managers, proxies and matched in-table and out-table slots. Each object needing to communicate with an object in another address space does so by transparently issuing messages to that object's local proxy. Each process provides a registrar that includes a secret code table wherein an object is registered with a unique, practically unguessable secret code. Anticipating the need to re-establish object-proxy links following a inter-process communications fault, proxies are made revivable, meaning that their links with corresponding remote objects can be revived following a communications interruption.

Abstract: Apparatus, methods, and computer program products are disclosed for optimizing programs containing single basic block natural loops with a determinable number of iterations. The invention optimizes, for execution speed, such program loops containing statements that are initially variant, but stabilize and become invariant after some number of iterations of the loop. The invention optimizes the loop by unwinding iterations from the loop for which the statements are variant, and by hoisting the stabilized statement from subsequent iterations of the loop.

Abstract: A variety of methods, apparatus, and data structures for managing transient and persistent distributed objects are disclosed. Objects for use as object references are described, both for transient and persistent objects. In one aspect of the invention, a data structure that is intended for use as an object reference for a transient object is disclosed having a set of endpoint addresses, an incarnation number, and an object key. These elements serve to uniquely identify and locate the transient object. In another aspect of the invention, an object that is intended for use as an object reference for a persistent object is disclosed having a host computer name, a locator identification, an object key, and a subobject identifier. The first three elements serve as an indirection to the persistent object and the third element is for use by the persistent object. These data structures enable a distributed object operating environment which integrates both transient and persistent objects.

Abstract: A compiler which generates object-oriented code from high level models is disclosed. The compiler uses a class graph to construct a finite intermediate automaton which is used in conjunction with an adaptive program to generate an object-oriented program in a target language. The intermediate automaton enables general case compilation of most combinations of adaptive programs and class graphs. The automaton also enables use of standard minimization techniques which reduce the size of the generated object-oriented code.

Abstract: A computer device driver for accessing compressed files held in archives in a memory device, the device driver comprising: means for reading a compressed file from an archive in the memory device, decompressing the file in RAM and retaining the decompressed file in RAM in whole or in part so that operations to the memory device can be performed on the decompressed file by the operating system without having first to write the decompressed file to the memory device. The device driver also comprises means for accessing the file in said RAM and changing the contents of the file; and for returning the file to the archive in said memory device.

Abstract: A name space registry manages name space data within a computer operating system including configuration and initialization data. The registry provides access to the configuration information by means of an application program interface (API) for programs which can operate with the name space registry. Backward source-code compatibility is provided for older applications by maintaining configuration and initialization files that the older applications use to store configuration and initialization data under their traditional file names and with the traditional contents. Thus the older applications can directly access these files. The registry provides newer programs access to these configuration and initialization files through API program calls.