Y. A. Liu and T. Teitelbaum. Caching intermediate results for program improvement. In Proceedings of the ACM SIGPLAN Symposium on on PEPM, La Jolla, California, June 1995.  Home/Search   Document Details and Download   Summary   Related Articles   Check

....using previous values of the function to compute its new value. Second, automatically using previous values given by subformulas of the given function in the computation of its new value. Third, discovering new values to maintain as auxiliary data to aid in the computation of the function [27, 26, 28]. Fundamental work on the creation of programs obeying temporal logic specifications has been done by Pnueli. He has given algorithms for both the creation of finite state machines meeting temporal specifications and the creation of infinite state machines, based on the timed automata model, ....

Liu, Yanhong A., and Teitelbaum, Tim. Caching intermediate results for program improvement. In ACM SIGPLAN Symposium on Partial Evaluation and SemanticsBased Program Manipulation (La Jolla, CA, June 1995), ACM Press, pp. 190--201.

.... targeted toward very high level set theoretic languages were investigated by Fong and Ullman (Fong and Ullman, 1976; Fong, 1977; Fong, 1979) More recently, Liu and Stoller have used some extensions of these ideas to optimize array computations (Liu and Stoller, 1998) and recursive programs (Liu and Stoller, 2000). Liu et al. have also shown how such transformations can be applied to derive algorithms for incrementalcomputation problems (i.e. problems in which the goal is to maintain the value of some function F (x) as the input x undergoes small changes) Liu, 1995; Liu and Teitelbaum, 1995a; Liu and ....

