Abstract: A system and a method for transmitting data between a local data processing system and a remote data processing system through an asynchronous transmission channel. To ensure synchronization between a local and a remote data processing device, it is proposed that when a first program of the local data processing device sends a call, such as a RPC (Remote Procedure Call) to a second program of the remote data processing device, at least one predefinable parameter of the data to be transmitted is stored in the local data processing device. When the remote data processing device sends a response to the local data processing device, the predefinable parameter is provided to identify and/or synchronize the response in the first program.

Abstract: A system is provided whereby software components acting as servers can be upgraded or installed when new functionality is required without client components which have made requests to these components being made aware of the upgrade initiated by their request. The servers can then respond to requests which would otherwise have caused errors in the client components.

Abstract: The disclosed technology enables electronic messages generated by one software application program to be routed to another remote software application program via a middleware oriented messaging (“MOM”) infrastructure using named/labeled routing nodes and queues. Network connection information corresponding to particular routing nodes and queues can be automatically and dynamically determined by periodically, and/or upon the occurrence of an event, transmitting/receiving informational messages between software processes associated with known/previously-encountered routing nodes and queues. The routing nodes and queues can be identified by names or labels, which can be dynamically mapped to network connection information at runtime in the event of an addition, deletion, or modification to a processor cluster via the information contained in the informational messages.

Abstract: A background event buffer manager (BEBM) for ordering and accounting for events in a data processing system having a processor includes a port for receiving event identifications (IDs) from a device, a queuing function enabled for queuing event IDs received, and a notification function for notifying the processor of queued event IDs. The BEBM handles all event ordering and accounting for the processor. The BEBM in preferred embodiments queues events by type with priority and by priority within type, and also handles sending acknowledgement to the device when processing on each event is concluded, and buffers the acknowledgement process. In particular embodiments the apparatus and method is taught as a packet processing router engine.

Abstract: A system and method for providing seamless communication with threads executing on an embedded computer. Using a DAT system, a programmer can test the communication interfaces of a thread via either a scripting program, any COM-compliant program, or a graphical test utility. The DAT system automatically formats a block of data that is transmitted between the embedded computer and a host computer and accounts for machine specific enumeration sizes, machine specific pointer sizes, machine specific structure alignment boundaries, machine specific integer sizes, and machine specific byte ordering.

Abstract: The Hat Trick deque requires only a single DCAS for most pushes and pops. The left and right ends do not interfere with each other until there is one or fewer items in the queue, and then a DCAS adjudicates between competing pops. By choosing a granularity greater than a single node, the user can amortize the costs of adding additional storage over multiple push (and pop) operations that employ the added storage. A suitable removal strategy can provide similar amortization advantages. The technique of leaving spare nodes linked in the structure allows an indefinite number of pushes and pops at a given deque end to proceed without the need to invoke memory allocation or reclamation so long as the difference between the number of pushes and the number of pops remains within given bounds. Both garbage collection dependent and explicit reclamation implementations are described.

Abstract: An application watchdog, comprising a dedicated watchdog counter in the hardware layer and a watchdog driver operating in the kernel mode layer of the computer operating system. The driver comprises a system thread configured to monitor a plurality of designated user applications operating in the user mode of the operating system and a message passing interface for receiving periodic signals from each of the user applications. The driver also uses an interface for transmitting timer reset commands to the dedicated watchdog counter. If the system thread receives a message from each of the designated user applications within an allotted period of time, the watchdog driver sends a timer reset command to the dedicated watchdog counter. Otherwise, the dedicated watchdog counter fails to receive the reset command and subsequently issues a system reset command. Early warning signals may be issued prior to system reset to alert system management.

Abstract: A linked-list-based concurrent shared object implementation has been developed that provides non-blocking and linearizable access to the concurrent shared object. In an application of the underlying techniques to a deque, the linked-list-based algorithm allows non-blocking completion of access operations without restricting concurrency in accessing the deque's two ends. The new implementation is based at least in part on a new technique for splitting a pop operation into two steps, marking that a node is about to be deleted, and then deleting it. Once marked, the node logically deleted, and the actual deletion from the list can be deferred. In one realization, actual deletion is performed as part of a next push or pop operation performed at the corresponding end of the deque.

