Exploiting distributed software transactional memory

Over the past years research and development on computer architecture has shifted from uni-processor systems to multi-core architectures. This transition has created new incentives in software development because in order for the software to scale it has to be highly parallel. Traditional synchronization primitives based on mutual exclusion locking are challenging to use and therefore are only efficiently employed by a minority of expert programmers. Transactional Memory (TM) is a new alternative parallel programming model aiming to alleviate the problems that arise from the use of explicit synchronization mechanisms. In TM, lock guarded code is replaced by memory transactions which comply with the ACI (atomicity, consistency, isolation) principles. The simplicity of the programming model that TM proposes has led to major research efforts by academia and industry to produce high-performance TM implementations. The majority of these TM systems, however, focus on shared-memory Chip MultiProcessors (CMPs) leaving the area of distributed systems unexplored. This thesis explores Transactional Memory in the distributed systems domain and more specifically on small-scale clusters. A variety of novel distributed transactional coherence protocols are proposed and evaluated, against complex TM oriented benchmarks, in the context of distributed Java Virtual Machines (JVMs) - an area that has received much attention over the last decade due to its perfect applicability into the enterprise domain. The implemented Distributed Software Transactional Memory (DiSTM) system, proposed in this thesis, is a JVM clustering solution that employs software transactional memory as its synchronization mechanism. Due to its modular design and ease in programming, it allows the addition of new protocols in a fairly easy manner. Finally, DiSTM is highly portable as it runs on top of off-the-shelf JVMs and requires no changes to existing Java source code.EThOS - Electronic Theses Online ServiceGBUnited Kingdo

Clustering JVMs with Software Transactional Memory Support

Abstract—Affordable transparent clustering solutions to scale non-HPC applications on commodity clusters (such as Terracotta) are emerging for Java Virtual Machines (JVMs). Working in this direction, we propose the Anaconda framework as a research platform to investigate the role Transactional Memory (TM) can play in this domain. Anaconda is a software transactional memory framework that supports clustering of multiple off-the-shelf JVMs on commodity clusters. The main focus of Anaconda is to investigate the implementation of Java synchronization primitives on clusters by relying on Transactional Memory. The traditional lock based Java primitives are replaced by memory transactions and the framework is responsible for ensuring transactional coherence. The contribution of this paper is to investigate which kind of TM coherency protocol can be used in this domain and compare the Anaconda framework against the state-of-the-art Terracotta clustering technology. Furthermore, Anaconda tracks TM conflicts at object granularity and provides distributed object replication and caching mechanisms. It supports existing TM coherence protocols while adding a novel decentralized protocol. The performance evaluation compares Anaconda against three existing TM protocols. Two of these are centralized, while the other is decentralized. In addition, we compare Anaconda against lock-based (coarse, medium grain) implementations of the benchmarks running on Terracotta. Anaconda’s performance varies amongst benchmarks, outperforming by 40 to 70 % existing TM protocols. Compared to Terracotta, Anaconda exhibits from 19x speedup to 10x slowdown depending on the benchmark’s characteristics

Mesobi: memória transacional em software tolerante a faltas bizantinas

Dissertação (mestrado) - Universidade Federal de Santa Catarina, Centro Tecnológico, Programa de Pós-Graduação em Ciência da Computação, Florianópolis, 2015.Memória Transacional em Software (STM) é um modelo utilizado para tratar acesso concorrente a dados compartilhados, onde programadores não precisam lidar explicitamente com mecanismos de controle de concorrência, como locks. O programador, apenas delineia qual parte do código necessita ser tratado como concorrente e sua execução seguirá o modelo transacional, respeitando as propriedades: atomicidade, consistência e isolação. É proposto nessa dissertação um modelo denominado Mesobi: Memória Transacional em Software Tolerante a Faltas Bizantinas onde transações somente leitura não abortam. Existem algumas abordagens na literatura que utilizam Memória Transacional em Software, das quais grande parte tolera faltas de parada mas pouco se fala sobre faltas maliciosas. Somente o trabalho de Zhang 2012 faz tolerância a faltas Bizantinas no contexto de STM; sua proposta utiliza dois clusters para alcançar tolerância a faltas Bizantinas.No modelo de Zhang, transações somente leitura podem ser abortadas, não é suportada a execução de transações interativas e não é possível executar transações de forma otimista. O Mesobi permite alcançar tolerância a faltas Bizantinas utilizando (3f+1) réplicas, sendo que, f é o número de faltas toleradas. O modelo consiste em inicialmente tentar executar as transações de forma otimista sem a necessidade de executar o protocolo Bizantino. Transações conflitantes localmente não são iniciadas de imediato com isso evita-se trabalho improdutivo. É possível e viável a execução de transações pré-declaradas e interativas no mesmo ambiente, sendo que, transações interativas têm pior desempenho devido a sua maior troca de mensagens.Abstract : Software Transactional Memory (STM) is a model to deal concurrent accesses on shared data. With STM developers do not need to cope with explicit concurrency control mechanisms like locks. Instead developers can write parallel portions of code as transactions, which are garanteed to execute atomically and in isolation regardless of eventual data races. In this dissertation we propose a model named Mesobi: Memória Transacional em Software Tolerante a Faltas Bizantinas in which read-only transactions do not abort. There are some approaches in literature that use STM, but most of them treat crash faults, but few deal with arbitrary faults. The work presented by Zhang 2012 mentions Byzantine Fault Tolerance (BFT) in STM context, but two clusters are necessary, one for consensus and another to execute transactions. Zhang's model abort read-only transactions, does not use optimistic execution neither interactive transactions processing. It achieves BFT using (3f+1) replicas where f represents the number of tolerated faults. The model executes in an optimistic fashion the transactions without the BFT protocol. Conflicting local transactions are not executed immediately thereby saving wasted work. Execution and consistency tests showed that execution of interactive and pre-declared transactions on same environment are possible and practical. Interactive transactions have worse performance than pre-declared due to need of more message exchanges