Abstract: The present invention comprises a method for allowing a controlling object to interface with any number of user interface objects without requiring separate interface code for each user interface object and without restricting the user interface to certain predetermined designs. The present method provides objects called association objects that are interposed between a controlling object and each user interface object. Each kind of user interface object has a corresponding association object. The association object for a particular kind of user interface object contains code that allows the association object to interact with the specific kind of user interface object with which it is associated. Each association object also presents a standard interface to a controlling object, regardless of the kind of user interface object with which the association object is associated.

Abstract: There is provided a method in a heterogeneous computer system having at least two CPU's accessing a common memory, which memory has stored therein at least two distinct operating systems. Client and Server Programs are also stored in the common memory. The Client Program is adapted for making function calls to the Server Program and the Server Program is adapted for returning results of the called function to the Client Program. Moreover, the Server Program is adapted for making function calls back to the Client Program and for receiving results therefrom. The Client Program includes procedures for invoking a Server Program function, for converting parameters and result data from a format compatible with the first operating system to one compatible with the second operating system and for passing data between the Client CPU and the Server CPU.

Abstract: A data communication system for allowing communication between various devices and various operating systems across various types of networking systems. The data communication system includes an host computer system 10 with a display device 15 and a processor 17 for generating signals for the display device, at least one peripheral device 56, and a dynamic device driver 42 for allowing two-way communication between the peripheral device and the host computer system. The dynamic device driver includes an operating system specific portion 33, configured for the operating system of the host computer system, and an operating system independent device driver portion 34, configured for the peripheral device. The operating system includes a linking mechanism 19 for allowing two-way communication between the operating system specific portion and the operating system independent device driver portion, thus allowing two-way communication between the processor and the peripheral device.

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 method and apparatus for prioritized load-balancing among non-communicating processes in a time-sharing system involves a Load Balancing Repository (LBR) which interfaces with each process that is actively addressed by the CPU. A scheduler within each process provides the LBR with a load distribution for that process representing the ratio of high-priority sub-task load to low-priority sub-task load. The LBR determines a target ratio in the form of an aggregate load distribution ratio. The target ratio is reported back to each active process. For processes which are occupied with a relatively low proportion of high priority sub-tasks and which therefore exhibit a load distribution that is below the target ratio, the process scheduler will give up a portion of the time slice allotted to that process by the operating system when the load distribution of that process reaches the target ratio.

Abstract: A method is disclosed for performing function calls from a first program operating under control of a first operating system running on a first CPU; to a second program operating under control of a second operating system running on a second CPU. The method operates in a heterogeneous multiprocessing system having a common memory accessible by each of the CPU's and disposed for storing the two different operating systems that actively run and control resources of the system. The method begins by initiating the second program. The first program then makes calls to the second program to perform a specific function while passing parameters thereto for processing according to the specific function. The second program processes the parameters according to the function; and, converts the results from a format compatible with the second program to a format compatible with the first program.

Abstract: A method and system for modifying the behavior of existing executable code by injecting new code into an executable file is provided. The injection mechanism injects a reference to new code contained in a DLL into an existing executable file such that, when the code of the executable file is executed, the DLL is automatically loaded and the new code is automatically executed. A reference to the DLL is injected into the executable file by either modifying an import table of the file, which causes automatic loading of the DLLs referred to therein, or by adding DLL loader code to the file. The DLLs loader code uses an underlying operating system call to load the DLL. Further, the injection mechanism provides enhanced security by injecting security code and data into the executable file. The injected security code mechanism uses an incremental encryption and decryption process to encrypt and decrypt portions of the executable file in a more secure manner.

Abstract: A method and system for integrating external functions into an application environment. The system includes an application environment, and a predetermined interface for communicating with an external function library. External functions offered by the external function library are integrated into the application environment such that they can be used in a formula as if they were native functions. According to another embodiment, an application environment is provided which implements pass by asynchronous-access-mechanism variables, and enables an external function to have access to a user interface object after the function has returned from an invocation.

Abstract: A computer-implemented method and apparatus in a computer system for inter-process communication. A first procedure allocates a first buffer in a first memory space shared by the first procedure (e.g. a client process) and a second procedure (e.g. a kernel or server process). The first procedure then marshals arguments for communicating with the second procedure in the first buffer. The first procedure indicates that a message for the second procedure is being passed and passes a first reference to the first buffer in the first memory space to the second procedure. The second procedure detects the indication of the message by the first procedure. The second procedure then references the first buffer and copies the arguments contained in the first buffer into a temporary buffer. The second procedure can then deallocate the first buffer.

Abstract: A method of managing a system comprising a plurality of queues (F.sub.1, F.sub.2, F.sub.3, . . . F.sub.n) in which events are inserted by a transmitter (E), and a set of tasks (T.sub.1, T.sub.2, T.sub.3, . . . T.sub.n) that consume said events, the method being characterized in that each queue is associated with an indirection identifier (I.sub.1, I.sub.2, I.sub.3, . . . I.sub.n) and in that each time a transmitter seeks to insert a new event (e) in a queue, it consults the state of the indirection identifier, and where appropriate, inserts a "substitution" event (s) containing an identifier of said queue containing the new event in the queue indicated by said indirection identifier.

