H. Baker, Unify and conquer (garbage, updating, aliasing . . . ) in functional languages. In Conference on Lisp and Functional Programming, ACM Press, Nice, June 1990.  Home/Search   Document Not in Database   Summary   Related Articles   Check

....call by name is irrelevant, which may explain why the authors of these systems were willing to settle for a call by name analysis. 8. 4 Data structure update A number of analyses for in place update of data structures have been proposed, including those by Schmidt [Sch85] Hudak [Hud86] Baker [Bak90], Guzm an and Hudak [GH90] 33 Wadler [Wad90b, Wad91] and Barendsen and Smetsers [BS93] In such analyses it is sufficient to check that there can be at most one live pointer to a data structure. For example, in the following expression the then and else clauses can only be executed after ....

H. Baker, Unify and conquer (garbage, updating, aliasing . . . ) in functional languages. In Conference on Lisp and Functional Programming, ACM Press, Nice, June 1990.

....originate [40] This allows syntactic proofs of properties which previously required semantic techniques. An alternative to specifying alias information is to infer it using program analysis techniques. Relevant techniques are based on Hindley Milner type inference and polymorphic recursion [3, 35, 34, 33]. Information resulting from these techniques is used both for compiler optimisation and program understanding in software engineering tools. None of these methods consider the containment relationship between objects. The idea that types restrict the topology of an object graph is not new. For ....

....and compiler technology. Indeed Bokowski has used Co eeStrainer to implement an earlier unpublished version of ownership types [5] Alternatively, static inference techniques could be employed to minimize the burden on the programmer. Based on program understanding techniques developed by Baker [3], Jackson [35] and O Callahan [34, 33] and region inference [39] the static inference would rst partition a program into contexts. Additional work is required to determine the containment relationship between these contexts. We anticipate that annotating elds containing representation with a ....

Henry G. Baker. Unify and Conquer (Garbage, Updating, Aliasing, ...) in Functional Languages. In Proc.

....be soundly de allocated when all its values have gone out of use. To group values according to their life times, region inference uses the observation that values produced by two expressions e 1 and e 2 often have similar life times, if the types of the expressions are unified during type checking [Bak90]. This makes type inference an ideal vehicle for deciding the region annotations of expressions, as the grouping can be integrated into the type checking mecanism by adding places to types. In this way, places are required to match at applications just as types are. So in addition to the target ....

Henry G. Baker. "Unify and Conquer (Garbage, Updating, Aliasing, : : :) in Functional Languages", Proceedings of the 1990 ACM conference on Lisp and Functional Programming, Nice, France, June 27-29, 1990.

....Unreachable objects are part of them and are detected by conventional trace based garbage collections (GC) such as mark sweep and copying. However, there are still objects that are reachable yet semantically garbage. For example, consider the following functional program: let h = 1] [2]; 3] g = y: map hd y) in g h; length h end Just before the application (length h) is evaluated, the elements of the list h are reachable, yet they will never be accessed from then on. In order to enable a conventional GC to collect such semantic garbage, a program may have to be modified to ....

....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 ....

[Article contains additional citation context not shown here]

H. G. Baker. Unify and conquer (garbage, updating, aliasing, ...) in functional languages. In Proceedings of Conference on LISP and Functional Programming, pages 218--226, 1990.

.... their semantic modelling in general remains less settled [Abadi and Cardelli, 1996] A related discipline is that of compile time garbage collection, or type and data flow analyses to improve the run time performance of collection in (usually) functional languages [Appel, 1989a; Harrison, 1989; Baker, 1990; Goldberg and Gloger, 1992; Boehm and Shao, 1993; Fradet, 1994; Aditya et al. 1994; Mohnen, 1995] The primary idea is to eliminate the need for heap allocation in the first place, by proving that certain objects can be allocated on the stack instead, which is considered (although not ....

Henry G. Baker. Unify and conquer (garbage, updating, aliasing, : : : ) in functional languages. In LFP [1990], pages 218--226.

....objects semantic garbage at that point. These include not only unreachable objects with no pointers from the live part of the heap, but also some reachable objects whose values are not needed in the rest of the computation. For example, consider the following functional program: let l = 1] [2]; 3] g = f: f l) in g length end Suppose that a garbage collection (GC) is invoked just before the application (f l) is evaluated. Since the elements of the list l are reachable, these elements are retained by conventional trace based GC schemes, such as mark sweep and copying. However, ....

