Abstract: A computer implemented method, system and/or computer program product is provided for managing a messaging queue in an asynchronous messaging system. A duration for which a message can remain on the messaging queue is determined. An age of the message on the messaging queue is monitored. The age of the message on the messaging queue and the determined duration is compared and a notification is generated based on the comparison.

Abstract: A method and system are provided that may centralize the management of applications that access the data of social networks via API calls. A central service may generate tokens at a generation rate that permit an application to access an API. The tokens may be distributed to queues associated with certain content types. The relative distribution of tokens to each queue may be determined by rules. A queue may release tokens to applications that function to access the content type associated with the queue. The token generation rate and rules may be selected to prevent violation of the rate limits for the API.

Abstract: A private cloud-based processing pipeline apparatus and method for its use is disclosed. A first load balancer directs data packets to one of a plurality of collectors. The collectors authenticate the data packet. Then a second load balancer receives the data packet from the collector and to direct the data packet to one of a plurality of extract transform load (ETL) frontends, where the data packet is converted from a platform dependent form into a platform independent form and loaded into a queue. Handlers then process the converted data packets. It is emphasized that this abstract is provided to comply with the rules requiring an abstract that will allow a searcher or other reader to quickly ascertain the subject matter of the technical disclosure. It is submitted with the understanding that it will not be used to interpret or limit the scope or meaning of the claims.

Abstract: In a network device, apparatus and methods perform precision time stamping. A time agent receives a master pace signal corresponding to a time representation based on a master real time clock in a master clock domain. A time accumulator accumulates time units one fill quantum at a time based on the master pace signal. The time accumulator decreases the accumulated time units by a leak quantum according to a local clock signal running at a higher frequency than the master pace signal. Correction logic periodically generates, at a granularity corresponding to the frequency of the local clock signal, an updated time representation in a target clock domain based on a residual number of time units in the time accumulator before depositing an additional fill quantum of time units in the time accumulator.

Abstract: Methods, systems, and apparatus, including computer programs encoded on a computer storage medium, are described for storing message data in a PubSub system. In certain examples, messages are received from a plurality of publishers for a plurality of distinct channels. The messages are ordered and stored in a plurality of buffers, with each channel having its own respective buffer. After a message has been written to a writable portion of the buffer for a channel, a pointer demarking a boundary between a readable portion of the buffer and the writeable portion of the buffer is advanced in an atomic operation. Following the atomic operation, the message resides in the readable portion and may be accessed by PubSub system components and/or processes. In general, one or more subscribers, components, or processes may read messages from the readable portion, in parallel.

Abstract: In an approach for generating transaction tracking data that is used to simulate a customer environment or test case scenario, a processor receives user input data, wherein the user input data includes, at least, an application topology constructed using a graphical user interface. A processor validates the user input data for, at least, supported environments of components of the application topology. A processor generates transaction tracking data based on, at least, the user input data.

Abstract: A middleware processor provisioning process provisions a plurality of processors in a multi-processor environment. The processing capability of the multiprocessor environment is subdivided and multiple instances of service applications start protected processes to service a plurality of user processing requests, where the number of protected processes may exceed the number of processors. A single processing queue is created for each processor. User processing requests are portioned and dispatched across the plurality of processing queues and are serviced by protected processes from corresponding service applications, thereby efficiently using available processing resources while servicing the user processing requests in a desired manner.

Abstract: Several different embodiments of a massively scalable object storage system are described. The object storage system is particularly useful for storage in a cloud computing installation whereby shared servers provide resources, software, and data to computers and other devices on demand. In several embodiments, the object storage system includes a ring implementation used to associate object storage commands with particular physical servers such that certain guarantees of consistency, availability, and performance can be met. In other embodiments, the object storage system includes a synchronization protocol used to order operations across a distributed system. In a third set of embodiments, the object storage system includes a metadata management system. In a fourth set of embodiments, the object storage system uses a structured information synchronization system. Features from each set of embodiments can be used to improve the performance and scalability of a cloud computing object storage system.

