Abstract: For each of one or more existing nodes in a file system, pending notifications of updates that have been performed on the node can be identified and sent to one or more other nodes. The file system can be opened for use, and one or more other nodes can be updated in response to the pending notifications while the file system is open for use. For example, this may be done in an operation for recovering from a crash of the file system. Also, a process for dealing with stale data in container nodes in a file system can include processing access requests according to a stale data scheme.

Abstract: A method and apparatus for sending and receiving messages between nodes on a compute cluster is provided. Communication between nodes on a compute cluster, which do not share physical memory, is performed by passing messages over an I/O subsystem. Typically, each node includes a synchronization mechanism, a thread ready to receive connections, and other threads to process and reassemble messages. Frequently, a separate queue is maintained in memory for each node on the I/O subsystem sending messages to the receiving node. Such overhead increases latency and limits message throughput. Due to a specialized coprocessor running on each node, messages on an I/O subsystem are sent, received, authenticated, synchronized, and reassembled at a faster rate and with lower latency. Additionally, the memory structure used may reduce memory consumption by storing messages from multiple sources in the same memory structure, eliminating the need for per-source queues.

Abstract: A method, system, and medium are disclosed for facilitating communication between multiple concurrent threads of execution using a multi-lane concurrent bag. The bag comprises a plurality of independently-accessible concurrent intermediaries (lanes) that are each configured to store data elements. The bag provides an insert function executable to insert a given data element into the bag by selecting one of the intermediaries and inserting the data element into the selected intermediary. The bag also provides a consume function executable to consume a data element from the bag by choosing one of the intermediaries and consuming (removing and returning) a data element stored in the chosen intermediary. The bag guarantees that execution of the consume function consumes a data element if the bag is non-empty and permits multiple threads to execute the insert or consume functions concurrently.

Abstract: A system and method for enabling interaction between one or more cloud applications and one or more local applications is provided. A web page of a cloud application is displayed on a web browser. The URL of the web page of the cloud application is extracted and analyzed. In other embodiments, the title or other metadata of the web page of the cloud application can be extracted and analyzed. An invoking application analyzes the URL, title, or other metadata to determine whether a local application is compatible with the cloud application. If it is determined that the local application is compatible, then the local application is activated to enable its interaction with the cloud application, and the functionalities of the local application may be used over the cloud application.

Abstract: An approach is provided that detects inbound messages being put to message queues managed by a middleware message queuing platform. The approach retrieves activity trace data corresponding to each of the inbound messages, with the activity trace data maintained by the middleware message queuing platform. The approach generates inbound event records corresponding the inbound messages based on the activity trace data. The approach then detects outbound messages retrieved from the message queues. Activity trace data corresponding to the outbound messages is retrieved and the approach generates an outbound event record for each outbound message. The approach receives a transaction request from a requestor that corresponds to a message. The approach retrieves and returns the inbound event records and outbound event records that correspond to the requested message. The retrieved event records are used for transaction tracking: to build transaction flow topologies and to report transaction performance metrics.

Abstract: Computer-executable code is automatically generated for a message flow in a message queuing infrastructure by determining a type of the message flow, inputting message flow parameters, and generating the computer-executable code based on the type of the message flow and the message flow parameters. The generation of code can also implement a design pattern, which is input based on the determined type of message flow. The computer-executable code can be, for example, Extended Structured Query Language (ESQL) code. The type of the message flow can identify, for example, a transformation requirement of the message flow. The transformation requirement can be, for example, one of (i) transformation from a first Extensible Markup Language (XML) message to a second XML message, (ii) transformation from an XML message to a Message Repository Manager (MRM) message, and (iii) transformation from a first MRM message to a second MRM message.

Abstract: The disclosure generally describes computer-implemented methods, software, and systems for modeling and deploying decision services. One computer-implemented method includes operations for identifying a sequence number of a first message, the sequence number indicating a position of the first message within a first sequence of messages. If a second message positioned prior to the first message in the first sequence is in a final processing state and the second message in the first sequence is a parent message, a plurality of child messages associated with the second message are identified. Each child message is associated with a sequence number indicating a position of the child message within a second sequence associated with the plurality of child messages. The computer-implemented method determines whether a child message positioned at the end of the second sequence is in a final processing state.

