4,709 research outputs found
Formal Derivation of Concurrent Garbage Collectors
Concurrent garbage collectors are notoriously difficult to implement
correctly. Previous approaches to the issue of producing correct collectors
have mainly been based on posit-and-prove verification or on the application of
domain-specific templates and transformations. We show how to derive the upper
reaches of a family of concurrent garbage collectors by refinement from a
formal specification, emphasizing the application of domain-independent design
theories and transformations. A key contribution is an extension to the
classical lattice-theoretic fixpoint theorems to account for the dynamics of
concurrent mutation and collection.Comment: 38 pages, 21 figures. The short version of this paper appeared in the
Proceedings of MPC 201
A semantics and implementation of a causal logic programming language
The increasingly widespread availability of multicore and manycore computers demands new programming languages that make parallel programming dramatically easier and less error prone. This paper describes a semantics for a new class of declarative programming languages that support massive amounts of implicit parallelism
Automated Verification of Practical Garbage Collectors
Garbage collectors are notoriously hard to verify, due to their low-level
interaction with the underlying system and the general difficulty in reasoning
about reachability in graphs. Several papers have presented verified
collectors, but either the proofs were hand-written or the collectors were too
simplistic to use on practical applications. In this work, we present two
mechanically verified garbage collectors, both practical enough to use for
real-world C# benchmarks. The collectors and their associated allocators
consist of x86 assembly language instructions and macro instructions, annotated
with preconditions, postconditions, invariants, and assertions. We used the
Boogie verification generator and the Z3 automated theorem prover to verify
this assembly language code mechanically. We provide measurements comparing the
performance of the verified collector with that of the standard Bartok
collectors on off-the-shelf C# benchmarks, demonstrating their competitiveness
Bounded Concurrent Timestamp Systems Using Vector Clocks
Shared registers are basic objects used as communication mediums in
asynchronous concurrent computation. A concurrent timestamp system is a higher
typed communication object, and has been shown to be a powerful tool to solve
many concurrency control problems. It has turned out to be possible to
construct such higher typed objects from primitive lower typed ones. The next
step is to find efficient constructions. We propose a very efficient wait-free
construction of bounded concurrent timestamp systems from 1-writer multireader
registers. This finalizes, corrects, and extends, a preliminary bounded
multiwriter construction proposed by the second author in 1986. That work
partially initiated the current interest in wait-free concurrent objects, and
introduced a notion of discrete vector clocks in distributed algorithms.Comment: LaTeX source, 35 pages; To apper in: J. Assoc. Comp. Mac
An Innovative Approach to Achieve Compositionality Efficiently using Multi-Version Object Based Transactional Systems
In the modern era of multicore processors, utilizing cores is a tedious job.
Synchronization and communication among processors involve high cost. Software
transaction memory systems (STMs) addresses this issues and provide better
concurrency in which programmer need not have to worry about consistency
issues. Another advantage of STMs is that they facilitate compositionality of
concurrent programs with great ease. Different concurrent operations that need
to be composed to form a single atomic unit is achieved by encapsulating them
in a single transaction. In this paper, we introduce a new STM system as
multi-version object based STM (MVOSTM) which is the combination of both of
these ideas for harnessing greater concurrency in STMs. As the name suggests
MVOSTM, works on a higher level and maintains multiple versions corresponding
to each key. We have developed MVOSTM with the unlimited number of versions
corresponding to each key. In addition to that, we have developed garbage
collection for MVOSTM (MVOSTM-GC) to delete unwanted versions corresponding to
the keys to reduce traversal overhead. MVOSTM provides greater concurrency
while reducing the number of aborts and it ensures compositionality by making
the transactions atomic. Here, we have used MVOSTM for the list and hash-table
data structure as list-MVOSTM and HT- MVOSTM. Experimental results of
list-MVOSTM outperform almost two to twenty fold speedup than existing
state-of-the-art list based STMs (Trans-list, Boosting-list, NOrec-list,
list-MVTO, and list-OSTM). HT-MVOSTM shows a significant performance gain of
almost two to nineteen times better than existing state-of-the-art hash-table
based STMs (ESTM, RWSTMs, HT-MVTO, and HT-OSTM). MVOSTM with list and
hash-table shows the least number of aborts among all the existing STM
algorithms. MVOSTM satisfies correctness-criteria as opacity.Comment: 35 pages, 23 figure
- …