Abstract: A client connected to a communication network performs an access request to an object. An application server performs an application by an actual object according to the client request. An object pool connected to the client and the application server pools a proxy object corresponding to the actual object and holds the actual object management information. The application server notifies the object pool of an event according to the status change of the application. The object pool automatically updates the actual object management information according to the notification of the event from the application server.

Abstract: A method is described that involves referring to first information from a directory table in system memory. The first information includes location information and size information of a first slice of system memory where first tracing data is to be stored. The method also includes tracking the amount of tracing data stored in the first slice of system memory and comparing the amount against the size information. The method also includes, before the first slice of system memory is filled, referring to second information from the directory table in system memory, where, the second information includes location information and size information of a second slice of system memory where second tracing data is to be stored. The first slice is not contiguous with the second slice of system memory.

Abstract: A communication technique which includes determining, at least in part by comparing data associated with a packet that has been pulled from a received packet queue with a highest sequence number among packets that have been placed in the received packet queue, that the received packet queue has space available to receive a further packet. A receiver with which the received packet queue is associated is sent, based at least in part on the determination, a next packet.

Abstract: A method for utilizing process identifiers to invalidate cached data is disclosed herein. The invention is a method for associating persistently stored data with an identifier of the process which created it, such that when the process that created the data is no longer present on the machine where the data is stored the data may be marked as invalid to prevent the use of “stale” data.

Abstract: Deterministic message processing in a direct memory access (DMA) adapter includes the DMA adapter incrementing from a sub-head pointer, a sub-tail pointer until encountering an out-of-sequence packet. The DMA adapter also consumes packets between the sub-head pointer and the sub-tail pointer including incrementing with the consumption of each packet, the sub-head pointer until determining that the sub-head pointer is equal to the sub-tail pointer. In response to determining that the sub-head pointer is equal to the sub-tail pointer, the DMA adapter determines whether the head pointer is pointing to the next in-sequence packet. If the head pointer is pointing to the next in-sequence packet, the DMA adapter resets the sub-head pointer and the sub-tail pointer to the head pointer. If the head pointer is not pointing to the next in-sequence packet, the DMA adapter resets the sub-head pointer and the sub-tail pointer to the next in-sequence packet.

Abstract: A method for executing a plurality of processing requests performed by a physical computing system that is programmed to execute the processing requests for clients includes, with the physical computing system, assigning an identification number to a new processing request; with the physical computing system, placing the new processing request into a process eligible group if the identification number of the new processing request meets a criterion; and with the physical computing system, placing the processing request into a queued group if the identification number of the processing request does not meet the criterion.

Abstract: In distributed object computing, messages from a source node to a destination node are often required to be routed via one or more intermediate nodes. In order to enhance efficiency of the relay process, a message envelope of a message may include a node list field that specifies the routing path of the message. The communication protocol for communicating the message may specify that when a message is received into a particular node, the node analyzes the node list field. If the identity of the node is last in the node list field, then the node is the destination node and thus the node unmarshals the message. Otherwise, the node forwards the message to the next node in the field list without unmarshalling the message.

Abstract: Distributed computer systems prepare and instantiate snapshots by processing sets of nodes representing computer resources that are portions of a larger system. A user may choose to prepare or instantiate a snapshot containing all or only a portion of the data within the distributed computer system, such as a template of the distributed computer system. A template snapshot may be available in an electronic marketplace for other users to purchase and instantiate into a replica of the distributed computer system.

Abstract: A server node can monitor the status of servers in a server cluster. The node may receive an alert indicating that a server in the server cluster is unavailable. In response to the alert, the node can send instructions that cause pending remote procedure call requests to be canceled and then reissued to another server in the server cluster instead of to the first server.

Abstract: Through an asynchronous callback enhancement, a thread makes a non-blocking request (e.g., send, receive, I/O) to a message passing interface library, and a callback routine is associated with the request as an asynchronous callback to the thread. The callback is queued for execution in the requesting thread and so has a deterministic execution context. Callback queuing may occur in response to another thread detecting that the request is complete. Further control over callback execution is provided by state transitions which determine whether the thread is open to processing (e.g., executing) an asynchronous callback. Callback association is done by a broad or by narrow association routines. An application which has processes organized in ranks, each including a communication thread with associated callback(s), and multiple worker threads. Interruptible wait enhancements may also be present.