Abstract: A system and method is provided for implementing a thread safe request queue. The request queue is preferably implemented using a circular array and atomic operations are preferably used for non-blocking functionality. In a preferred embodiment of the present invention, the request queue is capable of simultaneous thread release so that threads dequeue only when they are ready to be processed.

Abstract: A single atomic instruction is used to change up to four disjoint areas in memory concurrently in an extended compare and swap operation, replacing traditional locks for serialization and providing recovery for all queue manipulations. Use count-based responsibility passing is employed so that any number of tasks can read the various message queue chains, concurrent with queue updates being made. A summary queue update sequence number is maintained to provide concurrent chain update detection, so that any number of tasks can add elements to the end, or remove elements from the middle (i.e. any where in the chain) concurrently. Concurrent footprinting is used with chain manipulation, so that all (or none) of the chaining indicators and a footprint are set with a single, non-interruptible instruction, making it possible for recovery to always take the correct action.

Abstract: A queue manager monitors status of a server queue in a network server and status of a device queue in a peripheral device at the same time. A user interface displays the status of jobs in the server queue and device queue on the same display and allows a user to manipulate any of the jobs on either queue using the same user interface.

Abstract: Automatic message-based module invocation within a transactional message system is described. The modules can be software components, executable program files, etc. In one embodiment, a system includes one or more queues, a trigger store, and a trigger service. Each queue is capable of receiving messages. The trigger store includes one or more triggers, where each trigger is associated with a queue, and has associated therewith one or more rules, where each rule has a condition and an action. The trigger service is designed to, upon receipt of a message in a queue, check the condition of each rule of each trigger associated with the queue, to determine if the message satisfies the rule's condition. If such satisfaction occurs, then the action of the rule is performed, which can include invocation of a module. The rules may be short-circuit rules, non-destructive rules, and/or destructive rules, and may be checked in either a concurrent or serial manner.

Abstract: A portable thread environment comprising: an application programming interface configured to support multiple application program tasks with each task comprised of one or more threads; host adaptation logic for communicatively interfacing the tasks and threads with a host processing environment; and a scheduler configured to determine an execution order of the one or more threads based on one or more execution variables.

Abstract: A method and apparatus is provided for providing and integrating high-performance message queues. “Contexts” are provided that allow independent worlds to be created and execute in parallel. A context is created with one or more threads. Each object is created with context affinity, allowing any thread inside the context to modify the object or process pending messages. Threads in a different context are unable to modify the object or process pending messages for that context. To help achieve scalability and context affinity, both global and thread-local data is often moved into the context. Remaining global data has independent locks, providing synchronized access for multiple contexts. Each context has multiple message queues to create a priority queue. There are default queues for sent messages and posted messages, carry-overs from legacy window managers, with the ability to add new queues on demand. A queue bridge is also provided for actually processing the messages.

Abstract: The invention is a method of handling groups of services where the makeup of the groups can be determined and changed while the application is running. This is mainly accomplished through a group proxy, which is generated at run time, and which handles interactions with groups of services on behalf of one or more clients. The group proxy consists of a group logic shell which contains all the group-aware logic, and a service proxy for each service in the group which contains the necessary logic to interact with the particular service. The group proxy, which is given to a client for all of its interactions with the group of services, buffers calls from that client to its group when the group is unavailable because it is in transition. When the transition is complete the group proxy transmits the stored client commands to the group.

Abstract: A system for communications in a distributed computing environment is provided that includes an application layer (132), a proxy layer (134), a reference layer (136), and an object layer (138). The application layer (132) provides communications between an application (108) and an operating entity. The proxy layer (134) provides communications between the application (108) and a remote proxy (154). The remote proxy (154) is a local representative for a requested object (110) residing in an address space different from an address space in which the application (108) resides. The reference layer (136) provides communications between the remote proxy (154) and the requested object (110). The reference layer (136) includes communication protocol details to support transmission of messages across a network (106) linking the remote proxy (154) and the requested object (110). The object layer (138) includes the requested object (110).

Abstract: Improved techniques for managing propagation of data through software modules used by computer systems are disclosed. The improved techniques allow a plurality of threads running on different processors to propagate data between software modules by providing concurrent access to queued data by multiple threads. The techniques are particularly well suited for use with the STREAMS model that uses software models arranged in a stack to provide data communications.

