Scalable Transactions for Web Applications in the Cloud

2012 IEEE Fifth International Conference on Cloud Computing, 2012

Key-value based data storage systems such as HBase and Bigtable provide high scalability compared to traditional relational databases, however, they provide only limited transactional functionality, such as single-row transactions. We address the problem of building scalable transaction management mechanisms for multi-row transactions on key-value storage systems. We develop scalable techniques for transaction management utilizing the snapshot isolation (SI) model. Because the SI model can lead to non-serializable transaction executions, we investigate two conflict detection techniques for ensuring serializability under SI. To support scalability, we investigate system architectures and mechanisms in which the transaction management functions are decoupled from the storage system and integrated with the application-level processes. We present two system architectures and demonstrate their scalability under the scale-out model of Cloud computing platforms. In the first system architecture all transaction management functions are executed in a fully decentralized manner by the application processes. The second architecture is based on a hybrid approach in which the conflict detection techniques are implemented by a dedicated service. We perform a comparative evaluation of these architectures for supporting snapshot isolation and serializability using the TPC-C benchmark. Through experimental evaluations, we demonstrate that multi-row transactions can be supported with the guarantees of ACID properties in a scalable manner using the applicationlevel transaction management techniques presented in this paper.

2019 IEEE 35th International Conference on Data Engineering Workshops (ICDEW), 2019

Existing relational database systems often suffer from rapid increases or significant variability of transactional workloads but lack support for scalability or elasticity. Database replication has been employed to scale workload performance but past approaches make various performance versus consistency tradeoffs and typically lack the mechanisms and policies for dynamically adding and removing replicas. This paper presents Hihooi, a replication-based middleware system that is able to achieve scalability, strong consistency, and elasticity for existing transactional databases. These features are enabled by (i) a novel replication algorithm for propagating database modifications asynchronously and consistently to all replicas at high speeds, and (ii) a new routing algorithm for directing incoming transactions to consistent replicas. Our experimental evaluation validates the high scalability and elasticity benefits offered by Hihooi, which form the key ingredients towards a truly auto-scaling system.

Journal of Systems and Software, 2015

With the development of cloud computing and internet; e-Commerce, e-Business and corporate world revenue are increasing with high rate. These areas not only require scalable and consistent databases but also require inter database transaction support. In this paper, we present, a scalable three-tier architecture along with a distributed middle-ware protocol to support atomic transactions across heterogeneous NoSQL databases. Our methodology does not compromise on any assumption on the accuracy of failure modalities. Hence, it is suitable for a class of heterogeneous distributed systems. To achieve such a target, our architectural model exploits an innovative methodology to achieve distributed atomic transactions. We simulate this architectural setup with different latency tests under different environments to produce reliable impact and correctness.

2012

Minho c 1. Motivation This paper describes a new cloud platform, CumuloNimbo, that envisions ultra-scalable transactional processing for multi-tier applications with the goal to process a million update transactions per second while providing the same level of consistency and transparency as traditional relational database systems. Most of the current approaches to attain scalability for transactional processing in the cloud resort to sharding. Sharding is a technique in which the database is split into many different partitions (e.g. thousands) that work as separate databases sharing the original schema of the database. Sharding is technically simple but neither syntactically nor semantically transparent. Syntactic transparency is lost because applications have to be rewritten as individual transactions are only allowed to access one of the partitions. Semantic transparency is lost, because the ACID properties provided previously by transactions over arbitrary data sets are lost. Alternatives to sharding have been proposed recently [BernRWY11, PengD10], but they are solutions for specialized data structures [BernRWY11] or are not designed for online systems that require fast response times [PengD10].

Human-centric Computing and Information Sciences, 2017

Background Data storage and processing needs of modern Internet services such as social networks, online shopping, data analytics and visualization have necessitated new kind of storage systems, called NoSQL (Not Only SQL) databases. Such databases use new techniques that support parallel processing and replication of data across multiple nodes in order to ensure improved performance and availability of data [1]. Unlike relational databases [2], NoSQL databases process and manage big data which is characterised by 3Vs (Volume, Variety, Velocity) [3]. NoSQL databases are required to support a variety of applications that need different levels of performance, consistency, availability and scalability [4]. For example, social media such as Twitter and Facebook [5] generate terabytes of daily data which is beyond the processing capabilities of