Abstract: Systems and methods for retrieving service request messages stored in a messaging queue and received by a queue in real-time. The service request messages are retrieved using a plurality of threads that comprise at least one retrieval criteria. Service request messages may be retrieved from the message queue or retrieved as they are received by the message queue in real-time using criteria in addition to or instead of the arrival time of the service request message which may also be referred to as the put-time. Service request messages may be requested and retrieved in an iterative process wherein multiple threads execute consecutively, concurrently, or a combination of both, in order to retrieve service request messages requested by an application.

Abstract: The techniques described herein implement an operating system that can reliably process time sensitive information in non real-time manner. Thus, the operating system described herein is capable of processing an instance of time sensitive input during a time period after the instance of time sensitive input is received (e.g., at a future point in time). To accomplish this, the techniques timestamp each instance of time sensitive input when it is received at a device. The techniques then store the timestamped instance of time sensitive input in a temporary queue, and make the timestamped instance available to the operating system at a time period after the time period when it is received, as indicated by the timestamp. Additional techniques described herein prioritize the activation of a driver configured to receive the time sensitive information during a boot sequence or a reboot sequence.

Abstract: A method of communication in at least one electronic device is presented. In the method, a first execution thread and a second execution thread are created in the at least one electronic device. Also created is a message service for receiving messages for the first thread. A message to be transferred from the second thread to the message service of the first thread is generated. One of multiple data transfer mechanisms is selected for transferring the message from the second thread to the message service of the first thread based on a relationship between the first and second threads. This relationship may be one in which the first and second threads are executing within a single process, within different processes of the same device, or within different devices. The message is transferred to the message service of the first thread using the selected data transfer mechanism and processed in the first thread.

Abstract: Transactional capable queuing is provided. A queue having an ordered list of messages is provided. A get cursor operation is provided within the queue to point to a current starting place for a getting application to start searching for a message to retrieve. A first lock is provided for putting operations, in response to there being more than one putting application, to ensure only one application is putting to the queue at a time. A second lock is provided for getting operations, in response to there being more than one getting application, to ensure that only one application is getting from the queue at a time. Putting applications and getting applications are synchronized to check and update the get cursor operation.

Abstract: Methods and systems for application-driven polling of shared device queues are provided. One or more applications running in non-virtualized or virtualized computing environments may be adapted to enable methods for polling shared device queues. Applications adapted to operate in a polling mode may transmit a request to initiate polling of shared device queues, wherein operating in the polling mode disables corresponding device interrupts. Applications adapted to operate in a polling mode may be regulated by one or more predefined threshold limitations.

Abstract: Methods and systems relate to receiving, at a system device, a first request from an operating system, the first request identifying shared queue and providing an instruction to the system device to enable polling of the identified shared queue, enabling, by a processing device, polling of the identified shared queue, wherein enabling polling comprises identifying a message in the identified shared queue and polling information related to the identified shared queue, and disabling, by the processing device, a device interrupt associated with the message in the identified shared queue.

Abstract: A method for transmitting data between a sender queue of a sender intermediate layer of a protocol stack and a receiver queue of a receiver intermediate layer of the protocol stack implemented with a sliding window protocol. The method includes receiving a data message or a collection of data messages from a sender messaging layer; tagging the data message or the collection of data messages with a unique identifier; writing the data message or the collection of data messages tagged with the unique identifier as a data window in the sender queue; transmitting a front data window of the sender queue to the receiver queue; receiving a single receipt-acknowledgement message after the receiver transport layer has received all of the front data window; and receiving a commit-acknowledgement message after the receiver messaging layer has read from the receiver intermediate layer all of the front data window.

Abstract: An improved industrial automation system and communication system for implementation therein, and related methods of operation, are described herein. In at least some embodiments, the improved communication system allows communication in the form of messages between modules in different control or enterprise domains. Further, in at least some embodiments, such communications are achieved by providing a communication system including a manufacturing service bus having two internal service busses with a bridge between the internal busses. Also, in at least some embodiments, a methodology of synchronous messaging is employed.