....Not all actual types for type variables can be recovered. Surprisingly, however, objects whose types are not recovered, i.e. remain to be type variables, can safely be collected. In the above example, the global state just before (f l) is evaluated can be represented as letrec l 1 = 1] l 2 = [2] l 3 = 3] l = l 1 ; l 2 ; l 3 ] f = length in f l where the bindings represent the heap, and the body expression represents the remaining computation, which is only the application of f to l. In other words, the body expression represents the stack. Let the pointers f and l in the stack be ....

[Article contains additional citation context not shown here]

H. G. Baker. Unify and conquer (garbage, updating, aliasing, ...) in functional languages. In Proceedings of Conference on LISP and Functional Programming, pages 218--226, 1990.

....at gc time. If the collector is unable to determine a type for any given variable or field, then that variable or field will not be accessed in the future, and can safely be ignored by the collector. Baker discussed the general idea of using Hindley Milner unification in this way a bit earlier [Baker, 1990]. A little later, Fradet [Fradet, 1994] extended this sort of collector to include a certain kind of liveness information, based on the intuitive idea that if a polymorphic function does not depend on a type parameter, then it could not actually use any data items of that type. A simple example of ....

Henry G. Baker. Unify and conquer (garbage, updating, aliasing, . . . ) in functional languages. In Conference Record of the 1990 ACM Symposium on Lisp and Functional Programming (Nice, France, June 1990), ACM Press, pp. 218--226.

....and call by name is irrelevant, which may explain why the authors of these systems were willing to settle for a call by name analysis. 8. 4 Data structure update A number of analyses for in place update of data structures have been proposed, including those by Schmidt [Sch85] Hudak [Hud86] Baker [Bak90], Guzm an and Hudak [GH90] Wadler [Wad90b, Wad91] and Barendsen and Smetsers [BS93] In such analyses it is sufficient to check that there can be at most one live pointer to a data structure. For example, in the following expression the then and else clauses can only be executed after the ....

H. Baker, Unify and conquer (garbage, updating, aliasing . . . ) in functional languages. In Conference on Lisp and Functional Programming, ACM Press, Nice, June 1990.

....program analyses. For instance, unification between first order terms, as used for type inference in the Hindley Milner type system of ML and Haskell, is also at the basis of several fast program analyses such as Steensgaard s aliasing analysis [37] and Henglein s tagging analysis [18] Baker [6] reflects informally on this connection between Hindley Milner type inference and several program analyses. Another technique that has attracted considerable interest recently both from a type inference standpoint and a program analysis standpoint consists in setting up systems of set inclusion ....

Henry G. Baker. Unify and conquer (garbage, updating, aliasing, . . . ) in functional languages. In Lisp and Functional Programming 1990. ACM Press, 1990.

....that tag free collection is possible for polymorphic languages, such as SML, by a combination of recording information statically and performing what amounts to type inference during the collection process, though the connections between inference and collection were not made clear. Baker [8] recognized that Milner style type inference can be used to prove that reachable objects can be safely collected, but did not give a formal account of this result. Goldberg and Gloger [26] recognized that it is not possible to reconstruct the concrete types of all reachable values in an ....

Henry Baker. Unify and conquer (garbage, updating, aliasing ...) in functional languages. In ACM Conference on Lisp and Functional Programming, pages 218--226, Nice, 1990.

....is de allocated. The letregion expression is the only way of introducing and eliminating regions. Hence regions are allocated and de allocated in a stack like manner. The device we use for grouping values according to regions is unification of region variables, using essentially the idea of Baker[3], namely that two valueproducing expressions e 1 and e 2 should be given the same at ae annotation, if and only if type checking, directly or indirectly, unifies the type of e 1 and e 2 . Baker does not prove safety, however, nor does he deal with polymorphism. To obtain good separation of ....

