192 research outputs found
Multiversion Conflict Notion for Transactional Memory Systems*
In recent years, Software Transactional Memory systems (STMs) have garnered significant interest
as an elegant alternative for addressing concurrency issues in memory. STM systems take optimistic
approach. Multiple transactions are allowed to execute concurrently. On completion, each
transaction is validated and if any inconsistency is observed it is aborted. Otherwise it is allowed to
commit.
In databases a class of histories called as conflict-serializability (CSR) based on the notion of
conflicts have been identified, whose membership can be efficiently verified. As a result, CSR is the
commonly used correctness criterion in databases In fact all known single-version schedulers known
for databases are a subset of CSR. Similarly, using the notion of conflicts, a correctness criterion,
conflict-opacity (co-opacity) which is a sub-class of can be designed whose membership can be
verified in polynomial time. Using the verification mechanism, an efficient STM implementation
can be designed that is permissive w.r.t co-opacity. Further, many STM implementations have been
developed that using the notion of conflicts.
By storing multiple versions for each transaction object, multi-version STMs provide more concurrency
than single-version STMs. But the main drawback of co-opacity is that it does not admit
histories that are uses multiple versions. This has motivated us to develop a new conflict notions for
multi-version STMs. In this paper, we present a new conflict notion multi-version conflict. Using
this conflict notion, we identify a new subclass of opacity, mvc-opacity that admits multi-versioned
histories and whose membership can be verified in polynomial time. We show that co-opacity is a
proper subset of this class.
An important requirement that arises while building a multi-version STM system is to decide
“on the spot” or schedule online among the various versions available, which version should a transaction
read from? Unfortunately this notion of online scheduling can sometimes lead to unnecessary
aborts of transactions if not done carefully. To capture the notion of online scheduling which avoid
unnecessary aborts in STMs, we have identified a new concept ols-permissiveness and is defined
w.r.t a correctness-criterion, similar to permissiveness. We show that it is impossible for a STM system
that is permissive w.r.t opacity to such avoid un-necessary aborts i.e. satisfy ols-permissiveness
w.r.t opacity. We show this result is true for mvc-opacity as well
Mechanized proofs of opacity: A comparison of two techniques
Software transactional memory (STM) provides programmers with a high-level programming abstraction
for synchronization of parallel processes, allowing blocks of codes that execute in an interleaved manner to be treated
as atomic blocks. This atomicity property is captured by a correctness criterion called opacity, which relates the
behaviour of an STM implementation to those of a sequential atomic specification. In this paper, we prove opacity of
a recently proposed STM implementation: the Transactional Mutex Lock (TML) by Dalessandro et al. For this, we
employ two different methods: the first method directly shows all histories of TML to be opaque (proof by induction),
using a linearizability proof of TML as an assistance; the second method shows TML to be a refinement of an existing
intermediate specification called TMS2 which is known to be opaque (proof by simulation).
Both proofs are carried out within interactive provers, the first with KIV and the second with both Isabelle and
KIV. This allows to compare not only the proof techniques in principle, but also their complexity in mechanization.
It turns out that the second method, already leveraging an existing proof of opacity of TMS2, allows the proof to be
decomposed into two independent proofs in the way that the linearizability proof does not
Composability of transactions using closed nesting in software transactional memory
With the boom in the development of multi-core machines and the development
of multi-threaded applications as such, concurrent programming has gained increasingly
more significance than ever before. However, concurrent programming using
traditional methods such as locks, mutex and monitors is not easy, as they require
a programmer to predetermine the lock management scheme for each case. This
approach is error-prone. Besides, it is very difficult to trace the bugs in such programs.
Software transactional memory (STM) is a new technology that solves this
problem by offering automatic management of locks. As such, in recent years STM
has gained a lot of attention in both industry and academia. However, most of the
work in STM is restricted to non-nested transactions, while the domain of nested
transactions remains largely unexplored.
One of the striking features of STM is its ability to support composability of transactions
through three types of nesting, namely
at nesting, closed nesting and open
nesting. In this thesis, we study the complexities involved in designing STM protocols
for closed nested transactions. To this end, we extend Imbs and Raynal's STM
protocol [1], which is designed for non-nested transactions, to closed nested transactions.
We propose several extensions, employing different modes of concurrency
for subtransactions in the transaction tree : (i) serial execution (no concurrency) of
subtransactions at each level; (ii) pessimistic concurrency control at all nodes; (iii)
optimistic concurrency control at all nodes; and (iv) a mixture of optimistic concurrency
control at some nodes while pessimistic concurrency control at other nodes in
the same transaction tree
Performance Optimization Strategies for Transactional Memory Applications
This thesis presents tools for Transactional Memory (TM) applications that cover multiple TM systems (Software, Hardware, and hybrid TM) and use information of all different layers of the TM software stack. Therefore, this thesis addresses a number of challenges to extract static information, information about the run time behavior, and expert-level knowledge to develop these new methods and strategies for the optimization of TM applications
Micro Virtual Machines: A Solid Foundation for Managed Language Implementation
Today new programming languages proliferate, but many of them
suffer from
poor performance and inscrutable semantics. We assert that the
root of
many of the performance and semantic problems of today's
languages is
that language implementation is extremely difficult. This
thesis
addresses the fundamental challenges of efficiently developing
high-level
managed languages.
Modern high-level languages provide abstractions over execution,
memory
management and concurrency. It requires enormous intellectual
capability
and engineering effort to properly manage these concerns.
Lacking such
resources, developers usually choose naive implementation
approaches
in the early stages of language design, a strategy which too
often has
long-term consequences, hindering the future development of the
language. Existing language development platforms have failed
to
provide the right level of abstraction, and forced implementers
to
reinvent low-level mechanisms in order to obtain performance.
My thesis is that the introduction of micro virtual machines will
allow
the development of higher-quality, high-performance managed
languages.
The first contribution of this thesis is the design of Mu, with
the
specification of Mu as the main outcome. Mu is
the first micro virtual machine, a robust, performant, and
light-weight
abstraction over just three concerns: execution, concurrency and
garbage
collection. Such a foundation attacks three of the most
fundamental and
challenging issues that face existing language designs and
implementations, leaving the language implementers free to focus
on the
higher levels of their language design.
The second contribution is an in-depth analysis of on-stack
replacement
and its efficient implementation. This low-level mechanism
underpins
run-time feedback-directed optimisation, which is key to the
efficient
implementation of dynamic languages.
The third contribution is demonstrating the viability of Mu
through
RPython, a real-world non-trivial language implementation. We
also did
some preliminary research of GHC as a Mu client.
We have created the Mu specification and its reference
implementation,
both of which are open-source. We show that that Mu's on-stack
replacement API can gracefully support dynamic languages such as
JavaScript, and it is implementable on concrete hardware. Our
RPython
client has been able to translate and execute non-trivial
RPython
programs, and can run the RPySOM interpreter and the core of the
PyPy
interpreter.
With micro virtual machines providing a low-level substrate,
language
developers now have the option to build their next language on a
micro
virtual machine. We believe that the quality of programming
languages
will be improved as a result
A versatile STM protocol with invisible read operations that satisfies the virtual world consistency condition
International audienc
A versatile STM protocol with invisible read operations that satisfies the virtual world consistency condition
The aim of a Software Transactional Memory (STM) is to discharge the programmers from the management of synchronization in multiprocess programs that access concurrent objects. To that end, a STM system provides the programmer with the concept of a transaction. The job of the programmer is to decompose each sequential process the application is made up of into transactions. A transaction is a piece of code that accesses concurrent objects, but contains no explicit synchronization statement. It is the job of the underlying STM system to provide the illusion that each transaction appears as being executed atomically. For efficiency, a STM system allows transactions to execute concurrently. Consequently, due to the underlying STM concurrency management, a transaction commits or aborts. This paper first presents a new STM consistency condition, called virtual world consistency. This condition states that no transaction reads object values from an inconsistent global state. It is similar to opacity for the committed transactions but weaker for the aborted transactions. More precisely, it states that (1) the committed transactions can be totally ordered, and (2) the values read by each aborted transaction are consistent with respect to its causal past only. Hence, virtual world consistency is weaker than opacity while keeping its spirit. Then, assuming the objects shared by the processes are atomic read/write objects, the paper presents a STM protocol that ensures virtual world consistency (while guaranteeing the invisibility of the read operations). From an operational point of view, this protocol is based on a vector-clock mechanism. Finally, the paper considers the case where the shared objects are regular read/write objects. It also shows how the protocol can be weakened to satisfy the causal consistency condition (that is weaker than virtual world consistency). Virtual world consistency does not require the aborted transactions to agree on what they have seen. This is captured by the local vector clocks associated with each process and the vector timestamps associated with each object. From a comprehensive point of view, the paper addresses how the interplay of these local control informations allows the execution of a set of transactions to be provided with a global meaning
- …