Escape analysis [27, 14, 5] is a static analysis that determines whether the lifetime of data exceeds its static scope. The main originality of our escape analysis is that it determines precisely the effect of assignments, which is necessary to apply it to object oriented languages with promising results, whereas previous work [27, 14, 5] applied it to functional languages and were very imprecise on assignments. Our implementation analyses the full Java TM Language. We have applied our analysis to stack allocation and synchronization elimination. We manage to stack allocate 13% to 95% of data, eliminate more than 20% of synchronizations on most programs (94% and 99% on two examples) and get up to 44% speedup (21% on average). Our detailed experimental study on large programs shows that the improvement comes more from the decrease of the garbage collection and allocation times than from improvements on data locality [7], contrary to what happened for ML [5].

values can either be object names N 2 OName for objects and arrays, or ; for variables of simple types such as integers.

Abstract. Tuplespace provides parallel programmers with an abstraction that hides the speci c underlying architecture, allowing the architecture to be any number of platforms ranging from shared or distributed memory to a cluster of workstations. Unfortunately, any abstraction of this kind necessarily introduces a trade-o for the application programmer between ease-of-use and control over performance. This paper presents adata ow analysis framework which plays a key role in identifying opportunities for communication optimization in tuplespace parallel programs. The enabled optimizations are particularly important for implementations on distributed memory multiprocessors and cluster environments where tuplespace acts as a structured distributed shared memory abstraction and communication overhead is high. 1

Static memory management replaces runtime garbage collection with compile-time annotations that make all memory allocation and deallocation explicit in a program. We improve upon the Tofte/Talpin region-based scheme for compile-time memory management [TT94]. In the Tofte/Talpin approach, all values, including closures, are stored in regions. Region lifetimes coincide with lexical scope, thus forming a runtime stack of regions and eliminating the need for garbage collection. We relax the requirement that region lifetimes be lexical. Rather, regions are allocated late and deallocated as early as possible by explicit memory operations. The placement of allocation and deallocation annotations is determined by solving a system of constraints that expresses all possible annotations. Experiments show that our approach reduces memory requirements significantly, in some cases asymptotically.