K. Inoue H. Seki and H. Yagi. Analysis of functional programs to detect run-time garbage cells. TOPLAS, 10(4):555---578, October 1988.  Home/Search   Document Not in Database   Summary   Related Articles   Check

....may be employed by production compilers. All further information related to the JET project may be found at [18] 5 Related Works An number of approaches have been proposed for object lifetime analysis. Many works were dedicated to functional languages such as SML, Lisp etc. 14] 15] [16]) The power of the escape analyses supercedes ours to a great extent, however the complexity of the algorithms is not better than polynomial. The escape analysis for Java was investigated by reseachers using static Java analyzing frameworks. Except the JET compiler, the related works were ....

K. Inoue et al.: Analysis of functional programs to detect run-time garbage cells. ACM Transactions on Programming Languages and Systems, 10(4), 1988

....for JavaCard. Both of these algorithms handle heap references and destructive updates. They employ both forward (history) and backward (future) information on the behavior of the program. This allows us to free more objects than reachability based compile time garbage collection mechanisms (e.g. [17]) which only consider the history. 1.3 A Motivating Example Fig. 1 shows a program that creates a singly linked list and then traverses it. We would like to verify that for this program a free y statement can be added immediately after line 10. This is possible because once a list element is ....

....statement can be added immediately after line 10. This is possible because once a list element is traversed, it cannot be accessed along any execution path starting after line 10. It is interesting to note that even in this simple example, standard compile time garbage collection techniques (e.g. [17]) will not issue such a free statement, since the element referenced by y is reachable via a heap path starting from x. Furthermore, integrating limited information on the future of the computation such as liveness of local reference variables (e.g. 1] is insufficient for issuing such free ....

[Article contains additional citation context not shown here]

K. Inoue, H. Seki, and H. Yagi. Analysis of functional programs to detect run-time garbage cells. Trans. on Prog. Lang. and Syst., 10(4):555--578, Oct. 1988.

