137 research outputs found
Shirakami: A Hybrid Concurrency Control Protocol for Tsurugi Relational Database System
Modern real-world transactional workloads such as bills of materials or
telecommunication billing need to process both short transactions and long
transactions. Recent concurrency control protocols do not cope with such
workloads since they assume only classical workloads (i.e., YCSB and TPC-C)
that have relatively short transactions. To this end, we proposed a new
concurrency control protocol Shirakami. Shirakami has two sub-protocols.
Shirakami-LTX protocol is for long transactions based on multiversion
concurrency control and Shirakami-OCC protocol is for short transactions based
on Silo. Shirakami naturally integrates them with write preservation method and
epoch-based synchronization. Shirakami is a module in Tsurugi system, which is
a production-purpose relational database system
Cooperative memory and database transactions
Dissertação apresentada na Faculdade de
CiĂŞncias e Tecnologia da Universidade Nova
de Lisboa para a obtenção do Grau de Mestre
em Engenharia InformáticaSince the introduction of Software Transactional Memory (STM), this topic has received a strong interest by the scientific community, as it has the potential of greatly
facilitating concurrent programming by hiding many of the concurrency issues under
the transactional layer, being in this way a potential alternative to the lock based
constructs, such as mutexes and semaphores. The current practice of STM is based
on keeping track of changes made to the memory and, if needed, restoring previous
states in case of transaction rollbacks. The operations in a program that can be reversible,by restoring the memory state, are called transactional operations. The way
that this reversibility necessary to transactional operations is achieved is implementation dependent on the STM libraries being used. Operations that cannot be reversed,such as I/O to external data repositories (e.g., disks) or to the console, are called nontransactional
operations. Non-transactional operations are usually disallowed inside a memory transaction, because if the transaction aborts their effects cannot be undone.
In transactional databases, operations like inserting, removing or transforming data in
the database can be undone if executed in the context of a transaction. Since database
I/O operations can be reversed, it should be possible to execute those operations in the
context of a memory transaction.
To achieve such purpose, a new transactional model unifying memory and database
transactions into a single one was defined, implemented, and evaluated. This new transactional model satisfies the properties from both the memory and database
transactional models. Programmers can now execute memory and database operations
in the same transaction and in case of a transaction rollback, the transaction effects in both the memory and the database are reverted
Ensuring Serializable Executions with Snapshot Isolation DBMS
Snapshot Isolation (SI) is a multiversion concurrency control that has been implemented by open source and commercial database systems such as PostgreSQL and Oracle. The main feature of SI is that a read operation does not block a write operation and vice versa, which allows higher degree of concurrency than traditional two-phase locking. SI prevents many anomalies that appear in other isolation levels, but it still can result in non-serializable execution, in which database integrity constraints can be violated. Several techniques have been proposed to ensure serializable execution with engines running SI; these techniques are based on modifying the applications by introducing conflicting SQL statements. However, with each of these techniques the DBA has to make a difficult choice among possible transactions to modify. This thesis helps the DBA’s to choose between these different techniques and choices by understanding how the choices affect system performance. It also proposes a novel technique called ’External Lock Manager’ (ELM) which introduces conflicts in a separate lock-manager object so that every execution will be serializable. We build a prototype system for ELM and we run experiments to demonstrate the robustness of the new technique compare to the previous techniques. Experiments show that modifying the application code for some transactions has a high impact on performance for some choices, which makes it very hard for DBA’s to choose wisely. However, ELM has peak performance which is similar to SI, no matter which transactions are chosen for modification. Thus we say that ELM is a robust technique for ensure serializable execution
Serializable Isolation for Snapshot Databases
Many popular database management systems implement a multiversion concurrency control algorithm called snapshot isolation rather than providing full serializability based on locking. There are well-known anomalies permitted by snapshot isolation that can lead to violations of data consistency by interleaving transactions that would maintain consistency if run serially. Until now, the only way to prevent these anomalies was to modify the applications by introducing explicit locking or artificial update conflicts, following careful analysis of conflicts between all pairs of transactions. This thesis describes a modification to the concurrency control algorithm of a database management system that automatically detects and prevents snapshot isolation anomalies at runtime for arbitrary applications, thus providing serializable isolation. The new algorithm preserves the properties that make snapshot isolation attractive, including that readers do not block writers and vice versa. An implementation of the algorithm in a relational database management system is described, along with a benchmark and performance study, showing that the throughput approaches that of snapshot isolation in most cases
pH1: a transactional middleware for NoSQL
NoSQL databases opt not to offer important abstractions traditionally found in relational databases in order to achieve high levels of scalability and availability: transactional guarantees and strong data consistency.
In this work we propose pH1, a generic middleware layer over NoSQL databases that offers transactional guarantees with Snapshot Isolation. This is achieved in a non-intrusive manner, requiring no modifications to servers and no native support for multiple versions. Instead, the transactional context is achieved by means of a multiversion distributed cache and an external transaction certifier, exposed by extending the client’s interface with transaction bracketing primitives.
We validate and evaluate pH1 with Apache Cassandra and Hyperdex. First, using the YCSB benchmark, we show that the cost of providing ACID guarantees to these NoSQL databases amounts to 11% decrease in throughput.
Moreover, using the transaction intensive TPC-C workload, pH1 presented an impact of 22% decrease in throughput. This contrasts with OMID, a previous proposal that takes advantage of HBase’s support for multiple versions, with a throughput penalty of 76% in the same conditions
- …