Abstract: Various embodiments provide message queue management techniques designed to reduce the likelihood of multi-component applications becoming nonresponsive and enable recovery options for individual components if they do become nonresponsive. In at least some embodiments, a message queue manager detects when a component of an application interface becomes nonresponsive and detaches the component from a shared message queue. The shared message queue can continue to process messages for other responsive components while messaging for the nonresponsive component is managed via a separate queue. The message queue manager can also notify a user regarding the nonresponsive component and provide the user with options to facilitate recovery of the nonresponsive component. Further, in at least some embodiments, the message queue manager can monitor a detached component and reattach the detached component when it becomes responsive again.

Abstract: A service exception resolution framework provides a centralized exception handling console (EHC) used to reprocess unfulfilled service requests that have result in service request exceptions. The EHC allows an operator to analyze multiple service request exceptions simultaneously from disparate applications and domains. The framework greatly reduces the time, cost, and resource expenditures needed to analyze and resolve service request exceptions and reprocess service requests regardless of the applications and domains from which the service request exceptions result.

Abstract: A sending process maintains a sending process language-specific object in memory in a format that is dictated by a programming language utilized to implement the sending process. The sending process is also configured to cause the sending process language-specific object to be translated to a receiving process language-specific object. The receiving process language-specific object is in a format that is dictated by a programming language utilized to implement a receiving process. The sending process might also expose an application programming interface or another mechanism through which the receiving process can provide data indicating the programming language with which the receiving process has been programmed. The receiving process language-specific object is then transmitted to the receiving process. The receiving process can utilize the receiving process language-specific object directly without deserializing the received object.

Abstract: Internode data communications in a parallel computer that includes compute nodes that each include main memory and a messaging unit, the messaging unit including computer memory and coupling compute nodes for data communications, in which, for each compute node at compute node boot time: a messaging unit allocates, in the messaging unit's computer memory, a predefined number of message buffers, each message buffer associated with a process to be initialized on the compute node; receives, prior to initialization of a particular process on the compute node, a data communications message intended for the particular process; and stores the data communications message in the message buffer associated with the particular process. Upon initialization of the particular process, the process establishes a messaging buffer in main memory of the compute node and copies the data communications message from the message buffer of the messaging unit into the message buffer of main memory.

Abstract: A method for looking up routing information for a person or program assigned to respond to an incident messages is explained herein. The method includes recognizing a routing code that was appended to either the object name or description. The routing code is recognized by a program that looks up the responders contact information in a table that correlates routing codes with designated responder information.

Abstract: A method of dynamically changing an allocation of queue pair resources to an operating system image running in virtualized environment receives a notification at the operating system image of a change in allocation of queue pair resources to the operating system image. The method queries a physical network adapter through a hypervisor to obtain a new queue pair resource count that will exist in the virtualized system after the change in allocation. The method performs a hashing operation in the operating system image using the new queue pair resource count to distribute transmit traffic among the queue pair resources that will exist in the virtualized system after the change in allocation.

Abstract: The present invention extends to methods, systems, and computer program products for orchestrating notifications between identity platforms and relying parties. Embodiments enable identity platforms to ensure that users consistently receive notifications, even when the identity platforms lack knowledge of which relying parties are notification capable and which relying parties are incapable of notification. Embodiments include an identity platform generating a frameset having a first content frame for displaying a notification and a second content frame for displaying a relying party web page. When the relying party is notification capable, the relying party web page includes functionality for removing the frameset established by the frameset and displaying the notification within the context of the relying party web page. When a client renders the frameset, the client retrieves and renders the relying party web page, removing the frameset and displaying the notification as directed by the relying party.

Abstract: A system and method for messaging in which, when a connection to a queue manager (220) is established, the queue manager allocates a Connection Identifier from the same name space (300) as Message Identifiers and returns this information (400) to the user. The user can then use this Connection Identifier as a Correlation Identifier, safe in the knowledge that it will not clash with any system generated Message Identifier or Correlation Identifier. A secondary benefit to this allocation scheme is that if a shared reply queue suffers from a build-up of messages then the Correlation Identifier in those messages can be used to identify the application expected to receive those messages.

Abstract: The COBOL reference architecture (CRA) system and the transactional workflow driver (TWD) provide an efficient and effective way to extend an existing application using modern architecture techniques without rewriting the existing application. The (CRA) system and TWD provide a way to generate new and interchangeable COBOL language functionality for multiple interactive types (e.g., transaction servers and/or transaction managers) running in various computing environments, including: a WebSphere message queue (MQ) transaction server; a Customer Information Control System (CICS) transaction server; an Information Management System (IMS) transaction server; and a batch transaction manager.

