Data representation synthesis

@inproceedings{Hawkins2011DataRS,
  title={Data representation synthesis},
  author={Peter Hawkins and Alexander Aiken and Kathleen Fisher and Martin C. Rinard and Mooly Sagiv},
  booktitle={PLDI '11},
  year={2011}
}
We consider the problem of specifying combinations of data structures with complex sharing in a manner that is both declarative and results in provably correct code. In our approach, abstract data types are specified using relational algebra and functional dependencies. We describe a language of decompositions that permit the user to specify different concrete representations for relations, and show that operations on concrete representations soundly implement their relational specification. It… 

Figures and Tables from this paper

An introduction to data representation synthesis
TLDR
A language of decompositions is described that permits the user to specify different concrete representations for relations, and it is shown that operations on concrete representations soundly implement their relational specification.
Concurrent data representation synthesis Citation
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
Concurrent data representation synthesis
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
Development of automatically verifiable systems using data representation synthesis
TLDR
In this work, a port of the Fiasco.OC microkernel is presented to structures generated by Data Representation Synthesis that will be automatically verified by precise container reasoning techniques.
Synthesizing Concurrent Graph Data Structures: A Case Study
TLDR
A number of techniques used to specialize the graph data structure implementation for the application and the performance benefit from these specializations are discussed.
Extensible Data-Representation Selection for Correct-by-Construction Program Derivation
  • Computer Science
  • 2015
TLDR
This work presents the first automated, proof-generating refinement system that invents new data structures to suit the needs of a program, applying global program analysis to understand those needs.
Writing data-centric concurrent programs in imperative languages
TLDR
It is argued that the primary benefits of such languages come not from their declarative nature, but instead from the design patterns they espouse, and how to apply these design patterns to C and Java is explained.
Synthesizing iterators from abstraction functions
TLDR
It is demonstrated that most of the iterators in the widely used JDK Collections classes can be replaced with code synthesized from declarative abstraction functions, and these synthesized iterators perform competitively with the hand-written originals.
Code Generation for Abstract Data Types Based on Program Analysis
  • Li Bin, Liu Jun, Zhao Jianhua
  • Computer Science
    2015 IEEE International Conference on Software Quality, Reliability and Security - Companion
  • 2015
TLDR
Two techniques are used based on the properties derived through data-flow analysis to generate efficient code based on element, which is an abstract data type and declares a variable belonging to an existing container.
Code Generation for Abstract Data Types Based on Program Analysis
TLDR
Two techniques are used based on the properties derived through data-flow analysis to generate efficient code based on element, which is an abstract data type and declares a variable belonging to an existing container.
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 40 REFERENCES
Data Structure Fusion
TLDR
This work permits the user to specify different concrete shared representations for relations, and shows that the semantics of the relational specification are preserved.
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.
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.
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.
Graph types
TLDR
A notion of graph types is proposed, which allow common shapes, such as doubly-linked lists or threaded trees, to be expressed concisely and efficiently.
Separation logic: a logic for shared mutable data structures
  • J. C. Reynolds
  • Computer Science
    Proceedings 17th Annual IEEE Symposium on Logic in Computer Science
  • 2002
TLDR
An extension of Hoare logic that permits reasoning about low-level imperative programs that use shared mutable data structure is developed, including extensions that permit unrestricted address arithmetic, dynamically allocated arrays, and recursive procedures.
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.
Full functional verification of linked data structures
TLDR
The Jahob verification system is used to verify formal specifications, written in classical higher-order logic, that completely capture the desired behavior of the Java data structure implementations (with the exception of properties involving execution time and/or memory consumption).
Modular Verification with Shared Abstractions
TLDR
This work constructed a novel modular static analysis and implemented a proof-of-concept analyzer to verify that the inter-module sharing is restricted to a user-provided specification which also enables the analysis to handle side-effects.
...
1
2
3
4
...