3,490 research outputs found
Recommended from our members
Bringing modular concurrency control to the next level
Database users face a tension between ease-of-programming and high performance: ACID transactions can greatly simplify the programming effort of database applications by providing four useful properties—atomicity, consistency, isolation, and durability, but enforcing these properties can degrade performance.
This dissertation eases this tension by improving the performance of ACID transactions for scenarios where data contention is the bottleneck. The approach that we take is federating concurrency control (CC) mechanisms. It is based on the observation that any single CC mechanism is bound to make trade-offs that cause it to perform well in some cases but poorly in others. A federation opens the opportunity of applying each mechanism only to the set of transactions or workloads where it shines, while maintaining isolation.
In particular, this work builds upon Modular Concurrency Control (MCC), a recent technique that federates CCs by partitioning transactions into groups, and by applying different CC mechanisms in each group.
This dissertation addresses two critical shortcomings in the current embodiment of MCC. First, cross-group data conflicts are handled with a single, unoptimized CC mechanism that can significantly limit performance. Second, configuring MCC is a complex task, which runs counter to MCC’s purpose: to improve performance without sacrificing ease-of-programming.
To address these problems, this dissertation presents Tebaldi, a new transactional database that brings Modular Concurrency Control to the next level, both figuratively and literally. Tebaldi introduces a new, hierarchical model to MCC that partitions transactions recursively to compose CC mechanisms in a multi-level tree. This model increases flexibility in federating CC mechanisms, which is the key to realizing the performance potential of federation. Tebaldi reduces configuration complexity by managing the MCC federation automatically: it can detect performance issues in the current workload in real-time, and automatically adjusts its configuration to improve its performance.Computer Science
Lazy State Determination for SQL databases
Transactional systems have seen various efforts to increase their throughput, mainly
by making use of parallelism and efficient Concurrency Control techniques. Most approaches
optimize the systems’ behaviour when under high contention.
In this work, we strive towards reducing the system’s overall contention through Lazy
State Determination (LSD). LSD is a new transactional API that leverages on futures
to delay the accesses to the Database as much as possible, reducing the amount of time
that transactions require to operate under isolation and, thus, reducing the contention
window.
LSD was shown to be a promising solution for Key-Value Stores. Now, our focus turns
to Relational Database Management Systems, as we attempt to implement and evaluate
LSD in this new setting. This implementation was done through a custom JDBC driver
to minimize required modifications to any external platform.
Results show that the reduction of the contention window effectively improves the
success rate of transactional applications. However, our current implementation exhibits
some performance issues that must be further investigated and addressed.Os sistemas transacionais têm sido alvo de esforços variados para aumentar a sua velocidade
de processamento, principalmente através de paralelismo e de técnicas de controlo
de concorrência mais eficazes. A maior parte das soluções propostas visam a otimização
do comportamento destes sistemas em ambientes de elevada contenção.
Neste trabalho, nós iremos reduzir a contenção no sistema recorrendo ao Lazy State
Determination (LSD). O LSD é uma nova API transacional que promove a utilização
de futuros para adiar o máximo os acessos à Base de Dados, reduzindo assim o tempo
que cada transação requer para executar em isolamento e, por consequência, reduzindo
também a janela de contenção.
O LSD tem-se mostrado uma solução promissora para bases de dados Chave-Valor.
O nosso foco foi agora redirecionado para Sistemas de Gestão de Bases de Dados Relacionais,
com uma tentativa de implementação e avaliação do LSD neste novo contexto.
Este objetivo foi concretizado através da implementação de um controlador JDBC para
minimizar quaisquer alterações a plataformas externas.
Os resultados mostram que a redução da janela de contenção efetivamente melhora
a taxa de sucesso de aplicações transacionais. No entanto, a nossa implementação atual
tem alguns problemas de desempenho que necessitam de ser investigados e endereçados
Recommended from our members
Concurrency Control in Advanced Database Applications
Concurrency control has been thoroughly studied in the context of traditional database applications such as banking and airline reservations systems. There are relatively few studies, however, that address the concurrency control issues of advanced database applications such as CAD/CAM and software development environments. The concurrency control requirements in such applications are different from those in conventional database applications; in particular, there is a need to support non-serializable cooperation among users whose transactions are long-lived and interactive, and to integrate concurrency control mechanisms with version and configuration control. This paper outlines the characteristics of data and operations in some advanced database applications, discusses their concurrency control requirements, and surveys the mechanisms proposed to address these requirements
Theory and Practice of Transactional Method Caching
Nowadays, tiered architectures are widely accepted for constructing large
scale information systems. In this context application servers often form the
bottleneck for a system's efficiency. An application server exposes an object
oriented interface consisting of set of methods which are accessed by
potentially remote clients. The idea of method caching is to store results of
read-only method invocations with respect to the application server's interface
on the client side. If the client invokes the same method with the same
arguments again, the corresponding result can be taken from the cache without
contacting the server. It has been shown that this approach can considerably
improve a real world system's efficiency.
This paper extends the concept of method caching by addressing the case where
clients wrap related method invocations in ACID transactions. Demarcating
sequences of method calls in this way is supported by many important
application server standards. In this context the paper presents an
architecture, a theory and an efficient protocol for maintaining full
transactional consistency and in particular serializability when using a method
cache on the client side. In order to create a protocol for scheduling cached
method results, the paper extends a classical transaction formalism. Based on
this extension, a recovery protocol and an optimistic serializability protocol
are derived. The latter one differs from traditional transactional cache
protocols in many essential ways. An efficiency experiment validates the
approach: Using the cache a system's performance and scalability are
considerably improved
Recommended from our members
Concurrency Control in Advanced Database Applications
Concurrency control has been thoroughly studied in the context of traditional database applications such as banking and airline reservations systems. There are relatively few studies, however, that address the concurrency control issues of advanced database applications such as CAD/CAM and software development environments. The concurrency control requirements in such applications are different from those in conventional database applications; in particular, there is a need to support non-serializable cooperation among users whose transactions are long-lived and interactive, and to integrate concurrency control mechanisms with version and configuration control. This paper outlines the characteristics of data and operations in some advanced database applications, discusses their concurrency control requirements, and surveys the mechanisms proposed to address these requirements
Software Engineering and Petri Nets
This booklet contains the proceedings of the Workshop on Software Engineering and Petri Nets (SEPN), held on June 26, 2000. The workshop was held in conjunction with the 21st International Conference on Application and Theory of Petri Nets (ICATPN-2000), organised by the CPN group of the Department of Computer Science, University of Aarhus, Denmark. The SEPN workshop papers are available in electronic form via the web page:http://www.daimi.au.dk/pn2000/proceeding
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
- …