Abstract: Intranode data communications in a parallel computer that includes compute nodes configured to execute processes, where the data communications include: allocating, upon initialization of a first process of a compute node, a region of shared memory; establishing, by the first process, a predefined number of message buffers, each message buffer associated with a process to be initialized on the compute node; sending, to a second process on the same compute node, a data communications message without determining whether the second process has been initialized, including storing the data communications message in the message buffer of the second process; and upon initialization of the second process: retrieving, by the second process, a pointer to the second process's message buffer; and retrieving, by the second process from the second process's message buffer in dependence upon the pointer, the data communications message sent by the first process.

Abstract: The present invention is directed to a system, method, and computer-program product for protecting messaging consumers. According to one embodiment of the invention, a method for protecting messaging consumers can be provided. The method can include intercepting a message prior to arrival at a destination, comparing the message to one or more known message structures to determine the message structure, and determining if a message has a valid message structure for the destination. Intercepting a message prior to arrival at a destination may intercepts a message on a queue before the message is consumed by a consumer. Comparing the message to known message structures compares a message to message schemas, for example, XML schema, Java object definition or C structure format.

Abstract: In a computer system having a memory, a processor, and a network interface, a method for listening on multiple conferencing interfaces having the steps of loading a set of transport components into the memory; initializing each transport components of the set of transport components to listen on a particular conferencing interface using the network interface, each transport component of the set of transport components listening to a different conferencing interface; receiving an incoming call signal on the network interface having an incoming conferencing interface; processing the incoming call signal to detect the incoming conferencing interface; and launching an application based on the incoming conferencing interface. Other embodiments are also described.

Abstract: A method and apparatus of a device that changes the importance of a daemon process is described. In an exemplary embodiment, the device receives a message from a user process destined for daemon process, wherein the daemon process executes independently of the user process and the first daemon process communicates messages with other executing processes. The device further determines if the first message indicates that the importance of the first daemon process can be changed. If the first message indicates the importance of the first daemon process can be changed, the device changes the importance of the first daemon process. The device additionally forwards the first message to the first daemon process.

Abstract: An XLANG/s compiler detects convoy scenarios during compilation and generates runtime directives to correctly correlate incoming messages with business process instances. A convoy scenario, present in event driven processes, is defined by a correlation set initialized during a receive operation which is provided to a subsequent receive operation. The compiler detects those convoy scenarios by analyzing the control and dataflow of a XLANG/s program. Three convoy patterns are distinguished: (1) activation convoys, (2) uniform sequential convoys, and (3) non-uniform sequential convoys. XLANG/s allows declarative descriptions of convoy scenarios without requiring an understanding of the low-level details supporting their correct execution. Convoy scenarios are processed by statically analyzing a written workflow application to deduce the nature and type of convoy scenarios used by the application. Information is extracted at compile time to support the runtime infrastructure.

Abstract: A method, system, and medium are disclosed for facilitating communication between multiple concurrent threads of execution using an efficient concurrent queue. The efficient concurrent queue provides an insert function usable by producer threads to insert messages concurrently. The queue also includes a consume function usable by consumer threads to read the messages from the queue concurrently. The consume function is configured to guarantee a per-producer ordering, such that, for any producer, messages inserted by the producer are read only once and in the order in which the producer inserted those messages.

Abstract: A business object model, which reflects data that is used during a given business transaction, is utilized to generate interfaces. This business object model facilitates commercial transactions by providing consistent interfaces that are suitable for use across industries, across businesses, and across different departments within a business during a business transaction. In some operations, software creates, updates, or otherwise processes information related to a business rule business object.

Abstract: Methods and apparatus for resource resolution in computing environments using directed graphs are disclosed. A system includes a resource resolver and data sources that comprise records on resource classes of a provider network. The resolver receives a request to identify a set of resources of the provider network based on specified criteria. The resolver utilizes a directed graph representation of the data sources to identify query sequences to be directed to the data sources in response to the request. Each node of the graph represents a data source, and each edge represents a logical relationship between the data sources represented by the nodes connected by the edge. Each edge has a weight based on a performance metric obtained from a data source whose node is connected by the edge. The resolver issues queries of a preferred query sequence, identified using edge weights, to respective data sources.

