Concurrent data representation synthesis

@article{Hawkins2012ConcurrentDR,
  title={Concurrent data representation synthesis},
  author={Peter Hawkins and Alexander Aiken and Kathleen Fisher and Martin C. Rinard and Mooly Sagiv},
  journal={Proceedings of the 33rd ACM SIGPLAN Conference on Programming Language Design and Implementation},
  year={2012}
}
  • Peter Hawkins, A. Aiken, M. Sagiv
  • Published 1 June 2012
  • Computer Science
  • Proceedings of the 33rd ACM SIGPLAN Conference on Programming Language Design and Implementation
We describe an approach for synthesizing data representations for concurrent programs. Our compiler takes as input a program written using concurrent relations and synthesizes a representation of the relations as sets of cooperating data structures as well as the placement and acquisition of locks to synchronize concurrent access to those data structures. The resulting code is correct by construction: individual relational operations are implemented correctly and the aggregate set of operations… 

Figures from this paper

Automatic scalable atomicity via semantic locking
TLDR
This paper presents a synthesis algorithm that automatically enforces atomicity of given code fragments (in a client program) by inserting pessimistic synchronization that guarantees atomicity and deadlock-freedom (without using any rollback mechanism).
Derivable Partial Locking for Algebraic Data Types 153 1 . 1 Background
TLDR
This article presents a method that helps the implementation of threadsafe programs with Algebraic Data Types with a built-in, configurable locking mechanism including partial locking and proves that the shared version of the calculation will produce the same result as the original one.
FSE : G : Cozy : Synthesizing Collection Data Structures
TLDR
This work replaced programmer-written data structure implementations by implementations synthesized by Cozy, a tool that synthesizes efficient data structures from short, simple, declarative specifications using the technique of counter-example guided inductive synthesis.
Generalized Data Structure Synthesis
TLDR
This paper shows how to synthesize data structures that track subsets and aggregations of multiple related collections, and evaluates the approach in four large case studies, demonstrating that these extensions are broadly applicable.
Building Fast Concurrent Data Structures through Data Structure Families.
TLDR
This paper describes a novel methodology that selects an optimal data structure implementation from a repository that allows for fast, correct, scalable implementations that do not lock the user into a single approach.
Using Abstract Interpretation to Correct Synchronization Faults
TLDR
It is proved that corrective synchronization is serializable and give conditions under which progress is ensured, and early encouraging results that the approach competes with or out-performs previous pessimistic or optimistic approaches.
Black-box Concurrent Data Structures for NUMA Architectures
TLDR
Node Replication (NR) takes an arbitrary sequential data structure and automatically transforms it into a NUMA-aware concurrent data structure satisfying linearizability, and applies it to the data structures of Redis, an in-memory storage system.
Concurrent libraries with foresight
TLDR
A novel approach in which the concurrent library ensures atomicity of composite operations by exploiting information (foresight) provided by its clients by using a correctness condition that guarantees that composite operations execute atomically without deadlocks, and without using rollbacks.
Semantics-preserving data layout transformations for improved vectorisation
TLDR
This paper presents a program transformation for a first-order functional array programming language that systematically modifies they layouts of all data structures and shows that the transformation abides to a correctness criterion for layout modifying program transformations.
MSL: A Synthesis Enabled Language for Distributed Implementations
TLDR
By leveraging high level notations in a new language called MSL, it is possible to scale the synthesis and automated bug-finding technologies that underlie MSL to realistic computational kernels and enable high level implementation ideas to be reused between similar kernels.
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 29 REFERENCES
Data representation synthesis
TLDR
A language of decompositions that permit the user to specify different concrete representations for relations, and it is shown that operations on concrete representations soundly implement their relational specification.
Automating relational operations on data structures
TLDR
The testing of compilers that produce Lisp code for iteration, and for adding and deleting tuples of composite relations, is reviewed and an approach to having compilers do most of the implementation detail work in programming that divides a program into two parts is described.
Inferring locks for atomic sections
TLDR
This paper presents a system that combines compiler and runtime techniques to automatically transform programs written with atomic sections into programs that only use locking primitives, and shows that the compiler is sound, and reports experimental results.
Automatic data structure selection in SETL
TLDR
A new technique for automatic selection of appropriate data representations during compile-time for undeclared, or partially declared programs, is described and an efficient data structure selection algorithm is presented, whose complexity is comparable with those of the fastest known general data-flow algorithms.
Deriving linearizable fine-grained concurrent objects
TLDR
This work follows a construction process that combines manual steps corresponding to high-level insights with automatic exploration of implementation details, and presents the steps that were used to derive various highly-concurrent algorithms.
Linearizability: a correctness condition for concurrent objects
TLDR
This paper defines linearizability, compares it to other correctness conditions, presents and demonstrates a method for proving the correctness of implementations, and shows how to reason about concurrent objects, given they are linearizable.
DiSTiL: A Transformation Library for Data Structures
TLDR
DiSTiL is a software generator that implements a declarative domain-specific language (DSL) for container data structures that relies on several reusable, general-purpose infrastructure tools offered by IP that substantially simplify DSL implementation.
Software transactional memory
TLDR
STM is used to provide a general highly concurrent method for translating sequential object implementations to non-blocking ones based on implementing a k-word compare&swap STM-transaction, a novel software method for supporting flexible transactional programming of synchronization operations.
Lock Inference for Atomic Sections
TLDR
A pessimistic lock-based technique that uses the results of static whole-program analysis to enforce atomicity and provides parallelism according to precision of the alias analysis while minimizing the number of required locks is proposed.
Programming by Refinement, as Exemplified by the SETL Representation Sublanguage
TLDR
The facilities provided by the representation sublanguage and the run-time data structures that it can generate are described and a heuristic which uses some of the methods of global program analysis and which should be capable of selecting an acceptably efficient representation automatically is given.
...
1
2
3
...