ACM Transactions on Database Systems, 2014

As more data management software is designed for deployment in public and private clouds, or on a cluster of commodity servers, new distributed storage systems increasingly achieve high data access throughput via partitioning and replication. In order to achieve high scalability, however, today's systems generally reduce transactional support, disallowing single transactions from spanning multiple partitions. This article describes Calvin, a practical transaction scheduling and data replication layer that uses a deterministic ordering guarantee to significantly reduce the normally prohibitive contention costs associated with distributed transactions. This allows near-linear scalability on a cluster of commodity machines, without eliminating traditional transactional guarantees, introducing a single point of failure, or requiring application developers to reason about data partitioning. By replicating transaction inputs instead of transactional actions, Calvin is able to support ...

2013

Eventual consistency improves the scalability of large datasets in cloud systems. We propose a novel technique for managing different levels of replica consistency in a replicated relational DBMS. To this end, data is partitioned and managed by a partial replication protocol that is able to define a hierarchy of nodes with a lazy update propagation. Nodes in different layers of the hierarchy may maintain different versions of their assigned partitions. Transactions are tagged with an allowance parameter k that specifies the maximum degree of data outdatedness tolerated by them. As a result, different degrees of transaction criticality can be set and non-critical transactions may be completed without blocking nor compromising the critical ones.

IEEE Transactions on Knowledge and Data Engineering, 2020

With the advent of the Internet and Internet-connected devices, modern business applications can experience rapid increases as well as variability in transactional workloads. Database replication has been employed to scale performance and improve availability of relational databases but past approaches have suffered from various issues including limited scalability, performance versus consistency tradeoffs, and requirements for database or application modifications. This paper presents Hihooi, a replication-based middleware system that is able to achieve workload scalability, strong consistency guarantees, and elasticity for existing transactional databases at a low cost. A novel replication algorithm enables Hihooi to propagate database modifications asynchronously to all replicas at high speeds, while ensuring that all replicas are consistent. At the same time, a fine-grained routing algorithm is used to load balance incoming transactions to available replicas in a consistent way. Our thorough experimental evaluation with several well-established benchmarks shows how Hihooi is able to achieve almost linear workload scalability for transactional databases.

VLDB, 2013

Web service providers have been using NoSQL datastores to provide scalability and availability for globally distributed data at the cost of sacrificing transactional guarantees. Recently, major web service providers like Google have moved towards building storage systems that provide ACID transactional guarantees for globally distributed data. For example, the newly published system, Spanner, uses Two-Phase Commit and Two-Phase Locking to provide atomicity and isolation for globally distributed data, running on top of Paxos to provide fault-tolerant log replication. We show in this paper that it is possible to provide the same ACID transactional guarantees for multi-datacenter databases with fewer crossdatacenter communication trips, compared to replicated logging. Instead of replicating the transactional log, we replicate the commit operation itself, by running Two-Phase Commit multiple times in different datacenters and using Paxos to reach consensus among datacenters as to whether the transaction should commit. Doing so not only replaces several inter-datacenter communication trips with intra-datacenter communication trips, but also allows us to integrate atomic commitment and isolation protocols with consistent replication protocols to further reduce the number of cross-datacenter communication trips needed for consistent replication; for example, by eliminating the need for an election phase in Paxos. We analyze our approach in terms of communication trips to compare it against the log replication approach, then we conduct an extensive experimental study to compare the performance and scalability of both approaches under various multi-datacenter setups.

2012 International Conference on Computing, Networking and Communications (ICNC), 2012

Cloud storage service is currently becoming a very popular solution for medium-sized and startup companies. However, there is still no suitable solution being offered to deploy transactional databases in a cloud platform. The maintenance of ACID (Atomicity, Consistency, Isolation and Durability) properties is the primary obstacle to the implementation of transactional cloud databases. The main features of cloud computing: scalability, availability and reliability are achieved by sacrificing consistency. While different forms of consistent states have been introduced, they do not address the needs of many database applications. In this paper we present a tree-based consistency approach, called TBC, that reduces interdependency among replica servers to minimize response time of cloud databases and to maximize the performance of those applications. Experimental results indicate that our TBC approach trades off availability and consistency with performance.