Abstract: Processing posted receive commands in a parallel computer, including: posting, by a parallel process of a compute node, a receive command, the receive command including a set of parameters excluding the receive command from being directed among parallel posted receive queues; flattening the parallel unexpected message queues into a single unexpected message queue; determining whether the posted receive command is satisfied by an entry in the single unexpected message queue; if the posted receive command is satisfied by an entry in the single unexpected message queue, processing the posted receive command; if the posted receive command is not satisfied by an entry in the single unexpected message queue: flattening the parallel posted receive queues into a single posted receive queue; and storing the posted receive command in the single posted receive queue.

Abstract: Processing posted receive commands in a parallel computer, including: posting, by a parallel process of a compute node, a receive command, the receive command including a set of parameters excluding the receive command from being directed among parallel posted receive queues; flattening the parallel unexpected message queues into a single unexpected message queue; determining whether the posted receive command is satisfied by an entry in the single unexpected message queue; if the posted receive command is satisfied by an entry in the single unexpected message queue, processing the posted receive command; if the posted receive command is not satisfied by an entry in the single unexpected message queue: flattening the parallel posted receive queues into a single posted receive queue; and storing the posted receive command in the single posted receive queue.

Abstract: A method for preventing a browser timeout resulting from multiple requests sent from a client to a server is provided. In response to receiving a request from the client, an application thread is initialized on the server for submitting data to the client. The application thread is observed using a daemon observation thread. If a loading time of the application thread exceeds a timeout, the application thread is terminated. In response to terminating the application thread, an empty response is sent to the client. In response to receiving the empty response to the client, a determination is made whether to make an additional request to the server.

Abstract: Management of transaction message flow utilizing a transaction message queue. The system and method are for use in financial transaction messaging systems. The system is designed to enable an administrator to monitor, distribute, control and receive alerts on the use and status of limited network and exchange resources. Users are grouped in a hierarchical manner, preferably including user level and group level, as well as possible additional levels such as account, tradable object, membership, and gateway levels. The message thresholds may be specified for each level to ensure that transmission of a given transaction does not exceed the number of messages permitted for the user, group, account, etc.

Abstract: A low overhead method to handle inter process and peer to peer communication. A queue manager is used to create a list of messages with minimal configuration overhead. A hardware queue can be connected to another software task owned by the same core or a different processor core, or connected to a hardware DMA peripheral. There is no limitation on how many messages can be queued between the producer and consumer cores. The low latency interrupt generation to the processor cores is handled by an accumulator inside the QMSS which can be configured to generate interrupts based on a programmable threshold of descriptors in a queue. The accumulator thus removes the polling overhead from software and boosts performance by doing the descriptor pops and message transfer in the background.

Abstract: Systems and methods are provided for controlling a device. In one aspect, a method for controlling a device includes exposing a plurality of virtual device interfaces (13) for a device (11), wherein each virtual device interface (13) enables client control of a discrete function of the device, and controlling concurrent communication between the device (11) and two or more virtual device interfaces (13) operating on a single shared I/O connection (15) using a shared I/O port controlled by a device I/O module (12). The device I/O module (12) enables independent development of multiple device interfaces (13) that can seamlessly and independently operate on a single (physical) device communication connection (15), wherein the device shared I/O (input/output) module (12) implements functions to arbitrate and coordinate I/O activity between the device interfaces (13) and target device (11).

Abstract: In one embodiment, a computer system instantiates a queue manager configured to process a plurality of existing queue manager commands on messages in a message queue. The computer system instantiates a virtualized instance of a queue manager in a virtual layer associated with the queue manager in the computing system. The a virtualized queue manager instance provides supplemental queue manager commands usable in addition to existing queue manager commands, such that the queue manager can be used to implement the supplemental commands without substantial modification. The computer system receives an indication that a message in a message queue is to be accessed according to a specified command provided by the instantiated virtualized queue manager instance that is not natively supported by the queue manager and the virtualized queue manager performs the specified supplemental command as indicated by the received indication by performing one or more existing queue manager commands.

Abstract: Disclosed are systems and methods for distributing a plurality of transactions for parallel processing, which includes receiving a message, such that each transaction comprises information associated with a target object, wherein the target object is stored in a memory. The systems and methods further include parsing the messages into the plurality of transactions, transmitting the parsed transactions to a transaction queue, receiving a transaction from the transaction queue, determining the target object associated with the transaction, assigning the transaction to a particular processing queue based on the target object, and guaranteeing that subsequent transactions associated with the target object are assigned to the same processing queue and the same processor, which guarantees that the target object will be modified in correct sequence.

