Victor Luchangco

Suggest Changes
Mark Moir74
Nir Shavit58
Maurice Herlihy55
Nancy A. Lynch48
Michael L. Scott41
57Mark Moir
45Brijesh Dongol
45John Derrick
39Virendra J. Marathe
38Nir Shavit

Filter Results:

  • Full text PDF available (65)

Publication Year

1992
2016
  • This year (0)
  • Last five years (16)

Publication Type

Co-author

Publication Venue

Key Phrases

Learn More
Software transactional memory for dynamic-sized data structures
We propose a new form of software transactional memory (STM) designed to support dynamic-sized data structures, and we describe a novel non-blocking implementation. The non-blocking property we consider is <i>obstruction-freedom</i>. Obstruction-freedom is weaker than lock-freedom; as a result, it admits substantially simpler and more efficient… (More)
A flexible framework for implementing software transactional memory
We describe DSTM2, a Java&#8482; software library that provides a flexible framework for implementing object-based software transactional memory (STM). The library uses <i>transactional factories</i> to transform sequential (unsynchronized) classes into atomic (transactionally synchronized) ones, providing a substantial improvement over the awkward… (More)
Hybrid transactional memory
Transactional memory (TM) promises to substantially reduce the difficulty of writing correct, efficient, and scalable concurrent programs. But "bounded" and "best-effort" hardware TM proposals impose unreasonable constraints on programmers, while more flexible software TM implementations are considered too slow. Proposals for supporting "unbounded"… (More)
A Lazy Concurrent List-Based Set Algorithm
List-based implementations of sets are a fundamental building block of many concurrent algorithms. A skiplist based on the lock-free list-based set algorithm of Michael will be included in the Java TM Con-currency Package of JDK 1.6.0. However, Michael's lock-free algorithm has several drawbacks, most notably that it requires all list traversal operations ,… (More)
Formal Verification of a Practical Lock-Free Queue Algorithm
We describe a semi-automated verification of a slightly optimised version of Michael and Scott's lock-free FIFO queue implementation. We verify the algorithm with a simulation proof consisting of two stages: a forward simulation from an automaton modelling the algorithm to an intermediate automaton, and a backward simulation from the intermediate automaton… (More)
Towards formally specifying and verifying transactional memory
Over the last decade, great progress has been made in developing practical transactional memory (TM) implementations, but relatively little attention has been paid to precisely specifying what it means for them to be correct, or formally proving that they are. In this paper, we present TMS1 (Transactional Memory Specification 1), a precise specification of… (More)
DCAS is not a silver bullet for nonblocking algorithm design
Despite years of research, the design of efficient nonblocking algorithms remains difficult. A key reason is that current shared-memory multiprocessor architectures support only single-location synchronisation primitives such as compare-and-swap (CAS) and load-linked/store-conditional (LL/SC). Recently researchers have investigated the utility of… (More)
Obstruction-Free Synchronization: Double-Ended Queues as an Example
We introduce obstruction-freedom, a new nonblocking property for shared data structure implementations. This property is strong enough to avoid the problems associated with locks, but it is weaker than previous nonblocking properties—specifically lock-freedom and wait-freedom— allowing greater flexibility in the design of efficient implementations.… (More)
Formal Verification of a Lazy Concurrent List-Based Set Algorithm
We describe a formal verification of a recent concurrent list-based set algorithm due to Heller et al. The algorithm is optimistic: the add and remove operations traverse the list without locking, and lock only the nodes affected by the operation; the contains operation uses no locks and is wait-free. These properties make the algorithm challenging to prove… (More)