Abstract: Disclosed are various embodiments for balancing a load on a queue among multiple consumers. A target polling hit rate is derived for at least one queue from a consumer load. The consumer load dictates a read rate of the at least one queue. The consumer load on the at least one queue is adjusted responsive to a difference between the target polling hit rate and an observed polling hit rate for the at least one queue.

Abstract: A message control program of an embodiment causes a monitoring apparatus to further function as a plurality of message control unit configured to individually controlling a communication method of a message transmitted from each internal application unit. Each message control unit receives a message containing a message type and service name from the internal application unit. Each message control unit specifies communication method identification information from a file based on the message type and service name in the received message. Each message control unit changes the communication method of the received message based on the specified communication method identification information, and sends the message to a common bus.

Abstract: Acknowledging incoming messages, including: determining, by an acknowledgement dispatching module, whether an incoming message has been received in an active message queue; responsive to determining that the incoming message has been received in the active message queue, resetting, by the acknowledgement dispatching module, an acknowledgment iteration counter; incrementing, by the acknowledgement dispatching module, the acknowledgment iteration counter; determining, by the acknowledgement dispatching module, whether the acknowledgment iteration counter has reached a predetermined threshold; and responsive to determining that the acknowledgment iteration counter has reached the predetermined threshold, processing, by the acknowledgement dispatching module, all messages in the active message queue.

Abstract: A message queuing system implemented by at least one computer. The system comprises a performance queue to keep event status related to performance of non-performance queues, threads, which are sequences of programmed instructions, launched by the queue managers to transmit and receive messages over connections between individual queues, and an external monitoring application or a monitoring application within a queue manager. The monitoring application monitors threads, channels, and events in the message queuing system, polls the performance queue periodically and counts the number of threads in the case of the external monitoring application, directly gathers current event information in the case of the monitoring application within the queue manager, determines whether both the thread/threads and channel have failed when all threads of an application are missing, and restarts channels that failed after determining that both channels and all threads have failed.

Abstract: A method for conveying a data packet received from a network to a virtual machine instantiated on a computer system coupled to the network, and a medium and system for carrying out the method, is described. In the method, a guest receive pointer queue of a component executing in the virtual machine is inspected in order to identify a location in a guest receive packet data buffer that is available to receive packet data. Data from the data packet received from the network is copied into the guest receive packet data buffer at the identified location. A standard receive interrupt is raised in the virtual machine. Thus, the kernel places the data packet received from the network into a memory space accessible to the virtual machine without any intervention by a virtual machine monitor component of the virtualization software.

Abstract: Technologies are provided for locally processing queue requests from co-located workers. In some examples, information about the usage of remote datacenter queues by co-located workers may be used to determine one or more matched queues. Messages from local workers to a remote datacenter queue classified as a matched queue may be stored locally. Subsequently, local workers that request messages from matched queues may be provided with the locally-stored messages.

Abstract: Acknowledging incoming messages, including: determining, by an acknowledgement dispatching module, whether an incoming message has been received in an active message queue; responsive to determining that the incoming message has been received in the active message queue, resetting, by the acknowledgement dispatching module, an acknowledgment iteration counter; incrementing, by the acknowledgement dispatching module, the acknowledgment iteration counter; determining, by the acknowledgement dispatching module, whether the acknowledgment iteration counter has reached a predetermined threshold; and responsive to determining that the acknowledgment iteration counter has reached the predetermined threshold, processing, by the acknowledgement dispatching module, all messages in the active message queue.

Abstract: The present invention enables “unit-of-order”, which allows a message producer to group messages into a single unit. It guarantees that messages are not only delivered to consumers in order, they are also are processed in order. The unit-of-order will be delivered to consumers as one unit and only one consumer will process messages from the unit at a time. The processing of a single message is complete when it is acknowledged, committed, recovered, or rolled back. Until message processing for a message is complete, the remaining unprocessed messages for that unit-of-order are blocked.

Abstract: Systems and methods provide unified playing of announcements across different network interfaces. A system to extend an IMS SCIM to enable application servers using MSCML to play announcements to execute on WIN (CDMA) networks include an application server, including IMS applications. The system includes a SCIM to manage communication between call parties and the applications. In a CDMA network, which an open dialogue the SCIM is configured to respond to the IMS applications that then can play the announcement, receive a second message which indicates the announcement to play from the IMS applications, buffer the announcement indicated, and respond with a message to the IMS applications as if the announcements have been played.

Abstract: A mechanism is provided for providing resource affinity for multi-queue network adapters via dynamic reconfiguration. A device driver allocates an initial queue pair within a memory. The device driver determines whether workload of the data processing system has risen above a predetermined high threshold. Responsive to the workload rising above the predetermined high threshold, the device driver allocates and initializes an additional queue pair in the memory. The device driver programs a receive side scaling (RSS) mechanism in a network adapter to allow for dynamic insertion of an additional processing engine associated with the additional queue pair. The device driver enables transmit tuple hashing to the additional queue pair.

Abstract: A mechanism is provided for consuming ordered streams of messages in a message oriented middleware having a single queue. The mechanism provides a first consuming application thread to process a first message, locks the first message when available on the queue to the first application thread and locking all subsequent messages on the queue with the same stream identifier as the first message to the first application thread, and identifies any messages with different stream identifiers currently locked to the first application thread, and making available the further messages to other application threads; delivering the first message. The mechanism also provides a second consuming application thread to process a subsequent message, locks a next unlocked message when available on the queue to the second consuming application, and locks all subsequent messages on the queue with the same stream identifier as the next unlocked message to the second consuming application thread.

Abstract: A mechanism is provided for merging in a network processor results from a parser and results from an external coprocessor providing processing support requested by said parser. The mechanism enqueues in a result queue both parser results needing to be merged with a coprocessor result and parser results which have no need to be merged with a coprocessor result. An additional queue is used to enqueue the addresses of the result queue where the parser results are stored. The result from the coprocessor is received in a simple response register. The coprocessor result is read by the result queue management logic from the response register and merged to the corresponding incomplete parser result read in the result queue at the address enqueued in the additional queue.

Abstract: A method of suppressing unwanted windows created by an operating system is described. The method comprises: monitoring calls from the operating system relating to creation of a window and ascertaining if a monitored call relates to creation of a window of a type corresponding to a window type to be blocked. If the window is not of a type that is to be blocked, then the method involves displaying the window. If the window is of a type that is to be blocked, then the method involves: registering a new window procedure for that window; and returning an error message to the operating system using the new window procedure to suppress display of the window.

Abstract: A system and method may generate executable models having message sending objects and message receiving objects. A message may include a fixed data payload, and the message may persist for only a determined time interval of a total execution or simulation time of model. Message queues may be established for the messages, and the queues may have attributes. The model may include a state-based portion having states and transitions. States may be configured to generate and send messages, and to receive and process messages. In addition, transitions may be guarded by particular messages. The system and method also may generate standalone code, such as source code, for the model. The standalone code may include code that establishes a message passing service to support the sending and receiving of messages.

Abstract: The present invention provides a message processing method and device, wherein the method comprises: creating a message queue by an application; taking out all current messages from a message queue created by an operating system; performing order adjustment for the taken-out messages and placing them in the message queue created by the application; performing delivery-processing for each message according to an order of messages in the message queue created by the application. Through the present invention, the messages in the message queue may be processed more flexibly.

Abstract: A method and apparatus for handling queues associated with web services of a business process. The method may include generating deployment descriptors for executing a business process as a web application, and determining a default queue for the business process using a business process management (BPM) configuration file. During execution of the business process, users are allowed to monitor the message load associated with the default queue. If a user decides to re-distribute the message load, the user is allowed to specify a new set of queues for the business process to improve performance of the business process at runtime.