Abstract: A method of performing message operations includes receiving a message operation request identifying a queue, retrieving a list of the subset of partitions associated with the alias received in the request, and selecting at least one of the partitions within the retrieved subset. According to the method, the queue includes a plurality of partitions, the request identifies the queue with an alias, and the alias having a subset of the plurality of partitions associated therewith.

Abstract: A system includes a queuing module coupled to a first database and a delivery module coupled to a second database and the queuing module. The queuing module is operable to receive a plurality of communications from a plurality of applications and store the plurality of communications in the first database. The delivery module is operable to receive the stored plurality of communications from the queuing module, access end-user subscription information stored in the second database, determine, based on the end-user subscription information, one or more devices to receive the plurality of communications, and deliver the plurality of communications to the determined one or more devices on behalf of the plurality of applications. The end-user subscription information indicates one or more devices to receive the plurality of communications.

Abstract: Two threads may communicate via shared memory using two different modes. In a polling mode, a receiving thread may poll an indicator set by the sending thread to determine if a message is present. In a blocking mode, the receiving thread may wait until a synchronization object is set by the sending thread which may cause the receiving thread to return to the polling mode. The polling mode may have low latency buy may use processor activity of the receiving thread to repetitively check the indictor. The blocking mode may have a higher latency but may allow the receiving thread to enter a sleep mode or perform other activities.

Abstract: An approach is provided to allow virtual devices that use a plurality of processors in a multiprocessor systems, such as the BE environment. Using this method, a synergistic processing unit (SPU) can either be dedicated to performing a particular function (i.e., audio, video, etc.) or a single SPU can be programmed to perform several functions on behalf of the other processors in the system. The application, preferably running in one of the primary (PU) processors, issues IOCTL commands through device drivers that correspond to SPUs. The kernel managing the primary processors responds by sending an appropriate message to the SPU that is performing the dedicated function. Using this method, an SPU can be virtualized for swapping multiple tasks or dedicated to performing a particular task.

Abstract: An approach is provided that detects inbound messages being put to message queues managed by a middleware message queuing platform. The approach retrieves activity trace data corresponding to each of the inbound messages, with the activity trace data maintained by the middleware message queuing platform. The approach generates inbound event records corresponding the inbound messages based on the activity trace data. The approach then detects outbound messages retrieved from the message queues. Activity trace data corresponding to the outbound messages is retrieved and the approach generates an outbound event record for each outbound message. The approach receives a transaction request from a requestor that corresponds to a message. The approach retrieves and returns the inbound event records and outbound event records that correspond to the requested message. The retrieved event records are used for transaction tracking: to build transaction flow topologies and to report transaction performance metrics.

Abstract: A method, system and computer program product for transferring data between two applications over a local network connection. The invention establishes a socket connection between the applications and transfers data through the socket connection using a pseudo socket layer interface when the two endpoints of the socket connection are on the same host. Socket application program interface comprises socket buffers for sending and receiving data. A connecting application identifies and establishes a connection with a listening socket, and places data directly in the socket receive buffer of the receiving socket. If the other end of the socket connection is on a remote host, then data is transferred using underlying network facilities.

Abstract: A method for managing a shared buffer between a data processing system and a network. The method provides a communication interface unit for managing bandwidth of data between the data processing system and an external communicating interface connecting to the network. The method performs, by the communication interface unit, a combined de-queue and head drop operation on at least one data packet queue within a predefined number of clock cycles. The method also performs, by the communication interface unit, an en-queue operation on the at least one data packet queue in parallel with the combined de-queue operation and head drop operation within the predefined number of clock cycles.

Abstract: A method of queuing messages for communications between a first computer program and a second computer program, comprises: placing a plurality of messages in a queue, wherein each message has a message body; placing selector information on each message, wherein the selector information contains information as to which message is to be processed next; and using the selector information on a message to identify a next message for processing.

Abstract: A computer system and method of using a service oriented architecture (SOA) which runs business service application in a distributed network. The system has a channel dependent client layer containing a presentation layer and an application control layer, a channel independent service layer containing a business service layer and a data service layer and an integration layer. The integration layer can receive requests for service from the client layer and has a message generator for sending a request message to the service layer which is adapted to read the request message and in response, to run the business service application.

Abstract: An event queue managing module that prevents unnecessary events from continuously executing applications when an application execution environment resumes from a suspended state, and including: a queue managing unit for storing event objects reported from an event detector of a basic software unit into an event queue in order of occurrence of events and managing their queue; an event classification detection unit for detecting the event classification and parameter of the event objects whose queue is managed by the queue managing unit; a stop state detection unit for detecting a stop state of an application execution environment; and an event deletion unit for deleting an unnecessary event from the event objects stored in the event queue when the application execution environment is in the stop state.