Abstract: An event notification channel is provided in a computer controlled object oriented programming system having at least one event supplier object and a plurality of event consumer objects which may be run continuously without interruption and without loss of event notification to any consumer object irrespective of whether any of the consumer objects are off line for filter modification or any other maintenance purpose. The channel transmits events from supplier objects to a plurality of filter objects, each respectively associated with one of the plurality of consumer objects for passing only selected events to the associated consumer object. The system includes a plurality of proxy consumer objects, each associated with one of said consumer objects and between said filter object and said supplier object, whereby said proxy consumer object may receive supplier transmitted events on behalf of its associated consumer object.

Abstract: An arrangement is provided for inter-thread communications. A first group of thread includes at least one thread. A thread from the first group buffers a request in a first buffer. A thread from a second group of thread retrieves the request buffered in the first buffer. The thread from the second group performs an operation based on the request and generates a response. The thread from the second group buffers the response in a second buffer. A thread from the first group of thread retrieves the response from the second buffer.

Abstract: A distributed system framework and a distributed system architecture that includes three features: it can accommodate a large number of addressable entities, it is possible to connect any arbitrary group of entities together into a virtual network, and the infrastructure supports large numbers of concurrent virtual networks.

Abstract: A method, apparatus and program storage device for enabling the reading of data from a named pipe by a reader process while minimizing the use of system resources in an information handling system in which client and reader processes write data to and read data from a named pipe by issuing function calls to an operating system. A first reader process creates a named pipe if it does not already exist and issues a read function call to the operating system specifying the named pipe to attempt to read data from the pipe. If the read operation is successful, the first reader process repeats the step of issuing the read function call. Otherwise, the first reader process issues an activate-on-receipt function call to the operating system, specifying the named pipe, a new reader process to be activated upon the receipt of data by the named pipe and, optionally, data being passed from the first reader process to the new reader process, and then terminates.

Abstract: One or more queues store data information such as packets or data flows for later transmission to downstream communication devices. A real-time clock tracks current time and an advancement of a moving time reference, which is displaced with respect to the current time of the clock by an offset value. Thus, as current time advances, the moving time reference also advances in time. Upon servicing a queue, a time stamp associated with the serviced queue is also advanced in time. To monitor a rate of outputting data from the one or more queues, a processor device at least occasionally adjusts the offset value so that the moving time reference and values of the time stamps advance in relation to each other. Consequently, by tracking a relative time difference between current time of the real-time clock and a relative advancement of time stamps, a rate of outputting data information from the queue is monitored over time.

Abstract: In a message control apparatus for transferring messages between objects which belong to different processes, a message distributor distributes messages to queue buffers provided for each of target objects, and a thread controller simultaneously prepares a plurality of threads less than a maximum thread allocation number predetermined for each of processes and the target objects and takes out the messages to be given to a corresponding target object. Also, the maximum thread allocation number corresponding to a CPU serviceability ratio in the processes can be designated, and a part of the thread allocation number of the target objects with few thread number used is allotted to the maximum thread allocation number of the target objects with many thread number used.

Abstract: An invention for creating, sending, and using self-descriptive objects as messages over a network is disclosed. In an embodiment of the present invention, self-descriptive persistent dictionary objects are serialized and sent as messages across a message queuing network. The receiving messaging system unserializes the message object, and passes the object to the destination application. The application then queries or enumerates message elements from the instantiated persistent dictionary, and performs the programmed response. Using these self-descriptive objects as messages, the sending and receiving applications no longer rely on an a priori convention or a special-coding serialization scheme. Rather, messaging applications can communicate arbitrary objects in a standard way with no prior agreement as to the nature and semantics of message contents.

Abstract: A method and system for performing straight through processing is presented. The method includes monitoring a queue in order to detect a specific message. This message is parsed to take it from an external format into an internal format. The contents of the message include stages, with one stage being marked as active, and each stage having at least one step and a queue identifier. The processing specified in the steps contained in the active stage is performed, the active stage is marked inactive, and a new stage is marked active. The message is parsed back into the external format and directed to the queue specified by the queue identifier. Additional embodiments include a storage medium and a signal propagated over a propagation medium for performing computer messaging.

Abstract: A novel linked-list-based concurrent shared object implementation has been developed that provides non-blocking and linearizable access to the concurrent shared object. In an application of the underlying techniques to a deque, non-blocking completion of access operations is achieved without restricting concurrency in accessing the deque's two ends. In various realizations in accordance with the present invention, the set of values that may be pushed onto a shared object is not constrained by use of distinguishing values. In addition, an explicit reclamation embodiment facilitates use in environments or applications where automatic reclamation of storage is unavailable or impractical.

Abstract: A timer management system and method for managing timers in both a synchronous and asynchronous system. In one embodiment of the present invention, a timer management system comprises an application program interface (API) for providing a set of synchronous functions allowing an application to functionally operate on the timer. The timer management system further comprises a timer database for storing timer-related information. Furthermore, the timer management system comprises a timer services for detecting the expiring of the timer. A handle function of the timer services allows an asynchronous application, i.e., application in a multi-task system, to synchronously act on the timer. That is, when a timer in a asynchronous system times-out, the handle function allows the asynchronous application to act on the expired timer without incurring an illegal time-out message.

Abstract: A network scheduler for real time applications is described. The network scheduler supports scheduling of network packets in a multi-threaded operating system to insure correct scheduling order and to preclude kernel preemption of active threads. The network scheduler resides between a kernel (and device drivers) and multiple sessions at the user-level. The network scheduler uses input/output control primitives such as HOLD and RELEASE to control servicing of the queues of packets at the kernel or network device driver. The control primitives serve as a middleware interface to the underlying kernel or network device driver. The network scheduler functions as a proxy scheduler to manage the queues of packets at the kernel or network device driver.

Abstract: Within a processing of a sender task, a transmission request occurs that a data item be sent to a processing of a recipient task. The data item is then once stored in a queue from which the recipient task can retrieve the data item when the recipient task is thereafter activated. When the data item is stored, it is determined whether the queue already stores another data item. When no another data item is being stored, an activation request for activating the recipient task is outputted to the operating system. When another data item is being stored, no activation request is outputted. Within the processing of the recipient task, all the data items are retrieved from the queue. This decreases the activation/termination of the recipient task, reducing the processing load.

Abstract: The Messaging API Framework is an MQ Series gateway allowing distributed C++ applications to communicate with little effort. The system is designed with an object-oriented paradigm in mind, and seamlessly integrates MQ Series' messaging technology. The application developers do not need to obtain any in-depth knowledge of MQ Series, rather, they can use it the same way they do any other C++ objects. More specifically, where MQ Series is to be used to allow communication between two end points, namely, a CORBA-based application in a CORBA environment, and a destination application, a layer of abstraction, or Application Programming Interfaces (APIs), built on top of MQ Series APIs is highly desirable to alleviate the burden of CORBA-based application programmers to handle the complexity of MQ Series programming. This layer could take the form of a framework. The Messaging API Framework of the present invention is intended to be such a layer.

Abstract: A messaging system and method which allows parallel execution of related requests according their context-based sequence. A serialization processor receives each incoming message request from a messaging client, extracts a transaction identifier (TI), searches a state table for the TI, and, if the TI is found active in the state table, stores the request in a serialization queue and makes an entry for that TI with the state “queued” in the state table. After execution of the active request, its entry in the state table is cleared, and the queued request with the same TI is executed, whereupon its entry is changed from queued to active.

Abstract: Systems and methods are disclosed for a distributed computing infrastructure on a computer network comprising a plurality of computers. The distributed computing infrastructure (DCI) provides a software platform for creating, running, and managing distributed applications. DCI may include XML-capable software applications on a peer-to-peer network. DCI may include small, network-unaware applications called peerlets. DCI may include a system and method for creating complex distributed applications using pre-complied binaries. DCI may include a capability for multiple, independent collaborative sessions for distributed collaborative applications (e.g., chat, instant messaging, shared whiteboard, etc.). DCI may include systems and methods for reducing interactions between users and applications to archivable form and then playing back the interactions. DCI may include a system and method for automatic software retrieval on a peer-to-peer network.

Abstract: Disclosed is a method and computer program product for sending a persistent message in a transaction-enabled messaging and queuing system comprising a message queue manager responsible for transferring messages from a sender program to a receiving program via a message queue. A message is sent from the sender program to the message queue manager, the message being defined so as to permit the message queue manager to select whether to treat the message transactionally or non-transactionally.