Functional programming for dynamic and large data with self-adjusting computation

Chen, Yan; Acar, Umut A.; Tangwongsan, Kanat

doi:10.1145/2692915.2628150

Cited by 7 publications

(7 citation statements)

References 58 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Our approach is based on the technique of self-adjusting computation for dynamizing static algorithms [1,2,23,27]. Prior work applied self-adjusting computation to problems in several areas including in dynamic data structures [3,4], computational geometry [7,8], large data sets [13,15], and machine learning algorithms [9,39]. All of this prior work assumes a sequential model of computation.…”

Section: Related Workmentioning

confidence: 99%

Brief Announcement

Acar

Aksenov²,

Westrick

2017

Proceedings of the 29th ACM Symposium on Parallelism in Algorithms and Architectures

Self Cite

View full text Add to dashboard Cite

Dynamic algorithms are used to compute a property of some data while the data undergoes changes over time. Many dynamic algorithms have been proposed but nearly all are sequential. In this paper, we present our ongoing work on designing a parallel algorithm for the dynamic trees problem, which requires computing a property of a forest as the forest undergoes changes. Our algorithm allows insertion and/or deletion of both vertices and edges anywhere in the input and performs updates in parallel. We obtain our algorithm by applying a dynamization technique called selfadjusting computation to the classic algorithm of Miller and Reif for tree contraction.

show abstract

Section: Related Workmentioning

confidence: 99%

Brief Announcement

Acar

Aksenov²,

Westrick

2017

Proceedings of the 29th ACM Symposium on Parallelism in Algorithms and Architectures

Self Cite

View full text Add to dashboard Cite

show abstract

“…This chapter is based on work on the theoretical formulation of implicit self-adjusting computation (Chen et al , 2014b, and a type system extension for precise dependency tracking (Chen et al 2014a).…”

Section: Chapter 6 Translationmentioning

confidence: 99%

“…This chapter is based on work on the empirical evaluation of implicit self-adjusting computation , and a language extension for computing with large and dynamic data in self-adjusting computation (Chen et al 2014a).…”

Section: Chapter 8 Empirical Evaluationmentioning

confidence: 99%

Implicit self-adjusting computation for purely functional programs

Chen¹,

Dunfield²,

Hammer³

et al. 2014

J. Funct. Prog.

Self Cite

View full text Add to dashboard Cite

Computational problems that involve dynamic data, such as physics simulations and program development environments, have been an important subject of study in programming languages. Building on this work, recent advances in self-adjusting computation have developed techniques that enable programs to respond automatically and efficiently to dynamic changes in their inputs. Self-adjusting programs have been shown to be efficient for a reasonably broad range of problems, but the approach still requires an explicit programming style, where the programmer must use specific monadic types and primitives to identify, create, and operate on data that can change over time. We describe techniques for automatically translating purely functional programs into self-adjusting programs. In this implicit approach, the programmer need only annotate the (top-level) input types of the programs to be translated. Type inference finds all other types, and a type-directed translation rewrites the source program into an explicitly self-adjusting target program. The type system is related to information-flow type systems and enjoys decidable type inference via constraint solving. We prove that the translation outputs well- typed self-adjusting programs and preserves the source program's input–output behavior, guaranteeing that translated programs respond correctly to all changes to their data. Using a cost semantics, we also prove that the translation preserves the asymptotic complexity of the source program.

show abstract

“…The proof relies on a substitution lemma for (SLet) case. We present the full proof in the appendix [14].…”

Section: Translating Expressionsmentioning

confidence: 99%

Functional programming for dynamic and large data with self-adjusting computation

Chen

Acar

Tangwongsan

2014

Proceedings of the 19th ACM SIGPLAN International Conference on Functional Programming

Self Cite

View full text Add to dashboard Cite

Combining type theory, language design, and empirical work, we present techniques for computing with large and dynamically changing datasets. Based on lambda calculus, our techniques are suitable for expressing a diverse set of algorithms on large datasets and, via self-adjusting computation, enable computations to respond automatically to changes in their data. To improve the scalability of self-adjusting computation, we present a type system for precise dependency tracking that minimizes the time and space for storing dependency metadata. The type system eliminates an important assumption of prior work that can lead to recording spurious dependencies. We present a type-directed translation algorithm that generates correct self-adjusting programs without relying on this assumption. We then show a probabilistic-chunking technique to further decrease space usage by controlling the fundamental spacetime tradeoff in self-adjusting computation. We implement and evaluate these techniques, showing promising results on challenging benchmarks involving large graphs.

show abstract

Functional programming for dynamic and large data with self-adjusting computation

Cited by 7 publications

References 58 publications

Brief Announcement

Brief Announcement

Implicit self-adjusting computation for purely functional programs

Functional programming for dynamic and large data with self-adjusting computation

Contact Info

Product

Resources

About