Abstract not found

Abstract—Accurately predicting object lifetimes is important for improving memory management systems. Current garbage collectors make relatively coarse-grained predictions (e.g., “short-lived ” versus “long-lived”) and rely on application-independent heuristics related to the local characteristics of an allocation. This paper introduces a prediction method which is fully precise and makes its predictions based on application-specific training rather than application-independent heuristics. By “fully precise ” we mean that the granularity of predictions is equal to the smallest unit of allocation. The method described here is the first to combine high precision and efficiency in a single lifetime predictor. Fully precise prediction enables us, for the first time, to study zero-lifetime objects. The paper reports results showing that zero-lifetime objects comprise a significant fraction of object allocations in benchmark programs for the Java programming language and that they are correlated with their allocation context (the call stack and allocation site). Beyond zerolifetime objects, the paper reports results on predicting longer lived objects, where, in some cases, it is possible to predict the lifetime of objects based on their allocation context (the call stack and allocation site) well. For the SPEC benchmark programs, the number of dynamically allocated objects whose call sites have accurate predictors ranges from 0.2 percent to 61 percent. This method could potentially improve the performance of garbage collectors. The paper proposes a death-ordered collector (DOC) and analyzes its implementation overheads and its best possible performance. The study shows how memory performance could be enhanced using the extra information provided by fully precise prediction. Index Terms—Object lifetimes, workload characterization, pretenuring, object-oriented programming languages, garbage collection, program behavior. 1

A corpus of 291 small C-program test cases was developed to evaluate static and dynamic analysis tools designed to detect buffer overflows. The corpus was designed and labeled using a new, comprehensive buffer overflow taxonomy. It provides a benchmark to measure detection, false alarm, and confusion rates of tools, and also suggests areas for tool enhancement. Experiments with five tools demonstrate that some modern static analysis tools can accurately detect overflows in simple test cases but that others have serious limitations. For example, PolySpace demonstrated a superior detection rate, missing only one detection. Its performance could be enhanced if extremely long run times were reduced, and false alarms were eliminated for some C library functions. ARCHER performed well with no false alarms whatsoever. It could be enhanced by improving interprocedural analysis and handling of C library functions. Splint detected significantly fewer overflows and exhibited the highest false alarm rate. Improvements in loop handling and reductions in false alarm rate would make it a much more useful tool. UNO had no false alarms, but missed overflows in roughly half of all test cases. It would need improvement in many areas to become a useful tool. BOON provided the worst performance. It did not detect overflows well in string functions, even though this was a design goal.

analysis algorithm for Java programs with unstructured multithreading. The algorithm is based on the abstraction of parallel interaction graphs, whichcharacterize the points-to and escape relationships between objects and the ordering relationships between actions performed by multiple parallel threads. To our knowledge, this algorithm is the first interprocedural, flow-sensitive pointer analysis algorithm capable of extracting the points-to relationships generated by the interactions between unstructured parallel threads. It is also the first algorithm capable of analyzing interactions between threads to extract precise escape information even for objects accessible to multiple threads.

Escape analysis of object-oriented languages allows us to stack allocate dynamically created objects and to reduce the overhead of synchronisation in Java-like languages. We formalise the escape property E , computed by an escape analysis, as an abstract interpretation of concrete states. We de ne the optimal abstract operations induced by E for a framework of analysis known as watchpoint semantics. The implementation of E inside that framework is a formally correct abstract semantics (analyser) for escape analysis. We claim that E is the basis for more re ned and precise domains for escape analysis.

Abstract. We describe an analysis-driven storage allocation scheme for concurrent languages that use message passing with copying semantics. The basic principle is that in such a language, data which is not part of any message does not need to be allocated in a shared data area. This allows for deallocation of threadspecific data without requiring global synchronization and often without even triggering garbage collection. On the other hand, data that is part of a message should preferably be allocated on a shared area, which allows for fast (O(1)) interprocess communication that does not require actual copying. In the context of a dynamically typed, higher-order, concurrent functional language, we present a static message analysis which guides the allocation. As shown by our performance evaluation, conducted using an industrial-strength language implementation, the analysis is effective enough to discover most data which is to be used as a message, and to allow the allocation scheme to combine the best performance characteristics of both a process-centric and a shared-heap memory architecture. 1

Escape analysis of object-oriented languages determines, for every program point, the escape property E i.e., the set of the creation points of the objects reachable from some variables. An approximation of E is useful to stack allocate dynamically created objects and to reduce the overhead of synchronisation in Java-like languages. E can itself be used for escape analysis, but it is very imprecise. We de ne here a re nement ER of E , in the sense that ER is more concrete than E and, hence, leads to a more precise escape analysis than E .

We describe an analysis-driven storage allocation scheme for concurrent systems that use message passing with copying semantics. The basic principle is that in such a system, data which is not part of any message does not need to be allocated in a shared data area. This allows for deallocation of thread-specific data without requiring global synchronization and often without even triggering garbage collection. On the other hand, data that is part of a message should preferably be allocated on a shared area, which allows for fast (O(1)) interprocess communication that does not require actual copying. In the context of a dynamically typed, higher-order, concurrent functional language, we present a static message analysis which guides the allocation. As shown by our performance evaluation, conducted using an industrial-strength language implementation, the analysis is effective enough to discover most data which is to be used as a message, and to allow the allocation scheme to combine the best performance characteristics of both a process-centric and a communal memory architecture.

As real-time and embedded systems become increasingly large and complex, the traditional strictly static approach to memory management begins to prove untenable. The challenge is to provide a dynamic memory model that guarantees tight and bounded time and space requirements without overburdening the developer with memory concerns. This paper provides an analysis of memory management approaches in order to characterise the tradeoffs across three semantic domains: space, time and a characterisation of memory usage information such as the lifetime of objects. A unified approach to distinguishing the merits of each memory model highlights the relationship across these three domains, thereby identifying the class of applications that benefit from targeting a particular model. Crucially, an initial investigation of this relationship identifies the direction future research must take in order to address the requirements of the next generation of complex embedded systems. Some initial suggestions are made in this regard and the memory model proposed in the Real-Time Specification for Java is evaluated in this context. 1

Abstract. Escape analysis facilitates better optimization of programs in object-oriented programming languages such as Java, significantly reducing memory management and synchronization overhead. Unfortunately, existing escape analysis algorithms are often too expensive to be applicable in just-in-time compilation contexts. We propose to perform the analysis ahead of time and ship its results as code annotations. We present an interprocedural, flow insensitive, static escape analysis that is less precise than traditional escape analyses, but whose result can be transported and verified efficiently. Unlike any other escape analysis that we know of, our method optionally provides for dynamic class loading, which is necessary for full Java compatibility. Benchmarks indicate that, when compared to Whaley and Rinard’s elaborate escape analysis, our simple analysis can pinpoint 81 % of all captured allocation sites (69 % when dynamic loading is supported), with negligible space overhead for the transport of annotations and negligible time overhead for the verification. 1