International Business Machines Corporation

Andrew John Schofield

Jonathan Levell

Ian C Edwards

Ian Robinson

Soloman J Barghouthi

Kevin William Sutter

Anthony Robert Washer

Stephen James Todd

Francis Nicholas Parr

Tian Cheng Liu

Philip Graham Willoughby

Qi Ming Teng

Susan Patricia Paice

Trevor Lobban

Gareth Ian Bottomley

Brian Trevor DePradine

Leo J Davison

A messaging system having a cluster of receiving applications for handling received messages, and a cluster of messaging engines for receiving messages from one or more message sources and forwarding the received messages to one of the receiving applications is provided. Each messaging engine is operable to transmit load balancing information, the load balancing information comprising an indication of the current loading on the messaging engine. The receiving applications are instructed to establish a connection to receive messages from a particular messaging engine within the cluster based on the load balancing information. Accordingly, applications are able to receive messages in such a way that the messages do not build up unprocessed on a particular messaging engine for too long, and such that messages are routed to messaging engines where messages are being consumed, and so that the receiving applications receive messages from every messaging engine where messages are arriving.

Messaging forwarding system and method

Data integrity is maintained in an environment in which multiple instances of a software component each can include multiple processes capable of accessing a shared resource. Each instance of the software component can be either an 'active' instance (which is allowed to update data) or a 'standby' instance (which is not allowed to update data). At any point in time, the environment does not comprise more than one active instance. There can, however, be more than one standby instance. Preferably, a single standby instance can become a new active instance in the event of a complete failure of the active instance, i.e. a failure associated with every process of the current active instance.

Maintaining data integrity

In a messaging and queuing system that supports a cluster of logically associated messaging servers for controlling queues of messages, messages are processed. In response to an application program command to a first messaging server, a queue is opened, the queue having multiple instances on further messaging servers of the cluster. Responding to first messaging server putting messages on the queue, messages are distributed among the multiple instances of the queue on their respective messaging servers so as to balance. For the first message of an affinity set, access information for the particular queue instance to which it is put is obtained and stored. The access information may be used in order to send the further message to the particular queue instance and, if said further message is not part of the affinity set, it is put to an instance of the queue as determined by said predetermined rules.

Queueing messages related by affinity set

Technique for analyzing memory areas based on local copies of a global counter by: (i) determining a plurality of currently-executing fast threads and a plurality of currently executed slow threads; (ii) intermittently incrementing a global counter variable to have a current global counter value; (iii) intermittently setting the local counter of the data set for each fast thread of the plurality of fast threads to be equal to the current global counter value; (iv) determining that no slow threads of the plurality of slow threads reference the first memory region; (v) assigning a free-after value to the first memory region; (vi) determining whether the free-after value of the first memory region is less than or equal to all of the local counters of the fast thread data sets of the plurality of fast threads; and (vii) de-allocating the first memory region.

Reference counting for memory areas

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.

Transaction capable queuing

A user is enabled to specify policy information for use by a persistence manager in determining how to persist information relating to a data item so as achieve a desired level of reliability. The user is permitted to specify at least two behavior requirements to be associated with information to be persisted. The first behavior requirement is specifiable for a first system state, and the second behavior state is specifiable for a second system state. The behavior requirements are interpretable by the persistence manager to determine a persistence behavior necessary to conform with the policy information.

Management of persistence in a data processing system

A system receives an identifier for a temporary destination in response to messaging software at a client requesting that a messaging server create the temporary destination. The messaging software uses the identifier to indicate the temporary destination as a destination for responses to messages from the messaging software. The identifier is logged. A disconnection from the messaging server is detected. A second request for a temporary destination is created. The identifier is indicated in the second request. The second request indicating the identifier is transmitted to the messaging server to preserve a messaging service in a highly available environment.

Preserving a messaging service in a highly available environment

Method, apparatus, and computer program product for reducing the number of operations performed by a persistence manager against a persistent store of data items. A plurality of requests from an application are received. Each request is mapped into a transaction for performance against the persistent store, each transaction having at least one operation. Transactions are accumulated and preprocessed to reduce the number of operations for performance against the persistent store.

Reducing the number of operations performed by a persistence manager against a persistent store of data items

A method and system for increasing a system's performance and achieving improved memory utilization by approximating the memory sizes that will be required for data objects that can be deserialized and constructed in a memory cache. The method and system may use accurate calculations or measurements of similar objects to calibrate the approximate memory sizes.

Method and system for approximating object sizes in an object-oriented system

A computer system and storage medium that, in an embodiment, receive an allocation request for a resource and registers the resource as a non-voting participant if the resource desires to delegate commit voting to another resource. The registered resource is then prohibited from participating in an enclosing transactional context and instead is informed when the transaction completes. The resource is enlisted as a voting participant if the resource does not desire to delegate commit voting. In this way, when multiple resources are used in a transaction, a resource may be registered and receive notifications of transaction completion instead of being enlisted and voting on commit decisions. The result of a transaction in which a single resource takes responsibility for a number of other resources is that transaction completion avoids the two-phase commit protocol and the resulting performance degradation.

Registering a resource that delegates commit voting

Method, apparatus, computer program, and computer program product for managing the durability of a plurality of transactions, each transaction including a plurality of operations, each operation for applying to a data item, each operation having a reliability level associated therewith. Each transaction is divided into one or more sub-transactions based upon reliability level of the operations. Sub-transactions are then dispatched to a persistence manager for execution against a persistent store.

Method, apparatus, computer program, and computer program product for managing the durability of a pluraliy of transactions

A method, apparatus, system, and signal-bearing medium that, in an embodiment, receive an allocation request for a resource and registers the resource as a non-voting participant if the resource desires to delegate commit voting to another resource. The registered resource is then prohibited from participating in an enclosing transactional context and instead is informed when the transaction completes. The resource is enlisted as a voting participant if the resource does not desire to delegate commit voting. In this way, when multiple resources are used in a transaction, a resource may be registered and receive notifications of transaction completion instead of being enlisted and voting on commit decisions. The result of a transaction in which a single resource takes responsibility for a number of other resources is that transaction completion avoids the two-phase commit protocol and the resulting performance degradation.

A technique of logging updates to a plurality of data records into discrete pages in non-volatile storage, wherein a page partially full of data is known as a partial page. Identical partial pages I and I+1 are established in the logging process as quickly as possible. Thereafter, in response to a data segment D larger than the remaining space of a most recent updated partial page I, D is partitioned into a first segment Dsufficient to fill the remaining space of page I and a second data segment DPage I is updated with a first write operation to its present contents concatenated with Dand identical partial pages containing Dare created at I+1 and I+2 with a second write operation, whereby those pages become pages I and I+1 for the next logging operation.

Growing community of inventors

Eastleigh, United Kingdom

Andrew John Schofield