.... see [14, 13, 46, 51] register allocation (with the help of liveliness analysis and pointer or alias analysis, see [3, 17, 64, 30] stack allocation to replace heap allocation (see [24, 52] selection of efficient representation for the values (see [31, 32, 53] recycling of heap objects (see [34, 35]) elimination of dead code (see [3, 39] static branch prediction (using numerical analysis, though, see [47] etc. 7.3.4 Demand Propagation Calculus We merely make an allusion to this subject as it is no more than a vague idea by ours. A demand driven type analysis could be based on a pure ....

Katsuro Inoue, Hiroyuki Seki, and Hikaru Yagi. Analysis of functional programs to detect run- time garbage cells. A CM Transactions on Programming Languages and Systems, 10(4):555-578, oct 1988. BIBLIOGRAPHY xvi

....notion denotationally, we need the ability to distinguish between original (the argument) and copy (the result) However, this difference cannot be expressed by the standard denotational semantics. The knowledge of the escape behaviour allows techniques like compile time garbage collection [ISY88,Hug92,Moh95]. To remedy this problem, the analysis could be proven to be correct in an operational setting, e.g. data flow graphs or abstract machines. But this is not attractive for denotational style semantics abstract interpretation. Moreover, this often destroys the separation between analysis on one ....

K. Inoue, H. Seki, and H. Yagi. Analysis of Functional Programs to Detect Run-Time Garbage Cells. TOPLAS, 10(4):555--578, October 1988.

....on the runtime stack using a very simple analysis algorithm. The increase in stack size is relatively small. 6 Related Work Escape analysis and stack allocation or compile time garbage collection based on same have been performed on functional languages like SML or Lisp [Bla98, Deu97, Hug92, ISY88, Moh95, PG92] and recently for Java [CGS 99, Bla99, 3 Performance numbers for a larger and partially overlapping set of benchmarks are presented in [FKR 99] Table 2. objects allocated on the stack Name Code Stack Allocated Stack allocated Reduced increase increase objs bytes ....

Katsuro Inoue, Hiroyuki Seki, and Hikaru Yagi. Analysis of functional programs to detect run-time garbage cells. ACM Transactions on Programming Languages and Systems, 10(4):555--578, October 1988.

....analysis uses a reference counting method similar to that in run time garbage collection. While the former keeps track of pointers to memory cells that will be used later in the execution, the latter maintains pointers reachable from the stack at the current point in execution. Inoue and others [12] analyze functional programs to detect run time garbage conservatively at compiletime. Their result is an approximation without any information about the input. Also, they do not compute the size of live space. Several type systems [11, 10, 4] have been proposed for reasoning about space and time ....

K. Inoue, H. Seki, and H. Yagi. Analysis of functional programs to detect run-time garbage cells. ACM Trans. Program. Lang. Syst., 10(4):555-578, Oct. 1988.

....live heap space, since a cell not to be used in the future may still be pointed to from the stack and thus would not yet be garbage collected by standard run time garbage collectors. Thus, we had to develop a di erent reference counting method for the live space analysis. Inoue and others [26] analyze functional programs to detect run time garbage, by nding run time garbage conservatively at compile time. Their result is an approximation without any information about the input. Also, they do not compute the size of live space. Our analysis combines static program analysis techniques ....

K. Inoue, H. Seki, and H. Yagi. Analysis of functional programs to detect run-time garbage cells. ACM Trans. Program. Lang. Syst., 10(4):555-578, Oct. 1988.

....lifetime can be bounded by the lifetime of a stack frame on a thread s runtime call stack, may be allocated in the call stack instead of on the heap. There are several recent implementations of this strategy in runtime systems for Java [2, 5, 9, 21] and various functional programming languages [3, 7, 12, 13, 14, 16, 18]. Marmot uses the stack allocation transformation described in [9] so objects allocated in thread speci c heap sections are not trivially stack allocatable. The language report for FX91 [10] brie y mentions an extension of FX91 that uses type annotations to indicate a storage region in which ....

K. Inoue, H. Seki, and H. Yagi. Analysis of functional programs to detect run-time garbage cells. ### ###### ##### ##### #####, 10(4):555-578, Oct. 1988.

....and backward analysis, for detecting sharing of objects in first order functional languages, and describe a method for reusing of cells based on the sharing analysis. We use only forward analysis providing, perhaps, a simpler conceptual framework for higher order languages. Inoue, Seki, and Yagi [12] describe an analysis for functional languages to detect, and reclaim, run time garbage cells based on the formal language theory and grammars. The paper focuses only on the explicit reclamation of cons cells and it is unclear that this approach could be extended for higher order languages. ....

K. Inoue, H. Seki, and H. Yagi. Analysis of functional programs to detect run-time garbage cells. ACM Transactions on Programming Languages, 10(4):555-578, October 1988.

....by theirs. In [12] they gave an argument on type inference GC. However, they specified conditions of a heap that a GC should find, but did not give an algorithm. Neither [4] nor [12] has dealt with polymorphism. Many techniques have been proposed to statically estimate life times of objects [2, 8, 6, 15, 3]. Techniques using sharing analysis [2, 8, 6] cannot collect more garbage than type inference GCs can since they use reachability based liveness of objects. Techniques using region inference [15, 3] can collect some semantic garbage. Since we have not studied to the extent to make a precise ....

....inference GC. However, they specified conditions of a heap that a GC should find, but did not give an algorithm. Neither [4] nor [12] has dealt with polymorphism. Many techniques have been proposed to statically estimate life times of objects [2, 8, 6, 15, 3] Techniques using sharing analysis [2, 8, 6] cannot collect more garbage than type inference GCs can since they use reachability based liveness of objects. Techniques using region inference [15, 3] can collect some semantic garbage. Since we have not studied to the extent to make a precise comparison between their scheme and our scheme, we ....

K. Inoue, H. Seki, and H. Yagi. Analysis of functional programs to detect run-time garbage cells. ACM Transactions on Programming, Languages and Systems, 10(4):555--579, 1988.

....to be unreachable (compile time garbage collection) The two major approaches are escape analysis and region inference. Stack allocation and compile time garbage collection based on escape analysis have mostly been performed on functional languages like SML [MTH90] or Lisp [Bla98, Deu97, Hug92, ISY88, Moh95, PG92] The precision of the escape analyses considered in these papers is much greater than ours. For instance, they can find that a function s result does not contain elements from the spine of its second argument (a list) This extra precision appears to be necessary for e#ective stack ....

Katsuro Inoue, Hiroyuki Seki, and Hikaru Yagi. Analysis of functional programs to detect runtime garbage cells. ACM Transactions on Programming Languages and Systems, 10(4):555--578, October 1988.

....heap space, since a cell not to be used in the future may still be pointed to from the stack and thus would not yet be garbage collected 25 of 28 by standard run time garbage collectors. Thus, we had to develop a different reference counting method for the live space analysis. Inoue and others [26] analyze functional programs to detect run time garbage, by finding run time garbage conservatively at compile time. Their result is an approximation without any information about the input. Also, they do not compute the size of live space. Our analysis combines static program analysis techniques ....

K. Inoue, H. Seki, and H. Yagi. Analysis of functional programs to detect run-time garbage cells. ACM Trans. Program. Lang. Syst., 10(4):555--578, Oct. 1988.

....order and does not handle imperative operations. Hughes [20] already introduces integer levels to represent the escaping part of data. He does not perform stack allocation, but keeps in memory the addresses of data to be deallocated in order to avoid using the GC. The work closest to Hughes is [21] by Inoue, Seki and 1 Yagi, who only free the top of lists, but give experimental results. McDowell [24] gives experimental evidence that there are many opportunities for stack allocation in Java programs, and suggests it would be interesting, but does not actually allocate data on the stack. ....

Inoue, K., Seki, H., and Yagi, H. Analysis of Functional Programs to Detect Run-Time Garbage Cells. ACM Transactions on Programming Languages and Systems 10, 4 (Oct. 1988), 555 -- 578.

....order and does not contain imperative operations. Hughes [24] already introduces integer levels to represent the escaping part of data. He does not perform stack allocation, but keeps in memory addresses of data to be deallocated in order to avoid using the GC. The work closest to Hughes is [25] by Inoue, Seki and Yagi, who only free the top of lists, but give experimental results. Alias analysis [13] reference counting [22, 19] storage use analysis [34] which is similar to [26, 18, 12, 35] can be applied to stack allocation though at a much higher cost. Another allocation ....

Inoue, K., Seki, H., and Yagi, H. Analysis of Functional Programs to Detect Run-Time Garbage Cells. ACM Transactions on Programming Languages and Systems 10, 4 (Oct. 1988), 555 -- 578.

....they can be reclaimed into a free storage list explicitly by the program without invoking a garbage collection process. When heap allocated objects are no longer needed, their storage can be reused directly in the allocation of new objects without invoking garbage collection. 11] 35] 41] [49], 50] 51] ffl Reference Counting Elimination : In reference counting, each object contains a count, called the reference count, of the number of references (pointers) pointing to it. Each time a reference is created or destroyed its reference count needs to be incremented or decremented. It ....

....and other structures. Most of these analyses have been first order (i.e. not accounting for higher order functions. Ruggieri and Murtagh ( 71] 72] described a lifetime analysis for a language with side effects and complex data structures, but, again, it is first order. Inoue, Seki, and Yagi [49] described an analysis for functional languages to detect, and reclaim run time garbage cells based on formal language theory and grammars. They focused only on the explicit reclamation of cons cells. It is unclear if this approach could be extended for higher order languages. Besides being ....

K. Inoue, H. Seki and H. Yagi. Analysis of functional programs to detect run-time garbage cells. ACM Transaction on Programming Languages and Systems, 10(4):555578, 1988.

....to the memory manager. The language on which the described optimisations are performed is a simple first order lazy functional language with list operators and recursion equations. A lot of work has already been done to show how compile time garbage collection can be performed for strict languages [ 17, 10, 14, 12, 7, 9 ] , but not so much has been done for lazy languages. A first order language was chosen to simplify the presentation, but the same methods can be applied to higher order languages. In order to show that the store related optimisations presented in this paper are correct, a reference must be ....

....have been used. No store semantics are defined for programs which have been annotated in this way, and the correctness of programs which have been annotated in this way is not considered. 6. 2 Explicit Deallocation The methods for validating explicit deallocation in a strict language described in [ 10 ] and [ 9 ] both make use of information obtained by an inheritance analysis and a generation analysis. The inheritance analysis is used to determine which cells will appear directly in the result of a function, and the generation analysis is used to determine which cells are created within a ....

[Article contains additional citation context not shown here]

K. Inoue, H. Seki, and H. Yagi. Analysis of functional programs to detect run-time garbage cells. ACM Transactions on Programming Languages and Systems, 10(4):555--578, October 1988.

....that it can be implemented in reasonably low cost. Therefore there would be trade off between memory saving and speed, possibly depending on applications. This should be investigated through experiments in the future. Many techniques have been proposed to statically estimate life times of objects [2, 8, 6, 15, 3]. Techniques using sharing analysis [2, 8, 6] cannot collect more garbage than type inference GCs can since they use reachability based liveness of objects. Techniques using region inference [15, 3] can collect some semantic garbage. Since we have not studied to the extent to make a precise ....

....Therefore there would be trade off between memory saving and speed, possibly depending on applications. This should be investigated through experiments in the future. Many techniques have been proposed to statically estimate life times of objects [2, 8, 6, 15, 3] Techniques using sharing analysis [2, 8, 6] cannot collect more garbage than type inference GCs can since they use reachability based liveness of objects. Techniques using region inference [15, 3] can collect some semantic garbage. Since we have not studied to the extent to make a precise comparison between their scheme and our scheme, we ....

K. Inoue, H. Seki, and H. Yagi. Analysis of functional programs to detect runtime garbage cells. ACM Transactions on Programming, Languages and Systems, 10(4):555--579, 1988.

....defined in terms of the tree fields and the underlying spanning tree. Thus, graph types can only describe data structures with a spanning tree backbone. A large body of work on analysis of heap allocated objects, has focused on other problems like reference counting and memory lifetimes [Hud86, ISY88, RM88, Deu90, WH92] 1.4 Our Approach Our overall goal was to design and implement a sophisticated pointer analysis framework for the McCAT C compiler. We followed the approach of decoupling stack and heap analyses, instead of solving the two problems using the same abstraction. As already ....

K. Inoue, H. Seki, and H. Yagi. Analysis of functional programs to detect run-time garbage cells. ACM TOPLAS, 10(4):555--578, October 1988.

....structures the reduced approach is not applicable at all. Park and Goldberg [PG92] describe a similar approach, which they call escape analysis, indicating whether (parts of) the arguments can escape from the function call. A combination of sharing analysis and inheritance analysis is used in [SY88], again for list structures only. The underlying analyses use context free grammars. In [JM89] a different approach is taken: list constructors which are not shared are collected as soon as they are dereferenced, i.e. as soon as they match a constructor on the left hand side of a function ....

K. Inoue H. Seki and H. Yagi. Analysis of functional programs to detect run-time garbage cells. TOPLAS, 10(4):555---578, October 1988.

.... There also exist garbage collectors, adapted to non deterministic languages, which detect and collect the useless binding values of useful logic variables [5] Compile time garbage collection is a static analysis which detects points in the program where part of the store can be collected [17][19] This information can then be used to reallocate old store. It reduces store use and therefore reduces garbage collection overhead. In the best cases those analyses detect what a traditional GC would detect at run time. We see this approach and ours as complementary. The most common ....

K. Inoue, H. Seki and H. Yagi. Analysis of functional programs to detect run-time garbage cells. ACM Trans. on Prog. Lang. and Sys., 10(4), pp. 555-578,1988.

....of the program. This may be regarded as a benefit or as a drawback. Related are also the work done by Raoult and Sethi [17] who have studied single threading using a pebble game on a program tree. Let us also mention studies aiming at reducing storage allocations for dynamic data structures [10,12] by doing a sharing analysis on strict, first order, languages. 6.2 Future work We did not consider product types in this paper. There are several ways to extend this work to deal with such constructs. One straightforward solution is to treat tuples the same way as closures but other approaches ....

K. Inoue, H. Seki and H. Yagi. Analysis of functional programs to detect run-time garbage cells. ACM Trans. on Prog. Lang. and Sys., 10(4), 1988, 555-578.

....defined in terms of the tree fields and the underlying spanning tree. Thus, graph types can only describe data structures with a spanning tree backbone. A large body of work on analysis of heap allocated objects, has focused on other problems like reference counting and memory lifetimes [Hud86, ISY88, RM88, Deu90, WH92] 1.3 Pointer Analysis in the McCAT C Compiler All the techniques we have discussed so far, either focus on stack analysis with a conservative approximation of the heap, or present sophisticated heap analyses considered in isolation from stack analysis (assuming stack directed ....

K. Inoue, H. Seki, and H. Yagi. Analysis of functional programs to detect run-time garbage cells. ACM TOPLAS, 10(4):555--578, October 1988.

No context found.

K. Inoue H. Seki and H. Yagi. Analysis of functional programs to detect run-time garbage cells. TOPLAS, 10(4):555---578, October 1988.

No context found.

K. Inoue, H. Seki, and H. Yagi. Analysis of Functional Programs to Detect RunTime Garbage Cells. TOPLAS, 10(4):555578, October 1988.

No context found.

Katsuro Inoue, Hiroyuki Seki, and Hikaru Yagi. Analysis of functional programs to detect run-time garbage cells. ACM Transactions on Programming Languages and Systems, 10(4):555--578, October 1988. 40

First 50 documents

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