Towards Consistency Oblivious Programming

Afek, Yehuda; Avni, Hillel; Shavit, Nir

doi:10.1007/978-3-642-25873-2_6

Cited by 23 publications

(15 citation statements)

References 22 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…An STM allows a programmer to specify that certain blocks of code should be executed atomically relative to one another. Recently, several fast concurrent binary search-tree algorithms using STM have been introduced by Afek et al [2] and Bronson et al [4]. Although they offer good performance for Updates, Removes and Finds, they achieve this performance, in part, by carefully limiting the amount of data protected by the transactions.…”

Section: Related Workmentioning

confidence: 99%

“…• COP: We employed consistency oblivious programming (COP) [2] to reduce the overhead of STM. In COP, the read-only prefix of the operation is executed without any synchronization, followed by an STM transaction that checks the correctness of the prefix execution and performs any necessary updates.…”

Section: The Leap-list In a Nutshellmentioning

confidence: 99%

“…As shown, each node may hold up to a predefined number of data items with different keys and a set of pointers for each level below that node level. The operations of the Leap-Lists are implemented using the COP scheme [2], where in the "search phase 1 " the data-structure pointers are accessed outside of a transactional context to achieve better performance. Due to the weakly isolated nature of GCC-TM and the need to prevent uncommitted pointers from guiding us to uncommitted nodes, we use a novel method of writing marked pointers in a transaction and removing the mark after a successful commit.…”

Section: Leap-list Designmentioning

confidence: 99%

See 2 more Smart Citations

Leaplist

Avni

Shavit

Suissa

2013

Proceedings of the 2013 ACM Symposium on Principles of Distributed Computing

Self Cite

View full text Add to dashboard Cite

We introduce Leap-List, a concurrent data-structure that is tailored to provide linearizable range queries. A lookup in Leap-List takes O(log n) and is comparable to a balanced binary search tree or to a skip-list. However, in Leap-List, each node holds up-to K immutable key-value pairs, so collecting a linearizable range is K times faster than the same operation performed non-linearizably on a skip-list.We show how software transactional memory support in a commercial compiler helped us create an efficient lock-based implementation of Leap-List. We used this STM to implement short transactions which we call Locking Transactions (LT), to acquire locks, while verifying that the state of the data-structure is legal, and combine them with a transactional COP mechanism to enhance data structure traversals.We compare Leap-List to prior implementations of skip-lists, and show that while updates in the Leap-List are slower, lookups are somewhat faster, and for range-queries the Leap-List outperforms the skip-list's non-linearizable range query operations by an order of magnitude. We believe that this data structure and its performance would have been impossible to obtain without the STM support.

show abstract

Section: Related Workmentioning

confidence: 99%

Section: The Leap-list In a Nutshellmentioning

confidence: 99%

Section: Leap-list Designmentioning

confidence: 99%

See 1 more Smart Citation

Leaplist

Avni

Shavit

Suissa

2013

Proceedings of the 2013 ACM Symposium on Principles of Distributed Computing

Self Cite

View full text Add to dashboard Cite

show abstract

“…A common guideline for programmers using relational databases and transactional memory is to keep transactions as short as possible to maximise performance; long transactions should be chopped into smaller pieces [3,21,24]. This advice is also applicable to PSI databases: the longer a transaction, the higher the chances that it will abort due to a write conflict.…”

Section: Introductionmentioning

confidence: 99%

Transaction Chopping for Parallel Snapshot Isolation

Cerone

Gotsman

Yang

2015

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Abstract. Modern Internet services often achieve scalability and availability by relying on large-scale distributed databases that provide consistency models for transactions weaker than serialisability. We investigate the classical problem of transaction chopping for a promising consistency model in this class-parallel snapshot isolation (PSI), which weakens the classical snapshot isolation to allow more efficient large-scale implementations. Namely, we propose a criterion for checking when a set of transactions executing on PSI can be chopped into smaller pieces without introducing new behaviours, thus improving efficiency. We find that our criterion is more permissive than the existing one for chopping serialisable transactions. To establish our criterion, we propose a novel declarative specification of PSI that does not refer to implementation-level concepts and, thus, allows reasoning about the behaviour of PSI databases more easily. Our results contribute to building a theory of consistency models for modern large-scale databases.

show abstract

“…Afek et al [1] explored this approach in the context of software TM; they call it "consistency oblivious programming," because the work that is removed from the transaction must be able to tolerate an inconsistent view of memory. We have pursued a similar partitioning of lock-based critical sections, to shorten critical path length [22,23].…”

Section: Introductionmentioning

confidence: 99%

Software partitioning of hardware transactions

Xiang

Scott

2015

Proceedings of the 20th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming

View full text Add to dashboard Cite

Best-effort hardware transactional memory (HTM) allows complex operations to execute atomically and in parallel, so long as hardware buffers do not overflow, and conflicts are not encountered with concurrent operations. We describe a programming technique and compiler support to reduce both overflow and conflict rates by partitioning common operations into readmostly (planning) and write-mostly (completion) operations, which then execute separately. The completion operation remains transactional; planning can often occur in ordinary code. Highlevel (semantic) atomicity for the overall operation is ensured by passing an application-specific validator object between planning and completion.Transparent composition of partitioned operations is made possible through fully-automated compiler support, which migrates all planning operations out of the parent transaction while respecting all program data flow and dependences. For both micro-and macro-benchmarks, experiments on IBM z-Series and Intel Haswell machines demonstrate that partitioning can lead to dramatically lower abort rates and higher scalability.

show abstract

Towards Consistency Oblivious Programming

Cited by 23 publications

References 22 publications

Leaplist

Leaplist

Transaction Chopping for Parallel Snapshot Isolation

Software partitioning of hardware transactions

Contact Info

Product

Resources

About