Abstract: In one aspect, the present application is directed to a computer system, a computer-implemented method and a computer program product for processing at an application. The computer system may comprise an application operable to process incoming messages, wherein at least two of the incoming messages are correlated, wherein correlated messages need processing at the application in a required order; and a sequencing framework implemented with the application to intercept the incoming messages and comprising an internal buffer to identify the correlated messages and to buffer the correlated messages as a message group with the required order, wherein the sequencing framework interacts with the application by transferring the incoming messages from the internal buffer in the required order to the application for processing.

Abstract: An LDAP bridge service retrieves a generic LDAP message request, placed in a request queue by a message queuing application, from the request queue. The LDAP bridge service formats the generic LDAP request into a particular API call for at least one LDAP API. The LDAP bridge service calls at least one LDAP API with the particular API call for requesting at least one LDAP service from at least one LDAP server managing a distributed directory. Responsive to the LDAP bridge service receiving at least one LDAP specific response from at least one LDAP API, the LDAP bridge service translates the LDAP specific response into a response message comprising a generic LDAP response. The API bridge service, places the response message in a response queue of the message queuing network, wherein the message queuing application listens to the response queue for the response message.

Abstract: An API bridge service retrieves a generic API message request, placed in a request queue of a message queuing network by a message queuing application, from the request queue. The API bridge service formats the generic API request into a particular API call for at least one specific API. The API bridge service calls at least one specific API with the particular API call. Responsive to the API bridge service receiving at least one API specific response from at least one specific API, the API bridge service translates at least one API specific response into a response message comprising a generic API response. The API bridge service, places the response message in a response queue of the message queuing network, wherein the message queuing application listens to the response queue for the response message.

Abstract: Data is managed in a Host Wireless Adapater (HWA)-Device Wireless Adapater (DWA) system by receiving at the HWA a wireless packet from the DWA which contains a DWA Transfer Result message. At the HWA, the DWA Transfer Result message is parsed. In the event parsing the DWA Transfer Result message indicates there is data ready to be sent over a wireless channel between the HWA to the DWA a Micro-scheduled Management Command (MMC) is generating at the HWA and the MMC is transmitted from the HWA to the DWA. The MMC is transmitted prior to receiving a Transfer Request message at the HWA from an HWA driver and the data is transmitted from the DWA to the HWA in response to receiving the MMC.

Abstract: This disclosure relates to methods and systems for queuing events. In one aspect, a method is disclosed that receives or creates an event and inserts the event into a queue. The method determines at least one property of the event and associates a priority with the event based on the property. The method then processes the event in accordance with its priority.

Abstract: A method and system for executing scripts on virtual machines is provided. The system includes an executor service that accepts scripts, parameters, authentication information from another process that needs to invoke a script on a target virtual machine (or group of virtual machines). The executor service remains running even after a script has completed execution. The executor service accepts any number of scripts and places them in a command queue. Agents running on the target virtual machine(s) check-in with the executor service to receive scripts from the command queue. Also, the executor service may directly invoke a script using a persistent connection to a virtual machine management center.

Abstract: A method and system for achieving time-awareness in the highly available, fault-tolerant execution of components in a distributed computing system, without requiring the writer of these components to explicitly write code (such as entity beans or database transactions) to make component state persistent. It is achieved by converting the intrinsically non-deterministic behavior of the distributed system to a deterministic behavior, thus enabling state recovery to be achieved by advantageously efficient checkpoint-replay techniques. The system is deterministic by repeating the execution of the receiving component by processing the messages in the same order as their associated timestamps and time-aware by allowing adjustment of message execution based on time.

Abstract: Administering incident pools including assigning an incident received from one or more components of the distributed processing system to a pool of incidents; assigning to each incident a particular combined minimum time for inclusion of the incident in the pool; in response to the pool closing, determining for each incident in the pool whether the incident has met its combined minimum time for inclusion in the pool; if the incident has been in the pool for its combined minimum time, including the incident in the closed pool; if the incident has not been in the pool for its combined minimum time, moving the incident from the closed pool to a next pool; applying incident suppression rules using the incidents assigned to the next pool; and applying incident creation rules to the incidents that were assigned to the next pool, while omitting any duplicate incidents caused by the assignment.