Henry G. Baker. Unify and conquer (garbage collection, updating, aliasing, ...) in functional languages. In Proceedings of the 1990 ACM Conference on Lisp and Functional Programming, pages 218--226, June 1990.

....not polymorphic) to the most recent, all type variables will be bound using unification. Example 1 Let us consider the following program and its evaluation using call by value. let rec append l 1 l 2 = case l 1 in nil : l 2 cons x xs : cons x (append xs l 2 ) in length (append [ 1] 2] 3] [4]] append : List a List a List a length : List a Int If the garbage collector is invoked at the beginning of the first call to cons the stack looks like Figure 1 The information associated with a return address includes the types of local variables and the actual types of the arguments of the ....

....a Int does not need the elements of the list for its execution . Contrary to tagless garbage collection, we do not attempt to completely reconstruct the types of acces We assume for now a language with no polymorphic comparison operators ; they are considered in section 3.3. 1] 2] 3] [4]] return address corresponding return address corresponding to the first recursive call to to the call append (append [ 1] 2] 3] 4] sible objects ; we rather try to minimally instantiate polymorphic types. A return address can be seen as a continuation of the form lx 1 . lx n .lr. E. ....

[Article contains additional citation context not shown here]

H.G. Baker. Unify and conquer (garbage, updating, aliasing, ...) in functional languages. In Proc. of the ACM Conf. on Lisp and Functional Programming, pp. 218-226, 1990.

....do prove a soundness result, albeit for a dynamic semantics, in which there are no regions and hence no notion allocation and deallocation of regions at runtime. The idea that unification of region variables during type inference performs a kind of value flow analysis is nicely presented by Baker[3]. Baker s location variables correspond to our region variables; Baker does not prove safety, however. Good separation of lifetimes hinges on the use of (a limited form) of polymorphic recursion. This approach to the separation of lifetimes is novel, as far as we know. The rest of this report is ....

Henry G. Baker. Unify and conquer (garbage collection, updating, aliasing, ...) in functional languages. In Proceedings of the 1990 ACM Conference on Lisp and Functional Programming, pages 218--226, June 1990.

....recursion polymorphically. Several program analyses based on uni cation and running in quasi linear time have been proposed as faster alternatives to more conventional dataAEow analyses. Two well known examples are Henglein s tagging analysis [10] and Steensgaard s aliasing analysis [26] Baker [1] suggests other examples of uni cation based analyses. 7 Conclusions and future work It is often said that uni cation based program analyses are faster, but less precise than more general constraint based analyses such as CFA or SBA. For exception analysis, our experience indicates that a ....

Henry G. Baker. Unify and conquer (garbage, updating, aliasing, . . . ) in functional languages. In Lisp and Functional Programming 1990. ACM Press, 1990.

....of syntactic constructs like blocks and abstractions, or syntactic program transformations like Tofte Talpin s, it is possible to determine statically (by abstract interpretation or otherwise) where dynamically allocated cells can be deallocated. This is known as compile time garbage collection [4, 8, 46, 52, 53]. The compiler can generate appropriate code that will call the garbage collector only at these particular program points. The intuition is that this should give better performance than in cases where the run time system has to call the garbage collector, periodically suspending program ....

Baker, H. Unify and conquer (garbage, updating, aliasing, ...) in functional languages. In Proceedings of the 1990 ACM Conference on Lisp and Functional Programming (Nice, France, June 1990), pp. 218--226.

....analysis for the ML Kit compiler based on (potentially polymorphic) region annotations (Tofte and Talpin, 1997) functions allocated to the same region are placed in the same closure analysis equivalence class. Our tag unification method closely resembles region inference for monomorphic programs (Baker, 1990; Tofte and Talpin, 1997) although we developed it independently; nothing in our scheme corresponds to the ML Kit s polymorphic region inference, however. An important point about our framework is that the result of an automated analysis like this can be expressed directly in SIL, and used as the ....

