1,980 research outputs found
Static detection of anomalies in transactional memory programs
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áticaTransactional Memory (TM) is an approach to concurrent programming based on the transactional semantics borrowed from database systems. In this paradigm, a transaction is a sequence of actions that may execute in a single logical instant, as though it was the only one being executed
at that moment. Unlike concurrent systems based in locks, TM does not enforce that a
single thread is performing the guarded operations. Instead, like in database systems, transactions execute concurrently, and the effects of a transaction are undone in case of a conflict, as though it never happened. The advantages of TM are an easier and less error-prone programming model, and a potential increase in scalability and performance.
In spite of these advantages, TM is still a young and immature technology, and has still
to become an established programming model. It still lacks the paraphernalia of tools and
standards which we have come to expect from a widely used programming paradigm. Testing
and analysis techniques and algorithms for TM programs are also just starting to be addressed by the scientific community, making this a leading research work is many of these aspects.
This work is aimed at statically identifying possible runtime anomalies in TMprograms. We
addressed both low-level dataraces in TM programs, as well as high-level anomalies resulting from incorrect splitting of transactions.
We have defined and implemented an approach to detect low-level dataraces in TM programs
by converting all the memory transactions into monitor protected critical regions, synchronized on a newly generated global lock. To validate the approach, we have applied our tool to a set of tests, adapted from the literature, that contain well documented errors.
We have also defined and implemented a new approach to static detection of high-level
concurrency anomalies in TM programs. This new approach works by conservatively tracing
transactions, and matching the interference between each consecutive pair of transactions
against a set of defined anomaly patterns. Once again, the approach was validated with well documented tests adapted from the literature
Maintaining consistency in client-server database systems with client-side caching
PhD ThesisCaching has been used in client-server database systems to improve the performance of applications. Much of the current work has concentrated on caching techniques at the server side, since the underlying assumption has been that clients are “thin” with application level processing taking place mainly at the server side. There are also a new class of “thick client” applications where clients need to access the database at the server but also perform substantial amount of processing at the client side; here client-side caching is needed to provide good performance for applications.
This thesis presents a transactional cache consistency scheme suitable for systems with client-side caching. The scheme is based on the optimistic approach to concurrency control. The scheme provides serializability for committed transactions. This is in contrast to many modern systems that only provide the snapshot isolation property which is weaker than serializability. A novel feature is that the processing load for validating transactions at commit time is shared between clients and the database server, thereby reducing the load at the server. Read-only transactions can be validated at the client-side, without communicating with the server. Another feature is that the scheme permits disconnected operation, allowing clients with cached objects to work offline.
The performance of the scheme is evaluated using simulation experiments. The experiments demonstrate that for mostly read only transaction load – for which caching is most effective - the scheme outperforms the existing concurrency control scheme with client-side caching considered to be the best, and matches the performance of the widely used scheme that only provides snapshot isolation. The results also show that the scheme in a disconnected environment provides reasonable performance.Directorate General of Higher Education, Ministry of National Education, Indonesia
A semantically aware transactional concurrency control for GPGPU computing
PhD ThesisThe increased parallel nature of the GPU a ords an opportunity for
the exploration of multi-thread computing. With the availability of
GPU has recently expanded into the area of general purpose program-
ming, a concurrency control is required to exploit parallelism as well
as maintaining the correctness of program. Transactional memory,
which is a generalised solution for concurrent con
ict, meanwhile allow
application programmers to develop concurrent code in a more intu-
itive manner, is superior to pessimistic concurrency control for general
use. The most important component in any transactional memory
technique is the policy to solve con
icts on shared data, namely the
contention management policy.
The work presented in this thesis aims to develop a software trans-
actional memory model which can solve both concurrent con
ict and
semantic con
ict at the same time for the GPU. The technique di ers
from existing CPU approaches on account of the di erent essential ex-
ecution paths and hardware basis, plus much more parallel resources
are available on the GPU. We demonstrate that both concurrent con-
icts and semantic con
icts can be resolved in a particular contention
management policy for the GPU, with a di erent application of locks
and priorities from the CPU.
The basic problem and a software transactional memory solution idea
is proposed rst. An implementation is then presented based on the
execution mode of this model. After that, we extend this system to re-
solve semantic con
ict at the same time. Results are provided nally,
which compare the performance of our solution with an established
GPU software transactional memory and a famous CPU transactional
memory, at varying levels of concurrent and semantic con
icts
Robust Verteilte Software Transaktionen für Haskell
This thesis motivates and develops a robust distributed Software Transactional Memory (STM) library for Haskell. Many real-life applications are distributed by nature. They either control geographically wide spread hardware resources or utilize redundant hardware components to minimize system failure. STM is an abstraction for synchronizing shared resources in concurrent applications. It helps to prevent deadlocks and thus facilitates composing program code.
We extend the STM abstraction to distributed systems and present an implementation efficient enough to be used in soft real-time applications. Further, the implemented library is robust in itself, offering the application developer a high abstraction level to realize robustness, hence, significantly simplifying this, in general, complex task.Die vorliegende Arbeit motiviert und entwickelt eine robuste, verteilte Software Transactional Memory (STM) Bibliothek für Haskell. Viele reale Anwendungen sind von Natur aus verteilt. Sie steuern entweder geografisch weit verteilte Ressourcen oder nutzen redundante Hardware-Komponenten, um Systemfehler zu verringern. STM ist eine Abstraktion, um gemeinsame Ressourcen in nebenläufigen Anwendungen zu synchronisieren. Sie hilft Verklemmungen zu verhindern und vereinfacht dadurch die Komposition des Programmcodes.
Wir erweitern die STM-Abstraktion auf verteilte Systeme und präsentieren eine Implementierung, die effizient genug ist, um in weichen Echtzeit-Anwendungen genutzt zu werden. Weiterhin ist die implementierte Bibliothek selbst robust und bietet damit dem Anwendungsprogrammierer ein hohes Maß an Abstraktion, um Robustheit zu verwirklichen, was ihm diese, im Allgemeinen, komplexe Aufgabe deutlich erleichtert
Enhancing the efficiency and practicality of software transactional memory on massively multithreaded systems
Chip Multithreading (CMT) processors promise to deliver higher performance by running more than one stream of instructions in parallel. To exploit CMT's capabilities, programmers have to parallelize their applications, which is not a trivial task. Transactional Memory (TM) is one of parallel programming models that aims at simplifying synchronization by raising the level of abstraction between semantic atomicity and the means by which that atomicity is achieved. TM is a promising programming model but there are still important challenges that must be addressed to make it more practical and efficient in mainstream parallel programming.
The first challenge addressed in this dissertation is that of making the evaluation of TM proposals more solid with realistic TM benchmarks and being able to run the same benchmarks on different STM systems. We first introduce a benchmark suite, RMS-TM, a comprehensive benchmark suite to evaluate HTMs and STMs. RMS-TM consists of seven applications from the Recognition, Mining and Synthesis (RMS) domain that are representative of future workloads. RMS-TM features current TM research issues such as nesting and I/O inside transactions, while also providing various TM characteristics. Most STM systems are implemented as user-level libraries: the programmer is expected to manually instrument not only transaction boundaries, but also individual loads and stores within transactions. This library-based approach is increasingly tedious and error prone and also makes it difficult to make reliable performance comparisons. To enable an "apples-to-apples" performance comparison, we then develop a software layer that allows researchers to test the same applications with interchangeable STM back ends.
The second challenge addressed is that of enhancing performance and scalability of TM applications running on aggressive multi-core/multi-threaded processors. Performance and scalability of current TM designs, in particular STM desings, do not always meet the programmer's expectation, especially at scale. To overcome this limitation, we propose a new STM design, STM2, based on an assisted execution model in which time-consuming TM operations are offloaded to auxiliary threads while application threads optimistically perform computation. Surprisingly, our results show that STM2 provides, on average, speedups between 1.8x and 5.2x over state-of-the-art STM systems. On the other hand, we notice that assisted-execution systems may show low processor utilization. To alleviate this problem and to increase the efficiency of STM2, we enriched STM2 with a runtime mechanism that automatically and adaptively detects application and auxiliary threads' computing demands and dynamically partition hardware resources between the pair through the hardware thread prioritization mechanism implemented in POWER machines.
The third challenge is to define a notion of what it means for a TM program to be correctly synchronized. The current definition of transactional data race requires all transactions to be totally ordered "as if'' serialized by a global lock, which limits the scalability of TM designs. To remove this constraint, we first propose to relax the current definition of transactional data race to allow a higher level of concurrency. Based on this definition we propose the first practical race detection algorithm for C/C++ applications (TRADE) and implement the corresponding race detection tool. Then, we introduce a new definition of transactional data race that is more intuitive, transparent to the underlying TM implementation, can be used for a broad set of C/C++ TM programs. Based on this new definition, we proposed T-Rex, an efficient and scalable race detection tool for C/C++ TM applications. Using TRADE and T-Rex, we have discovered subtle transactional data races in widely-used STAMP applications which have not been reported in the past
Sound Atomicity Inference for Data-Centric Synchronization
Data-Centric Concurrency Control (DCCC) shifts the reasoning about
concurrency restrictions from control structures to data declaration. It is a
high-level declarative approach that abstracts away from the actual concurrency
control mechanism(s) in use. Despite its advantages, the practical use of DCCC
is hindered by the fact that it may require many annotations and/or multiple
implementations of the same method to cope with differently qualified
parameters. Moreover, the existing DCCC solutions do not address the use of
interfaces, precluding their use in most object-oriented programs. To overcome
these limitations, in this paper we present AtomiS, a new DCCC model based on a
rigorously defined type-sound programming language. Programming with AtomiS
requires only (atomic)-qualifying types of parameters and return values in
interface definitions, and of fields in class definitions. From this atomicity
specification, a static analysis infers the atomicity constraints that are
local to each method, considering valid only the method variants that are
consistent with the specification, and performs code generation for all valid
variants of each method. The generated code is then the target for automatic
injection of concurrency control primitives, by means of the desired automatic
technique and associated atomicity and deadlock-freedom guarantees, which can
be plugged-into the model's pipeline. We present the foundations for the AtomiS
analysis and synthesis, with formal guarantees that the generated program is
well-typed and that it corresponds behaviourally to the original one. The
proofs are mechanised in Coq. We also provide a Java implementation that
showcases the applicability of AtomiS in real-life programs
Recommended from our members
Using Formal Methods to Verify Transactional Abstract Concurrency Control
Concurrent application design and implementation is more important than ever in today\u27s multi-core processor world. Transactional Memory (TM) Concurrent application design and implementation is more important than ever in today\u27s multi-core processor world. Transactional Memory (TM). Each has its own particular advantages and disadvantages. However, these techniques each need some extra information to `glue\u27 the non-transactional operation into a transactional context. At the most general level, non-transactional code must be decorated in such a way that the TM run-time can determine how those non-transactional operations commute with one another, and how to `undo\u27 the non-transactional operations in case the run-time needs to abort a software transaction. The TM run-time trusts that these programmer-provided annotations are correct. Therefore, if an implementor needs to employ one of these transactional `escape hatches\u27, it is crucially important that their concurrency control annotations be correct. However, reasoning about the commutativity of data structure operations is often challenging, and increasing the burden on the programmer with a proof requirement does not simplify the task of concurrent programming. There is a way to leverage the structure that these TM extensions require to reduce greatly the burden on the programmer. If the programmer could describe the abstract state of the data structure and then reason about it with as much machine assistance as possible, then there would be much less opportunity for error. Abstract state is preferable to a more concrete state, because it permits the programmer to use different concrete implementations of the same abstract data type. Also, some TM extensions such as open nesting can handle concrete state conflicts without programmer intervention (making the abstract state the appropriate state for reasoning about commutativity). A solution to the problem of specifying and verifying the concurrency properties of abstract data structures is the subject of this thesis. We will describe a new language, ACCLAM, for describing the abstract state of a data structure and reasoning about its concurrency control properties. This thesis also describes a tool that can process ACCLAM descriptions into a machine verifiable form (they are converted to a SAT problem). We will also provides a more detailed overview of transactional memory and the more popular extensions, a detailed semantic description of ACCLAM and a set of example data structure models and the results of processing those examples with the language processing tool
- …