Liu, Y. and T. Teitelbaum: 1995a, `Caching Intermediate Results for Program Improvement'. In: Proc. of the ACM SIGPLAN Symp. on Part. Eval. and Sem.-Based Prog. Manip. New York, NY, ACM Press.

....they only handled functions with a single recursion parameter, while the accumulative parameters are generalised whenever possible. No attempt is made to analyse the synchronizability of multiple recursion accumulating parameters. With the aim of deriving incremental programs, Liu and Teitelbaum [12, 11] presented a three stage method to cache, incrementalize and prune user programs. The caching stage gathers all intermediate and auxiliary results which might be needed to incrementalize, while pruning removes unneeded results. While their method may be quite general, its power depends largely on ....

Y A. Liu and T. Teitelbaum. Caching intermediate results for program improvement. In ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation, pages 190--201, La Jolla, California, June 1995. ACM Press.

....has concerned imperative programming languages. In the context of functional languages, a slicing like operation is used by Liu and Teitelbaum as a cleanup step in their transformational methodology for deriving incremental versions of functional programs from non incremental functional programs [20]. In their work, slices can be taken only with respect to projection functions that express finite depth access patterns in a tree. In contrast, the method we have presented uses regular tree grammars to express projection functions that have arbitrary depth (but regular) access patterns. This ....

Liu, Y.A. and Teitelbaum, T., "Caching intermediate results for program improvement," in Proceedings of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation (PEPM 95), (La Jolla, California, June 21-23, 1995), ACM, New York, NY (1995).

.... calls [39, 40] saving results of intermediate reductions at appointed places [16] maintaining the change detailing network of INC [52] keeping residual programs for certain input partitions [47] and maintaining intermediate results and dependencies identified by Alphonse annotations [20] In [30], we have given a cache and prune method to statically transform programs to cache all kinds of intermediate results needed for incremental computation. The basic idea is to (I) extend the program f to a program f that returns all intermediate results, II) incrementalize the program f under ....

....[31] and collecting all subcomputations that depend on the previous input x. Then, we merge such information with intermediate results of f(x) and decide which of them are needed for efficient incremental computation and how they can be used (in a fashion similar to the cache and prune method in [30]) As a result, we derive a program that uses the needed intermediate results and auxiliary information to compute f incrementally, while incrementally maintaining these results and information at the same time. Our approach is modular: each component performs relatively independent analyses ....

[Article contains additional citation context not shown here]

Y. A. Liu and T. Teitelbaum. Caching intermediate results for program improvement. In Proceedings of the ACM SIGPLAN Symposium on on PEPM, La Jolla, California, June 1995.

....where maintaining expensive subexpressions (E1 to E4 and W ) and auxiliary expressions (E11 to E41) in additional to the desired output (O) is crucial for achieving the eciency of the algorithm. The idea of exploiting and incrementally maintaining return value [33] intermediate results [32, 31], and auxiliary information [30] is described more explicitly by Liu et al. in the context of incrementalizing recursive functions [27] Making these aspects explicit, as we did in this paper, help make the method for set expressions more systematic too. Fixed point expressions and dominated ....

....the formal approach to data structure selection in [18] might be helpful. Our study of regular tree grammar based constraints for dead code elimination is actually motivated by the need to prune unused values and computations in recursive functions and data structures after incrementalization [32, 31]. Previously, an algorithm was designed by informally applying nite di erencing so that after adding a new production, we consider only productions in extended forms whose right sides use the left side symbol of the new production [29] a simple analysis gives a O(n 3 ) time complexity, while ....

Y. A. Liu and T. Teitelbaum. Caching intermediate results for program improvement. In PEPM 1995 [43], pages 190-201.

....Extending f 0 to cache all intermediate results uses the transformations in Stage I of [54] It rst performs a straightforward extension transformation to embed all intermediate results in the nal return value and then performs administrative simpli cations. Certain improvements, suggested in [55] but not given in [55] or [54] can be made to the extension transformation. In particular, we can avoid caching redundant intermediate results, i.e. values of function applications that are already embedded in the values of their enclosing computations, since these omitted values can be ....

....all intermediate results uses the transformations in Stage I of [54] It rst performs a straightforward extension transformation to embed all intermediate results in the nal return value and then performs administrative simpli cations. Certain improvements, suggested in [55] but not given in [55] or [54] can be made to the extension transformation. In particular, we can avoid caching redundant intermediate results, i.e. values of function applications that are already embedded in the values of their enclosing computations, since these omitted values can be retrieved from the results of ....

[Article contains additional citation context not shown here]

Y. A. Liu and T. Teitelbaum. Caching intermediate results for program improvement. In Proceedings of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation, pages 190-201. ACM, New York, June 1995.

....where maintaining expensive subexpressions (E1 to E4 and W ) and auxiliary expressions (E11 to E41) in additional to the desired output (O) is crucial for achieving the efficiency of the algorithm. The idea of exploiting and incrementally maintaining return value [30] intermediate results [29, 28], and auxiliary information [27] is described more explicitly by Liu et al. in the context of incrementalizing recursive functions [24] Making these aspects explicit, as we did in this paper, help make the method for set expressions more systematic too. Fixed point expressions and dominated ....

....the formal approach to data structure selection in [16] might be helpful. Our study of regular tree grammar based constraints for dead code elimination is actually motivated by the need to prune unused values and computations in recursive functions and data structures after incrementalization [29, 28]. Previously, an algorithm was designed by informally applying finite differencing so that after adding a new production, we consider only productions in extended forms whose right sides use the left side symbol of the new production [26] a simple analysis gives a O(n 3 ) time complexity, while ....

Y. A. Liu and T. Teitelbaum. Caching intermediate results for program improvement. In PEPM 1995 [38], pages 190--201. 24

....of the major ideas discussed in this thesis, draws some conclusions, and suggests areas for future research. As an aid to the reader, an index of symbols, terms, and names are included at the end of the thesis. Much of Chapters 3, 4, 5, and 6 appears in separate papers (specifically, LT95b] LT95a] LST96] and [Liu95] respectively) Each of them is largely self contained. Chapter 2 Providing a general systematic approach to efficient computation Incremental computation takes advantage of repeated computations on inputs that differ slightly from one another, computing each new output ....

Yanhong A. Liu and Tim Teitelbaum. Caching intermediate results for program improvement. In Proceedings of the ACM SIGPLAN Symposium on PEPM, pages 190--201, La Jolla, California, June 1995.

....No. N00014 92 J 1973 and NSF under contract No. CCR 9503319. Author s address: Department of Computer Science, Cornell University, Ithaca, NY 14853. Email: yanhong cs.cornell.edu computes f(x Phi y) efficiently by making use of f(x) 32] the intermediate results computed in computing f(x) [31], and auxiliary information about f(x) that can be inexpensively maintained [30] Since every non trivial computation proceeds by iteration (or recursion) the approach can be used for achieving efficient computation by computing each iteration using an appropriate incremental program. However, ....

....in Figure 1. From the loop body, we obtain the function f and operation Phi: f(n; m; i) n; update(n; m; i) i Gamma 1 and hn; m; ii Phi h i = hn; update(n; m; i) i Gamma 1i (5) 3. 2 Step 2: Incrementalization Given a function f and an input change operation Phi, using the approach in [29, 30, 31, 32], we can derive an incremental program that computes f(x Phi y) incrementally by using the return value [32] the intermediate results [31] and certain auxiliary information [30] of f(x) i.e. we obtain a function f that computes f(x) and necessary additional information, a function f 0 ....

[Article contains additional citation context not shown here]

Y. A. Liu and T. Teitelbaum. Caching intermediate results for program improvement. In Proceedings of the ACM SIGPLAN Symposium on PEPM, pages 190--201, La Jolla, California, June 1995.

.... calls [39, 40] saving results of intermediate reductions at appointed places [16] maintaining the change detailing network of INC [52] keeping residual programs for certain input partitions [47] and maintaining intermediate results and dependencies identified by Alphonse annotations [20] In [30], we have given a cache and prune method to statically transform programs to cache all kinds of intermediate results needed for incremental computation. The basic idea is to (I) extend the program f to a program f that returns all intermediate results, II) incrementalize the program f under ....

....[31] and collecting all subcomputations that depend on the previous input x. Then, we merge such information with intermediate results of f(x) and decide which of them are needed for efficient incremental computation and how they can be used (in a fashion similar to the cache and prune method in [30]) As a result, we derive a program f 0 that uses the needed intermediate results and auxiliary information to compute f incrementally, while incrementally maintaining these results and information at the same time. Our approach is modular: each component performs relatively independent ....

[Article contains additional citation context not shown here]

Y. A. Liu and T. Teitelbaum. Caching intermediate results for program improvement. In Proceedings of the ACM SIGPLAN Symposium on on PEPM, La Jolla, California, June 1995.

....Sections 4, 5, and 6 describe caching, incrementalization, and pruning, respectively. Several examples are given in Section 7. Finally, we discuss related work and conclude in Section 8. For more details of some transformations, examples, and related work, see the extended version of this paper [25]. 2 Defining the problem We use a simple first order functional programming language. The expressions of our language are given by the following grammar: e : v variable j c(e1 ; en) constructor application j p(e1 ; en) primitive function application j f(e1 ; en) function ....

Y. A. Liu and T. Teitelbaum. Caching intermediate results for program improvement. Technical Report TR 95-1498, Department of Computer Science, Cornell University, Ithaca, New York, March 1995.

.... have been studied for various language features, such as strength reduction of arithmetic operations [4, 14, 31, 32] finite differencing of set and bag operations [51, 52, 54, 53, 72] and promotion and accumulation, finite differencing, and incrementalization of recursive functions [9, 43, 45, 46, 47, 63], but no systematic technique handles aggregate computations on arrays. At the same time, many optimizations have been studied for arrays, such as various APL compiler optimizations [26, 36, 49] loop fusion [3, 5, 29, 66] pipelining [2] and loop reordering [7, 39, 50, 56, 62] but none of them ....

....performed. Each of these components is relatively simple, and the overall optimization algorithm is modular. Both analytical and experimental results show drastic speedups that are not achievable by previous compiler optimizations. Methods of explicit incrementalization [47] cache and prune [46], and use of auxiliary information [45] were first formulated for a functional language [43] They have been adopted for loop incrementalization of imperative programs with no arrays, generalizing traditional strength reduction [44] This paper extends that work to handle imperative programs that ....

[Article contains additional citation context not shown here]

Y. A. Liu and T. Teitelbaum. Caching intermediate results for program improvement. In Proceedings of the ACM SIGPLAN Symposium on PEPM, pages 190--201, La Jolla, California, June 1995.

....results of the previous computation as parameters, and it uses auxiliary specialization [19] to find subcomputations whose values can be retrieved from the cached results of the previous computation. CACHET has been used to derive numerous incremental programs, including most of the examples in [19, 20, 21]. It has also been of great help in studying transformations for caching intermediate results [20] and discovering auxiliary information [21] The rest of the paper is organized as follows. Section 2 gives an overview of the desired features, the problems to be solved, and the suggested solutions. ....

....whose values can be retrieved from the cached results of the previous computation. CACHET has been used to derive numerous incremental programs, including most of the examples in [19, 20, 21] It has also been of great help in studying transformations for caching intermediate results [20] and discovering auxiliary information [21] The rest of the paper is organized as follows. Section 2 gives an overview of the desired features, the problems to be solved, and the suggested solutions. Section 3 describes the implementation techniques used for CACHET. Section 4 contains a sample ....

[Article contains additional citation context not shown here]

Y. A. Liu and T. Teitelbaum. Caching intermediate results for program improvement. In Proc. of the ACM SIGPLAN Symp. on PEPM, pages 190--201, La Jolla, CA, Jun. 1995.

....optimization, modification, and reuse. There are also other programming activities that do not explicitly involve live or dead code but rely on similar notions, e.g. program slices [42, 36] Analysis for identifying live or dead code, or code of similar relevance, has been studied and used widely [9, 8, 22, 32, 3, 21, 18, 13, 23, 28, 27, 39, 36]. It is essentially backward dependence analysis that aims to compute minimal sufficient information needed for producing certain results. We call this dead code analysis, bearing in mind that it may be used for many other purposes. In recent years, dead code analysis has been made more precise ....

....sufficient information needed for producing certain results. We call this dead code analysis, bearing in mind that it may be used for many other purposes. In recent years, dead code analysis has been made more precise so that more dead code can be identified in more complicated computations [18, 13, 23, 27, 36, 6]. A particularly important problem is to identify dead computations on recursive data. Recursive data constructions are used increasingly widely in high level languages, and dead code analysis for them is important for various program manipulations [21, 18, 28, 27, 36] The goal is to identify ....

[Article contains additional citation context not shown here]

Y. A. Liu and T. Teitelbaum. Caching intermediate results for program improvement. In Proceedings of the ACM SIGPLAN Symposium on PEPM, pages 190--201, La Jolla, California, June 1995.

No context found.

Liu, Y. A. & Teitelbaum, T. (1995a). Caching intermediate results for program improvement, Proceedings of the ACM SIGPLAN Symposium on PEPM, La Jolla, California, pp. 190--201.

....ffl P2. Caching, maintaining, and exploiting intermediate results of the computation f(x) ffl P3. Discovering, computing, maintaining, and exploiting auxiliary information about x, i.e. information not computed by f(x) Our current approaches to problems P1 and P2 are described in [41] and [40], respectively. In this paper, we address issue P3 for the first time and contribute: ffl A novel proposal for finding auxiliary information. ffl A comprehensive methodology for deriving incremental programs that addresses all three subproblems. Some approaches to incremental computation have ....

....retrieved from the cached result r of f(x) The computation of f(x Phi y) is symbolically transformed to avoid reperforming these subcomputations by replacing them with corresponding retrievals. This efficient way of computing f(x Phi y) is captured in the definition of f 0 (x; y; r) P2. In [40], we gave a method, called cache and prune, for statically transforming programs to cache all intermediate results useful for incremental computation. The basic idea is to (I) extend the program f to a program f that returns all intermediate results, II) incrementalize the program f under ....

[Article contains additional citation context not shown here]

Y. A. Liu and T. Teitelbaum. Caching intermediate results for program improvement. In Proceedings of the ACM SIGPLAN Symposium on PEPM, pages 190--201, La Jolla, California, June 1995.

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC