Downloads‎ > ‎

Looking for strong consistency but worried about scalability?

GMU can buy you both!

This version of Infinispan is based on the classical Two-Phase Commit (2PC) replication scheme for providing the SERIALIZABLE isolation level in the Infinispan's distribution mode.

As in the default Infinispan concurrency control scheme, each transaction is executed locally on the transaction's origin node  and without any explicit coordination among replicas till the transaction requests the commit. However, since the replication scheme is designed for the most general case according to which each Infinispan key is not replicated on all nodes in the system (i.e. distribution mode), a node N executing a transaction T needs to contact another node M whenever T wants to read a key stored on M but not replicated on N. Then, at commit time, the implementation follows the Two-Phase Commit based classical replication scheme in order to ensure atomicity during the modification of the replicas status.

The novelty of this version is the core distributed concurrency control scheme, the GMU algorithm, that ensures (i) a consistent evolution of the system state and (ii) that all the values returned by the read operations of a transaction T always belong to a consistent state. More precisely, this means that changes to the state of the data grid always produce consistent snapshots, namely states resulting from the commit of a set of update transactions on multiple nodes as they were executed sequentially in a single centralized transactional node. In addition, as in classical multiversion concurrency control schemes (MVCC), this scheme entails storing multiple versions for a same data item and allows transactions to always observe consistent snapshots of the data grid. Therefore, transactions that only execute read operations, namely read-only transactions, can be always successfully committed without incurring in any inter-replica synchronization process and as they were executed instantaneously between their begin and the commit request.

However, unlike most of the existing distributed MVCC schemes, the implemented one does not order transactions commit events by relying on a centralized or fully replicated global clock. Conversely  it is designed as a novel, highly scalable, fully distributed synchronization scheme that exploits vector clocks to achieve the twofold objective: (i) determining which data item versions have to be returned by read operations issued by transactions; (ii) ensuring agreement among the nodes replicating the data items updated by a transaction T on the scalar clock to be used when locally applying the write-set of T , as well as on the vector clock to associate with the commit event of T.

For further details about the GMU concurrency control scheme, please refer to the paper "When Scalability Meets Consistency: Genuine Multiversion Update-Serializable Partial Data Replication", published in the proceedings of the 32nd IEEE International Conference on Distributed Computing Systems (ICDCS '12) and that can be found at the following link.

Where can I find the source code?

The code is under the Git, a distributed version control system. You can download the source code from our GitHub account here.

To download it follow this small steps

$ git clone git://
$ cd infinispan-5.0.0.SERIALIZABLE
git checkout serializability

How can I install it and use it in my application?

RequirementsJavaMaven and Internet Connection. 

To install it, follow the simple steps:

$ cd infinispan-5.0.0.SERIALIZABLE
$ mvn clean install [-DskipTests=true]

The option -DskipTests=true will avoid to run all the tests cases. After this, to use it in you application, you just need to do a last step, depending of your application

Maven Application: add Infinispan as a dependency to your pom.xml



Other: add the Infinispan Core jar to your application classpath. The jar can be found in:

<infinispan code folder>/core/target/infinispan-core.jar

How can I configure it?

Example of Infinispan Configuration file

<?xml version="1.0" encoding="UTF-8"?>

      <transport clusterName="infinispan-cluster">
          <property name="configurationFile" value="jgroups.xml" />


        useLockStriping="false" />

      <clustering mode="d">
        <l1 enabled="false" />
        <hash numOwners="2" rehashEnabled="false" rehashRpcTimeout="60000"/>


Sebastiano Peluso,
22 Oct 2012, 06:09