1,902 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
Recommended from our members
Rephrasing rules for off-the-shelf SQL database servers
We have reported previously (Gashi et al., 2004) results of a study with a sample of bug reports from four off-the-shelf SQL servers. We checked whether these bugs caused failures in more than one server. We found that very few bugs caused failures in two servers and none caused failures in more than two. This would suggest a fault-tolerant server built with diverse off-the-shelf servers would be a prudent choice for improving failure detection. To study other aspects of fault tolerance, namely failure diagnosis and state recovery, we have studied the "data diversity" mechanism and we defined a number of SQL rephrasing rules. These rules transform a client sent statement to an additional logically equivalent statement, leading to more results being returned to an adjudicator. These rules therefore help to increase the probability of a correct response being returned to a client and maintain a correct state in the database
Improving Reuse of Distributed Transaction Software with Transaction-Aware Aspects
Implementing crosscutting concerns for transactions is difficult, even using Aspect-Oriented Programming Languages (AOPLs) such as AspectJ. Many of these challenges arise because the context of a transaction-related crosscutting concern consists of loosely-coupled abstractions like dynamically-generated identifiers, timestamps, and tentative value sets of distributed resources. Current AOPLs do not provide joinpoints and pointcuts for weaving advice into high-level abstractions or contexts, like transaction contexts. Other challenges stem from the essential complexity in the nature of the data, operations on the data, or the volume of data, and accidental complexity comes from the way that the problem is being solved, even using common transaction frameworks. This dissertation describes an extension to AspectJ, called TransJ, with which developers can implement transaction-related crosscutting concerns in cohesive and loosely-coupled aspects. It also presents a preliminary experiment that provides evidence of improvement in reusability without sacrificing the performance of applications requiring essential transactions. This empirical study is conducted using the extended-quality model for transactional application to define measurements on the transaction software systems. This quality model defines three goals: the first relates to code quality (in terms of its reusability); the second to software performance; and the third concerns software development efficiency. Results from this study show that TransJ can improve the reusability while maintaining performance of TransJ applications requiring transaction for all eight areas addressed by the hypotheses: better encapsulation and separation of concern; loose Coupling, higher-cohesion and less tangling; improving obliviousness; preserving the software efficiency; improving extensibility; and hasten the development process
Empowering a Relational Database with LSD: Lazy State Determination
Computer systems are a part of today’s most common activities and, more often than not,
involve some type of interaction with a database. In this scheme, databases play a big
role, where even small operational delays could cost millions to big tech companies. It is
then, of utmost importance that such systems are responsive and adapt automatically to
different types of workload.
To this date, Relational Database Management System remain the most popular
database type, which allows the executing of concurrent transactions with Atomicity,
Consistency, Isolation and Durability guarantees. Enforcing such properties requires
strict control over the execution of transactions. However, maintaining such properties
and controlling the transactions’ concurrency may hamper performance of the system,
being this specially the case when database contention is high.
Motivated by such behavior, we propose the lazy evaluation of database SQL queries
— using Futures/Promises and Java Database Connectivity (JDBC) — by empowering
a relational database with Lazy State Determination (LSD). This novel Application
Programming Interface (API) allows delaying operations to the commit time, which in the
end reduces the transaction window where conflicts may occur.
We observed that, by introducing our implementation of a JDBC-LSD driver, in high
contention scenarios the throughput increased by 50% and latency reduced by 40%.Os sistemas informáticos são parte das atividades mais comuns na atualidade e, na maioria
das vezes, envolvem algum tipo de interação com uma base de dados. Neste cenário, as
bases de dados têm um grande papel, sendo que pequenos atrasos operacionais podem
custar milhões às grandes empresas tecnológicas.
Até os dias de hoje, os Sistemas de Gestão de Bases de Dados Relacionais continuam a
ser o tipo de bases de dados mais popular, permitindo a execução concorrente de transações
garantindo as propriedades de Atomicidade, Consistência, Isolamento e Durabilidade. A
aplicação de tais propriedades requer um controlo rigoroso sobre a execução de transações.
No entanto, manter tais propriedades e controlar a concorrência das transacções pode
diminuir o desempenho do sistema, sendo especialmente o caso em bases onde a contenção
é elevada.
Assim, propomos o atraso na execução de queries SQL na base de dados através da
introdução do protocolo de controlo de concorrência Lazy State Determination (LSD),
com a utilização de Futuros/Promessas e Java Database Connectivity (JDBC). Esta nova
Interface de Programação de Aplicações (API) permite adiar as operações para o momento
do commit, o que acaba por reduzir a janela da transação onde conflitos podem ocorrer.
Observamos que, ao utilizar LSD em um cliente JDBC, nós conseguimos aumentar a
taxa de execução de transações em 50% e reduzir a latência em 40% num ambiente de
contenção elevada
- …