2,206 research outputs found
The application of scripts to deadlock avoidance
We describe the prototype of an expert system software advisor for the lock manager of a database system. The software advisor, called EAGLE (Expert Advisor for Granting Locks Effectively), is intended to become an embedded expert system within a database management system. EAGLE maintains a record of lock request and lock status within a database management system as an application processes transactions. Eag uses this dynamic lock data to avoid the granting of locks which could lead to a future deadlock. The sequence of lock requests and lock grantings is held as a script(s). EAGLE uses its collected record of lock request sequence to match against stereotypical lock event sequence (script base) and to learn to avoid such sequences in future. As EAGLE gains experience of lock event sequences leading to deadlock it recognises patterns which have led to deadlock, an avoids granting locks which would repeat a previous deadlock-inducing sequence of locks, thereby reducing the occurrence of deadlock. EAGLE treats the deadlock problem as a plan recognition issue rather than a problem resolution issue. We describe the general design of EAGLE, present some results from the EAGLE prototype implementation and discuss planned enhancements to EAGLE
STM: Lock-Free Synchronization
Current parallel programming uses low-level programming constructs like threads and explicit synchronization (for example, locks, semaphores and monitors) to coordinate thread execution which makes these programs difficult to design, program and debug. In this paper we present Software Transactional Memory (STM) which is a promising new approach for programming in parallel processors having shared memory. It is a concurrency control mechanism that is widely considered to be easier to use by programmers than other mechanisms such as locking. It allows portions of a program to execute in isolation, without regard to other, concurrently executing tasks. A programmer can reason about the correctness of code within a transaction and need not worry about complex interactions with other, concurrently executing parts of the program
Middleware-based Database Replication: The Gaps between Theory and Practice
The need for high availability and performance in data management systems has
been fueling a long running interest in database replication from both academia
and industry. However, academic groups often attack replication problems in
isolation, overlooking the need for completeness in their solutions, while
commercial teams take a holistic approach that often misses opportunities for
fundamental innovation. This has created over time a gap between academic
research and industrial practice.
This paper aims to characterize the gap along three axes: performance,
availability, and administration. We build on our own experience developing and
deploying replication systems in commercial and academic settings, as well as
on a large body of prior related work. We sift through representative examples
from the last decade of open-source, academic, and commercial database
replication systems and combine this material with case studies from real
systems deployed at Fortune 500 customers. We propose two agendas, one for
academic research and one for industrial R&D, which we believe can bridge the
gap within 5-10 years. This way, we hope to both motivate and help researchers
in making the theory and practice of middleware-based database replication more
relevant to each other.Comment: 14 pages. Appears in Proc. ACM SIGMOD International Conference on
Management of Data, Vancouver, Canada, June 200
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
Distributed replicated macro-components
Dissertação para obtenção do Grau de Mestre em
Engenharia InformáticaIn recent years, several approaches have been proposed for improving application
performance on multi-core machines. However, exploring the power of multi-core processors
remains complex for most programmers. A Macro-component is an abstraction
that tries to tackle this problem by allowing to explore the power of multi-core machines
without requiring changes in the programs. A Macro-component encapsulates several
diverse implementations of the same specification. This allows to take the best performance
of all operations and/or distribute load among replicas, while keeping contention
and synchronization overhead to the minimum.
In real-world applications, relying on only one server to provide a service leads to
limited fault-tolerance and scalability. To address this problem, it is common to replicate
services in multiple machines. This work addresses the problem os supporting such
replication solution, while exploring the power of multi-core machines.
To this end, we propose to support the replication of Macro-components in a cluster of
machines. In this dissertation we present the design of a middleware solution for achieving
such goal. Using the implemented replication middleware we have successfully deployed
a replicated Macro-component of in-memory databases which are known to have scalability
problems in multi-core machines. The proposed solution combines multi-master
replication across nodes with primary-secondary replication within a node, where several
instances of the database are running on a single machine. This approach deals with
the lack of scalability of databases on multi-core systems while minimizing communication
costs that ultimately results in an overall improvement of the services. Results show
that the proposed solution is able to scale as the number of nodes and clients increases.
It also shows that the solution is able to take advantage of multi-core architectures.RepComp project (PTDC/EIAEIA/108963/2008
An Approach for Supporting Ad-hoc Modifications in Distributed Workflow Management Systems
Supporting enterprise-wide or even cross-organizational business processes is a characteristic challenge for any workflow management system (WfMS). Scalability at the presence of high loads as well as the capability to dynamically modify running workflow (WF) instances (e.g., to cope with exceptional situations) are essential requirements in this context. Should the latter one, in particular, not be met, the WfMS will not have the necessary flexibility to cover the wide range of process-oriented applications deployed in many organizations. Scalability and flexibility have, for the most part, been treated separately in the relevant literature thus far. Even though they are basic needs for a WfMS, the requirements related with them are totally different. To achieve satisfactory scalability, on the one hand, the system needs to be designed such that a workflow instance can be controlled by several WF servers that are as independent from each other as possible. Yet dynamic WF modifications, on the other hand, necessitate a (logical) central control instance which knows the current and global state of a WF instance. For the first time, this paper presents methods which allow ad-hoc modifications (e.g., to insert, delete, or shift steps) to be performed in a distributed WfMS; i.e., in a WfMS with partitioned WF execution graphs and distributed WF control. It is especially noteworthy that the system succeeds in realizing the full functionality as given in the central case while, at the same time, achieving extremely favorable behavior with respect to communication costs
- …