Abstract: In a system for dynamically linking a compiled procedure to referenced object components during execution of the compiled procedure, a native code loader loads the compiled procedure into a user's address space, and replaces a first instruction in the compiled procedure that references a first object component with a replacement instruction that invokes execution of a dynamic resolution procedure. While executing the compiled procedure, execution of the replacement instruction invokes execution of the dynamic resolution procedure. The dynamic resolution procedure locates the first object component, replaces the replacement instruction in the compiled procedure with a patch instruction, corresponding to the first instruction, that references the located first object component.

Abstract: A method and system that allows a client process to invoke a remote procedure. An operating system maintains a table with an entry for each remote procedure. Each entry of this table contains a signature that specifies a format in which parameters are exchanged between the client process and the remote procedure. When the client process requests the invocation of the remote procedure, the operating system creates a stack for the remote procedure. This stack is then mapped into the operating system's address space. By mapping the remote procedure's stack in this fashion, the operating system can simultaneously access the client's stack and the remote procedure's stack. The operating system then copies, in accordance with the remote procedure's signature, parameters directly from the client's stack to the remote procedure's stack. Once the parameters are copied, the remote procedure executes using the data contained on its own stack.

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 operating system for a non-uniform memory access (NUMA) multiprocessor system that utilizes a software abstraction of the NUMA system hardware representing a hierarchical tree structure to maintain the most efficient level of affinity and to maintain balanced processor and memory loads. The hierarchical tree structure includes leaf nodes representing the job processors, a root node representing at least one system resource shared by all the job processors, and a plurality of intermediate level nodes representing resources shared by different combinations of the job processors. The operating system includes a medium term scheduler for monitoring the progress of active thread groups distributed throughout the system and for assisting languishing thread groups, and a plurality of dispatchers each associated with one of the job processors for monitoring the status of the associated job processor and for obtaining thread groups for the associated job processor to execute.

Abstract: A macro program management system for facilitating edit operations of macro programs by clarifying associations between objects on a worksheet and macro programs. The macro program management system is equipped with a name information extraction unit for extracting names of worksheets, objects, and macro programs from application programs, and name list generation unit for listing the extracted names. This name list clarifies the association among the worksheets, objects, and macros. Further, the system has a listing/editing switching unit, coupled to the name list generation unit and to the macro editing unit, for switching the display screen either to a screen for showing the name list or to another screen for editing a macro program. With this unit, the operator can alternately select the listing screen or macro edit screen, thus facilitating development and maintenance of the application program.

Abstract: A method and associated structures for dynamically reformatting messages in a distributed computing environment based upon message content as represented by a description of the input message format and the output message format. An input message received by the formatter of the present invention is decomposed into a canonical format stored by the formatter for further use in a rapidly searchable data structure (FGA). The input message data is decomposed in accordance with an input message format description which describes the content of the input message in terms of atomic data types and structures. An output message is then generated in response to a user request and in accordance with a user provided output message format description. The output message format description describes the content of the output format in terms of atomic data types and attributes as well as functional operations performed to derive the output field value.

Abstract: Architectural support for generation isolation is provided through trapping of intergenerational pointer stores. Identification of pointer stores as intergenerational is performed by a store barrier responsive to an intergenerational pointer store trap matrix that is programmably encoded with store target object and store pointer data generation pairs to be trapped. The write barrier and intergenerational pointer store trap matrix provide a programmably-flexible definition of generation pairs to be trapped, affording a garbage collector implementer with support for a wide variety of generational garbage collection methods, including remembered set-based methods, card-marking type methods, write barrier based copying collector methods, etc., as well as combinations thereof and combinations including train algorithm type methods to managing mature portions of a generationally collected memory space.

Abstract: An apparatus and method for kernel level modules or drivers identifying message processing functions and for controlling execution of the message processing functions at the stream head, so that the functions are available at the stream head for adapting stream data interpretation, stream execution behavior, and the like in accordance with various system requirements such as requirements of devices or user processes.

Abstract: In general, in one aspect, the invention provides a modular application collaborator for providing inter-operability between applications including a plurality of connectors for communicating with a like plurality of applications and an interchange server. The interchange server includes an application collaboration module and service module. The service module transfers messages between connectors and the application collaboration module. The application collaboration defines the inter-operability between two or more applications. The interchange server service module includes a transaction service and an error service. Transactions are executed in the application collaboration module and the transaction service records each action and a compensating action for undoing an associated action.

Abstract: A computer system structures and manages programs and data as components of objects. Different versions of each object may exist. An object table, version table and component table are provided into which particular time data and address references are entered. By means of these tables, a component is copied only in response to an actual change. Unchanged components are associated with the different object versions by means of tables.