Abstract: An event management structure for an embedded system, which supports multiple waiters waiting on the same event without replicating the events for each waiter, is provided. Notifications of events are received from entities within an embedded system. The event management architecture then posts the events to a central queue and generates a unique identification tag for each posted event. Additionally, entities within the embedded system are allowed to wait on specific events. More specifically, entities may request access to specific events based on the unique identification tag associated with a particular event. In further implementations, data associated with queued events may be provided to the waiters. In some implementations, events matching a specific description since a particular event, identified by its unique identification tag, may be requested by entities in the embedded system.

Abstract: An apparatus has a unit that receives plural messages, which belong to plural transactions and respectively have a pertinent transaction identifier, in an indefinite order; plural processors each having a queue storing the messages belonging to a transaction in charge, and outputting, after the messages belonging to one of the transactions in charge have become complete, the complete messages in the queue to a message processing unit; an allocation unit that outputs the received message to one of the plural processors, wherein one of the processors is identified based on the transaction identifier of the received message and an allocation rule predetermined for the transaction identifier; and a change unit that changes the allocation rule when activating or stopping the processor. When the change unit changes the allocation rule, each of the processors outputs at least messages for which re-allocation is necessary to the allocation unit.

Abstract: A method and system for performing processing tasks is disclosed. At a resource, a detection is made as to when the resource is available to perform a processing task. Usage of the resource for performing processing tasks associated with each client of a set of clients is monitored. A restriction limiting which processing task is to be assigned to the resource is identified. The restriction identifies a hierarchy amongst at least two clients of the set of clients. The hierarchy is based on the monitored usage. A query identifying the restriction is generated. The query is transmitted to a remote queue in communication with a plurality of independent resources. The plurality of independent resources includes the resource. A response is received from the queue. The response identifies a processing task.

Abstract: An apparatus for managing a multi-carrier in a communication system supporting the multi-carrier receives channel quality information of multi-carriers from a terminal and directs the terminal to change a primary carrier from a current primary carrier to one carrier of the multi-carriers on the basis of reference information including channel quality information.

Abstract: Internode data communications in a parallel computer that includes compute nodes that each include main memory and a messaging unit, the messaging unit including computer memory and coupling compute nodes for data communications, in which, for each compute node at compute node boot time: a messaging unit allocates, in the messaging unit's computer memory, a predefined number of message buffers, each message buffer associated with a process to be initialized on the compute node; receives, prior to initialization of a particular process on the compute node, a data communications message intended for the particular process; and stores the data communications message in the message buffer associated with the particular process. Upon initialization of the particular process, the process establishes a messaging buffer in main memory of the compute node and copies the data communications message from the message buffer of the messaging unit into the message buffer of main memory.

Abstract: A split proxy is configured for managing asynchronous MAPI communications between a client and a server by establishing a queuing structure for MAPI messages that make up the communications. The MAPI messages are subsequently exchanged between the client and the server using the queuing structure. Multiple remote procedure calls (RPCs) underlying the MAPI messages may be grouped together in batches for exchange between proxies of the split proxy. Also, when the client logs off from the server, a MAPI keep-alive process allows updates received at the server to be pre-populated to the split proxy for transfer to the client when it reestablishes a connection.

Abstract: A highly parallel, asynchronous data flow processing system in which processing is represented by a directed graph model, can include processing nodes that generate, and process, groups of dependent messages and that process messages within such groups in order. Other messages can be processed in whatever order they are received by a processing node. To identify a group of dependent messages, message identifiers are applied to a message. Processing of a message may generate child messages. A child message is assigned a message identifier that incorporates the associated message identifier of the parent message. The message identifier of the parent message is annotated to indicate the number of related child messages. When a group of messages is to be processed by a processing node in order, the processing node maintains a buffer in which messages in the group are stored.

Abstract: A computer-implemented method for handling instant messages based on state may include identifying an instant message, detecting a first state of a computing device, and handling the instant message based on the first state of the computing device. The method may further include receiving a first instant-message-handling rule, receiving a first definition of the first state, and associating the first instant-message-handling rule with the first state. A computer-implemented method for preventing the output of instantaneous notifications may include identifying an instant notification, detecting a first state of a computing device, and preventing the instantaneous notification from being sent to an output device of the computing device. Corresponding computer-readable media are also disclosed.