Concurrent data representation synthesis

HawkinsPeter,; AikenAlex,; FisherKathleen,; RinardMartin,; SagivMooly,

doi:10.1145/2345156.2254114

“…We used the Graph benchmark [16] GossipRouter [6]. In these benchmarks, we compare the performance to coarse grained locking.…”

Section: Evaluating the Approach On Realistic Softwarementioning

confidence: 99%

“…In these benchmarks, we compare the performance to coarse grained locking. Graph This benchmark is based on a Java implementation of the Graph that has been used for the evaluation of [16]. The Graph consists of four composite operations: find successors, find predecessors, insert edge, and remove edge.…”

Section: Evaluating the Approach On Realistic Softwarementioning

confidence: 99%

See 1 more Smart Citation

Concurrent libraries with foresight

Golan-GuetaGuy

¹

,

RamalingamG.

²

,

SagivMooly

³

et al. 2013

Self Cite

View full text Add to dashboard Cite

Linearizable libraries provide operations that appear to execute atomically. Clients, however, may need to execute a sequence of operations (a composite operation) atomically. We consider the problem of extending a linearizable library to support arbitrary atomic composite operations by clients. We introduce a novel approach in which the concurrent library ensures atomicity of composite operations by exploiting information (foresight) provided by its clients. We use a correctness condition, based on a notion of dynamic rightmovers, that guarantees that composite operations execute atomically without deadlocks, and without using rollbacks.We present a static analysis to infer the foresight information required by our approach, allowing a compiler to automatically insert the foresight information into the client. This relieves the client programmer of this burden and simplifies writing client code.We present a generic technique for extending the library implementation to realize foresight-based synchronization. This technique is used to implement a general-purpose Java library for Map data structures -the library permits composite operations to simultaneously work with multiple instances of Map data structures.We use the Maps library and the static analysis to enforce atomicity of a wide selection of real-life Java composite operations. Our experiments indicate that our approach enables realizing efficient and scalable synchronization for real-life composite operations.

show abstract

“…This style of data organization is familiar from databases, and has been utilized by several recent works [26,27,51]. 2 The key advantage of the relational form is in abstracting data from its representation, which permits a clear, highlevel description of what guards and methods do.…”

Section: Preliminaries: Guards Methods and Relationsmentioning

confidence: 99%

Turning nondeterminism into parallelism

Tripp

¹

,

Koskinen

²

,

Sagiv

³

2013

Proceedings of the 2013 ACM SIGPLAN International Conference on Object Oriented Programming Systems Languages &Amp; Application

Self Cite

0

View full text Add to dashboard Cite

Nondeterminism is a useful and prevalent concept in the design and implementation of software systems. An important property of nondeterminism is its latent parallelism: A nondeterministic action can evaluate to multiple behaviors. If at least one of these behaviors does not conflict with concurrent tasks, then there is an admissible execution of the action in parallel with these tasks. Unfortunately, existing implementations of the atomic paradigm-optimistic as well as pessimistic-are unable to fully exhaust the parallelism potential of nondeterministic actions, lacking the means to guide concurrent tasks toward nondeterministic choices that minimize interference. This paper investigates the problem of utilizing parallelism due to nondeterminism. We observe that nondeterminism occurs in many real-world codes. We motivate the need for devising coordination mechanisms that can utilize available nondeterminism. We have developed a system featuring such mechanisms, which leverages nondeterminism in a wide class of query operations, allowing a task to look into the future of concurrent tasks that mutate the shared state during query evaluation and reduce conflict accordingly. We evaluate our system on a suite of 12 algorithmic benchmarks of wide applicability, as well as an industrial application. The results are encouraging.

show abstract

“…We compare four implementations of this pattern: (i) an implementation which is based on a global lock; (ii) an implementation which is based on our approach; (iii) an implementation which is based on ConcurrentHashMapV8; (iv) an implementation which is based on hand-crafted fine-grained locking (we used lock stripping, similar to [16], with 32 locks; this is an attempt to estimate the benefits of manual hand-crafted synchronization w/o changing the underlying library). The computation was emulated by allocating a relatively-large Java object (∼ 128 bytes).…”

Section: Comparison To Hand-crafted Implementationsmentioning

confidence: 99%

Concurrent libraries with foresight

Golan-Gueta

¹

,

Ramalingam

²

,

Sagiv

³

et al. 2013

Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation

Self Cite

View full text Add to dashboard Cite

Linearizable libraries provide operations that appear to execute atomically. Clients, however, may need to execute a sequence of operations (a composite operation) atomically. We consider the problem of extending a linearizable library to support arbitrary atomic composite operations by clients. We introduce a novel approach in which the concurrent library ensures atomicity of composite operations by exploiting information (foresight) provided by its clients. We use a correctness condition, based on a notion of dynamic rightmovers, that guarantees that composite operations execute atomically without deadlocks, and without using rollbacks.We present a static analysis to infer the foresight information required by our approach, allowing a compiler to automatically insert the foresight information into the client. This relieves the client programmer of this burden and simplifies writing client code.We present a generic technique for extending the library implementation to realize foresight-based synchronization. This technique is used to implement a general-purpose Java library for Map data structures -the library permits composite operations to simultaneously work with multiple instances of Map data structures.We use the Maps library and the static analysis to enforce atomicity of a wide selection of real-life Java composite operations. Our experiments indicate that our approach enables realizing efficient and scalable synchronization for real-life composite operations.

show abstract

Concurrent data representation synthesis

Cited by 15 publications

References 21 publications

Concurrent libraries with foresight

Concurrent libraries with foresight

Turning nondeterminism into parallelism

Concurrent libraries with foresight

Contact Info

Product

Resources

About