Baker, H. G. (1990). Unify and conquer (garbage collection, updating, aliasing, : : :) in functional languages. In Proc. 1990 ACM Conference on Lisp and Functional Programming, pages 218--226.

.... compiler optimizations related to heap allocated structures, both to detect potential aliasing and to allow heap objects to be stack allocated when it is possible to infer that they become garbage at a particular point in a program [Sch75a, Sch75b, Hud86, JM81, RM88, LH88, HPR89, CWZ90, Bak90] Cha87] discusses interactions between conventional optimizations and garbage collection, and when garbage collection oriented optimizations are safe. These topics are beyond the scope of this survey, and to the best of our knowledge no actual systems use these techniques for garbage collection ....

Henry G. Baker, Jr. Unify and conquer: (garbage, updating, aliasing : : : ) in functional languages. In Conference Record of the 1990 ACM Symposium on LISP and Functional Programming [LFP90], pages 218--226.

....a closure analysis for the ML Kit compiler [25] based on (potentially polymorphic) region annotations [50] functions allocated to the same region are placed in the same closure analysis equivalence class. Our tag unification method closely resembles region inference for monomorphic programs [4, 50], although we developed it independently; nothing in our scheme corresponds to the ML Kit s polymorphic region inference, however. An important point about our framework is that the result of an automated analysis like this can be expressed directly in SIL, and used as the basis of a ....

H. G. Baker. Unify and conquer (garbage collection, updating, aliasing, : : :) in functional languages. In Proc. 1990 ACM Conference on Lisp and Functional Programming, pages 218-- 226, June 1990.

....call by name is irrelevant, which may explain why the authors of these systems were willing to settle for a call by name analysis. 7. 4 Data structure update A number of analyses for in place update of data structures have been proposed, including those by Schmidt [Sch85] Hudak [Hud86] Baker [Bak90], Guzm an and Hudak [GH90] Wadler [Wad90b, Wad91] and Barendsen and Smetsers [BS93] In such analyses it is sufficient to check that there can be at most one live pointer to a data structure. For example, in the following expression the then and else clauses can only be executed after the ....

H. Baker, Unify and conquer (garbage, updating, aliasing : : : ) in functional languages. In Conference on Lisp and Functional Programming, ACM Press, Nice, June 1990.

....in the latter domain it is limited to tree like structures only. 2.5 Other Work There has been substantial work done on program analysis in regards to dynamic allocation. Such analysis is useful in many related problems, e.g. reference counting and memory lifetimes [Hud86, ISY88, RM88, Har89, Bak90, WH92] as well as memory placement [Har89, HA93] In particular, Harrison [Har89] performs extensive analysis of dynamically allocated memory; this work has been extended in [HA93] From this analysis it is possible to discover various properties of a data structure (e.g. its treeness) and thus ....

H. Baker. Unify and conquer (garbage, updating, aliasing, ...) in functional languages. In Pro227 ceedings of the '90 ACM Conference on LISP and Functional Programming, June 1990.

No context found.

Baker, Henry G. "Unify and Conquer (Garbage, Updating, Aliasing, ...) in Functional Languages". Proc. 1990 ACM Conf. on Lisp and Functional Progr., June 1990, 218-226.

No context found.

Baker, Henry. "Unify and Conquer (Garbage, Updating, Aliasing ...) in Functional Languages". Proc. 1990 ACM Conf. on Lisp and Functional Programming, Nice, France, June, 1990,218-226.

No context found.

Baker, Henry. "Unify and Conquer (Garbage, Updating, Aliasing ...) in Functional Languages". Proc. 1990 ACM Conf. on Lisp and Functional Programming, Nice, France, June, 1990,218-226.

No context found.

Baker90b: Baker, Henry. "Unify and Conquer (Garbage, Updating, Aliasing...) in Functional Languages". Proc. 1990 ACM Conference on Lisp and Functional Programming, June 1990.

No context found.

H. G. Baker. Unify and conquer (garbage collection, updating, aliasing, ...) in functional languages. In Proceedings of the 1990 ACM Conference on Lisp and Functional Programming, pages 218--226, June 1990.

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