Efficient compilation strategy for object‐oriented languages under the closed‐world assumption

Sonntag, Benoît; Colnet, Dominique

doi:10.1002/spe.2174

Cited by 4 publications

(5 citation statements)

References 56 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…There are four reasonable assumptions. The first one is commonly made on static analysis [Sonntag and Colnet 2014] and the next two are made previously on reflection analysis for Java ]. SOLAR adds one more assumption to allow re-flective allocation sites to be modeled lazily.…”

Section: Assumptionsmentioning

confidence: 99%

Understanding and Analyzing Java Reflection

Tan

Xue

2019

ACM Trans. Softw. Eng. Methodol.

View full text Add to dashboard Cite

Java reflection has been increasingly used in a wide range of software. It allows a software system to inspect and/or modify the behaviour of its classes, interfaces, methods and fields at runtime, enabling the software to adapt to dynamically changing runtime environments. However, this dynamic language feature imposes significant challenges to static analysis, because the behaviour of reflection-rich software is logically complex and statically hard to predict, especially when manipulated frequently by statically unknown string values. As a result, existing static analysis tools either ignore reflection or handle it partially, resulting in missed, important behaviours, i.e., unsound results. Therefore, improving or even achieving soundness in (static) reflection analysis-an analysis that infers statically the behaviour of reflective code-will provide significant benefits to many analysis clients, such as bug detectors, security analyzers and program verifiers.This paper makes two contributions: we provide a comprehensive understanding of Java reflection through examining its underlying concept, API and real-world usage, and, building on this, we introduce a new static approach to resolving Java reflection effectively in practice. We have implemented our reflection analysis in an open-source tool, called SOLAR, and evaluated its effectiveness extensively with large Java programs and libraries. Our experimental results demonstrate that SOLAR is able to (1) resolve reflection more soundly than the state-of-the-art reflection analysis; (2) automatically and accurately identify the parts of the program where reflection is resolved unsoundly or imprecisely; and (3) guide users to iteratively refine the analysis results by using lightweight annotations until their specific requirements are satisfied.

show abstract

Section: Assumptionsmentioning

confidence: 99%

Understanding and Analyzing Java Reflection

Tan

Xue

2019

ACM Trans. Softw. Eng. Methodol.

View full text Add to dashboard Cite

show abstract

“…Prediction of the NULL values makes it possible to detect statically that some calls will fail at runtime. Many research papers have been published regarding type analysis or NULL prediction: . Previous research papers address type analysis for the self or this variable, instance variables, formal parameters, local and global variables.…”

Section: Setting Up With Simple Flexible Arraysmentioning

confidence: 99%

“…The results presented here come from the work done in the SmartEiffel project [2,3] but also in the Lisaac project [4,5]. SmartEiffel consists of a compiler for the Eiffel language as well as a class library including all the kinds of arrays described in this article.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Exploiting array manipulation habits to optimize garbage collection and type flow analysis

Colnet

Sonntag

2014

Softw Pract Exp

Self Cite

View full text Add to dashboard Cite

A widespread practice to implement a flexible array is to consider the storage area into two parts: the used area, which is already available for read/write operations, and the supply area, which is used in case of enlargement of the array. The main purpose of the supply area is to avoid as much as possible the reallocation of the whole storage area in case of enlargement. As the supply area is not used by the application, the main idea of the paper is to convey the information to the garbage collector, making it possible to avoid completely the marking of the supply area. We also present a simple method to analyze the types of objects, which are stored in an array as well as the possible presence of NULL values within the array. This allows us to better specialize the work of the garbage collector when marking the used area, and also, by transitivity, to improve overall results for type analysis of all expressions of the source code. After introducing several abstract data types, which represent the main arrays concerned by our technique (i.e., zero or variable indexing, circular arrays and hash maps), we measure its impact during the bootstrap of two compilers whose libraries are equipped with these abstract data types. We then measure, on various software products we have not written, the frequency of certain habits of manipulation of arrays, to assess the validity of our approach. Copyright EXPLOITING ARRAY MANIPULATION HABITS 1641 Create(cap) The creation operation to be used in order to prepare a new empty array with a given capacity cap: assert (cap >= 0); capacity = cap; size = 0; storage = malloc(cap); Extend(obj) To extend by one the array on its right, writing obj in the new slot. In case of reallocation (i.e. when the supply area is empty), the capacity is increased twofold:if ( size >= capacity ) { capacity = capacity * 2; storage = realloc(storage, capacity); } storage[size] = obj; size = size + 1; Read(ind)This function returns the object stored at index ind assuming that the index is correct, that is, a valid index in the used area:Write(ind, obj) Change the value at index ind using obj for the replacement, assuming that the ind is a valid index in the used area: assert ((0 <= ind) && (ind < size)); storage[ind] = obj; order of statements. For instance, using all the reachable assignments in a variable, we compute all the possible types for that variable. The analysis is flow insensitive, that is, the order of reachable assignments does not matter. We consider on the whole the set of reachable assignments.Concerning instance variables, we do not discriminate between the different instances from the same class (Figure 2); the type information is identical for all instances of a given class. For a formal method argument, we use the set of reachable effective arguments, that is, all reachable calls. Classically, to obtain the set of dynamic types of a given method call, we consider all the methods EXPLOITING ARRAY MANIPULATION HABITS 1645 Note that it is not necessary to reset with NULL the cell that...

show abstract

“…The algorithms must be adapted to the new environment, or new directions must be taken (like the balanced approach by IBM). GC continues to play an important role in today's complier optimization techniques .…”

Section: Introductionmentioning

confidence: 99%

Cold object identification in the Java virtual machine

Briggs

Zhou

Dueck

2016

Softw. Pract. Exper.

View full text Add to dashboard Cite

Summary Many Java applications instantiate objects within the Java heap that are persistent but seldom if ever referenced by the application. Examples include strings, such as error messages, and collections of value objects that are preloaded for fast access. This paper describes a stack‐based framework for detecting these ‘cold’ objects at runtime, with a view to marshaling and sequestering them in designated regions of the heap where they may be preferentially paged out to a backing store, thereby freeing physical memory pages for occupation by more active objects. Furthermore, we evaluate the correctness and efficiency of stack‐based approach with an access barrier. The experimental results from a series of SPECjvm2008 benchmarks are presented. Copyright © 2016 John Wiley & Sons, Ltd.

show abstract

Efficient compilation strategy for object‐oriented languages under the closed‐world assumption

Cited by 4 publications

References 56 publications

Understanding and Analyzing Java Reflection

Understanding and Analyzing Java Reflection

Exploiting array manipulation habits to optimize garbage collection and type flow analysis

Cold object identification in the Java virtual machine

Contact Info

Product

Resources

About