FlowPools: A Lock-Free Deterministic Concurrent Dataflow Abstraction

Prokopec, Aleksandar; Miller, Heather; Schlatter, Tobias; Haller, Philipp; Odersky, Martin

doi:10.1007/978-3-642-37658-0_11

Cited by 22 publications

(15 citation statements)

References 22 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Prokopec et al [23] show that higher-order functions can simplify the programming interface of data-flow abstractions in the context of parallel Collections. Odersky [18] shows how Scala's collections framework, which has the equivalent functional operations coming in Java 8, simplifies the use of parallelism when iterating over Colections.…”

Section: Related Workmentioning

confidence: 99%

Crossing the gap from imperative to functional programming through refactoring

Gyori

Franklin

Dig

et al. 2013

Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering

View full text Add to dashboard Cite

Java 8 introduces two functional features: lambda expressions and functional operations like map or filter that apply a lambda expression over the elements of a Collection. Refactoring existing code to use these new features enables explicit but unobtrusive parallelism and makes the code more succinct. However, refactoring is tedious: it requires changing many lines of code. It is also error-prone: the programmer must reason about the control-, data-flow, and side-effects. Fortunately, refactorings can be automated.We designed and implemented LambdaFicator, a tool which automates two refactorings. The first refactoring converts anonymous inner classes to lambda expressions. The second refactoring converts for loops that iterate over Collections to functional operations that use lambda expressions. Using 9 open-source projects, we have applied these two refactorings 1263 and 1709 times, respectively. The results show that LambdaFicator is useful: (i) it is widely applicable, (ii) it reduces the code bloat, (iii) it increases programmer productivity, and (iv) it is accurate.

show abstract

Section: Related Workmentioning

confidence: 99%

Crossing the gap from imperative to functional programming through refactoring

Gyori

Franklin

Dig

et al. 2013

Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering

View full text Add to dashboard Cite

show abstract

“…FlowPools Prokopec et al [29] recently proposed a data structure with an API closely related to ideas in LVish: a FlowPool is a bag that allows concurrent insertions but forbids removals, a seal operation that forbids further updates, and combinators like foreach that invoke callbacks as data arrives in the pool. To retain determinism, the seal operation requires explicitly passing the expected bag size as an argument, and the program will raise an exception if the bag goes over the expected size.…”

Section: Related Workmentioning

confidence: 98%

Freeze after writing

Kuper

Turon

Krishnaswami

et al. 2014

Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages

View full text Add to dashboard Cite

Deterministic-by-construction parallel programming models offer the advantages of parallel speedup while avoiding the nondeterministic, hard-to-reproduce bugs that plague fully concurrent code. A principled approach to deterministic-by-construction parallel programming with shared state is offered by LVars: shared memory locations whose semantics are defined in terms of an applicationspecific lattice. Writes to an LVar take the least upper bound of the old and new values with respect to the lattice, while reads from an LVar can observe only that its contents have crossed a specified threshold in the lattice. Although it guarantees determinism, this interface is quite limited.We extend LVars in two ways. First, we add the ability to "freeze" and then read the contents of an LVar directly. Second, we add the ability to attach event handlers to an LVar, triggering a callback when the LVar's value changes. Together, handlers and freezing enable an expressive and useful style of parallel programming. We prove that in a language where communication takes place through these extended LVars, programs are at worst quasideterministic: on every run, they either produce the same answer or raise an error. We demonstrate the viability of our approach by implementing a library for Haskell supporting a variety of LVarbased data structures, together with a case study that illustrates the programming model and yields promising parallel speedup.

show abstract

“…FlowPools [23] provide a deterministic concurrent dataflow abstraction for multisets, with an efficient lockfree implementation. Reactive Async generalizes FlowPools by supporting arbitrary lattice-based data, including but not limited to multisets.…”

Section: Related Workmentioning

confidence: 99%

“…Recently, researchers designed concurrency models, like LVars [15], FlowPools [23] and Isolation Types [6], that result in deterministic executions. The idea behind these models is to restrict expressivity to capture only computations that can be defined in a deterministic way.…”

Section: Introductionmentioning

confidence: 99%

Reactive Async: expressive deterministic concurrency

Haller

Geries

Eichberg

et al. 2016

Proceedings of the 2016 7th ACM SIGPLAN Symposium on Scala

Self Cite

View full text Add to dashboard Cite

Concurrent programming is infamous for its difficulty. An important source of difficulty is non-determinism, stemming from unpredictable interleavings of concurrent activities. Futures and promises are widely-used abstractions that help designing deterministic concurrent programs, although this property cannot be guaranteed statically in mainstream programming languages. Deterministic-by-construction concurrent programming models avoid this issue, but they typically restrict expressiveness in important ways.This paper introduces a concurrent programming model, Reactive Async, which decouples concurrent computations using so-called cells, shared locations which generalize futures as well as recent deterministic abstractions such as LVars. Compared to previously proposed programming models Reactive Async provides (a) a fallback mechanism for the case where no computation ever computes the value of a given cell, and (b) explicit and optimized handling of cyclic dependencies. We present a complete implementation of the Reactive Async programming model as a library in Scala. Finally, the paper reports on a case study applying Reactive Async to static analyses of JVM bytecode based on the Opal framework.

show abstract

FlowPools: A Lock-Free Deterministic Concurrent Dataflow Abstraction

Cited by 22 publications

References 22 publications

Crossing the gap from imperative to functional programming through refactoring

Crossing the gap from imperative to functional programming through refactoring

Freeze after writing

Reactive Async: expressive deterministic concurrency

Contact Info

Product

Resources

About