A typical points-to analysis such as Andersen’s or Steensgaard’s may lose precision because it ignores the branching structure of the analyzed program. Moreover, points-to analysis typically focuses on objects only, not considering instructions manipulating primitive values. We argue that such an approach leads to an unnecessary precision loss, for example, when primitive constants true and false flow out of method calls. We propose a novel lightweight points-to analysis called SkipFlow that interprocedurally tracks the flow of both primitives and objects, and explicitly captures the branching structure of the code using predicate edges. At the same time, however, SkipFlow is as lightweight and scalable as possible, unlike a traditional flow-sensitive analysis. We apply SkipFlow to GraalVM Native Image, a closed-world solution to building standalone binaries for Java applications. We evaluate the implementation using a set of microservice applications as well as well-known benchmark suites. We show that SkipFlow reduces the size of the application in terms of reachable methods by 9% on average without significantly increasing the analysis time.

The Synthetic Aperture Radar operating in P-band and performing a helical flight pattern promises to be a potential tool for underground tomography, featuring high resolution and penetration. Based on the success of detecting ant nests beneath the industrial forest, a new experiment was carried out to detect buried bodies. Two sets of flights were performed and validated. Six bodies buried 0.5 m to 1.5 m deep, containing the remains of cow and pork, were located with a detection rate of 100% and a false alarm rate of 0%. Also, the ability to detect change across two sets of flights was verified by locating a bucket filled up with a large tarpaulin piece in the first set of flights.

The synthetic aperture radar (SAR) has long been used from satellites for forest monitoring at global level. The boreal forests in Sweden are well described wall-to-wall from airborne laser scanning and airborne photography. Hence, in Sweden, SAR can often only provide a limited added value, due to the low resolution compared to other sensors, despite its all-weather acquisition capabilities. By accounting for interfering effects that currently degrade the useful information in SAR images, it can be extremely valuable for both vegetation mapping and belowground mapping (e.g., soil conditions and tree roots). In the current work, we present the configuration of the first drone-based SAR experiment that allows us to image the forest in 3D with very high spatial resolution. We have started the analyses by using tomography to derive reflectivity for the roots of single trees, and comparing these with reference root biomass. The linear relationship indicates a potential for using SAR to derive forest variables that were yet neglected or little researched. Moreover, extensive additional remote sensing data have been collected from both airborne and spaceborne platforms, and reference data for both the vegetation and soil have been inventoried in-situ using complementary measurements and sensors. Hence, this unique experimental setup enables many unprecedented analyses about SAR applied to boreal forests.

As software projects grow increasingly more complex, debloating gains traction. While static analyses yield a coarse over-approximation of reachable code, approaches based on dynamic execution traces risk program correctness. By allowing the developer to reconsider only a few methods and still achieve a significant reduction in code size, cut-based debloating can minimize the risk. In this paper, we propose the idea of finding small cuts in the rule graphs produced by static analysis. After introducing an analysis with suitable semantics, we discuss how to encode its rules into a directed hypergraph. We then present an algorithm for efficiently finding the most effective single cut in the graph. The execution time of the proposed operations allows for the deployment in interactive tools. Finally, we show that our graph model is able to expose methods worthwhile to reconsider.

Designing a whole-program static analysis requires trade-offs between precision and scalability. While a context-insensitive points-to analysis is often considered a good compromise, it still has non-linear complexity that leads to scalability problems when analyzing large applications. On the other hand, rapid type analysis scales well but lacks precision. We use saturation in a context-insensitive type-based points-to analysis to make it as scalable as a rapid type analysis, while preserving most of the precision of the points-to analysis. With saturation, the points-to analysis only propagates small points-to sets for variables. If a variable can have more values than a certain threshold, the variable and all its usages are considered saturated and no longer analyzed. Our implementation in the points-to analysis of GraalVM Native Image, a closed-world approach to build standalone binaries for Java applications, shows that saturation allows GraalVM Native Image to analyze large Java applications with hundreds of thousands of methods in less than two minutes.

Whole-program analysis is an essential technique that enables advanced compiler optimizations. An important example of such a method is points-to analysis used by ahead-of-time (AOT) compilers to discover program elements (classes, methods, fields) used on at least one program path. GraalVM Native Image uses a points-to analysis to optimize Java applications, which is a time-consuming step of the build. We explore how much the analysis time can be improved by replacing the points-to analysis with a rapid type analysis (RTA), which computes reachable elements faster by allowing more imprecision. We propose several extensions of previous approaches to RTA: making it parallel, incremental, and supporting heap snapshotting. We present an extensive experimental evaluation of the effects of using RTA instead of points-to analysis, in which RTA allowed us to reduce the analysis time for Spring Petclinic (a popular demo application of the Spring framework) by 64% and the overall build time by 35% at the cost of increasing the image size due to the imprecision by 15%.

The first Futamura projection enables compilation and high performance code generation of user programs by partial evaluation of language interpreters. Previous work has shown that online partial evaluation can yield the same peak performance as a specialized JIT compiler. However, this comes with the downside of additional compile time: Online partial evaluation of language interpreters has to specialize interpreter code on the fly to the dynamic types used at run time to create efficient target code. As a result, the time spent on partial evaluation itself is a significant contributor to the overall compile time of a method.

Object Oriented Programming has flourished in many areas ranging from web-oriented microservices, data processing, to databases. However, while representing domain entities as objects is appealing to developers, it leads to data fragmentation, resulting in high memory footprint and poor locality.

Pointer analysis is widely used as a base for different kinds of static analyses and compiler optimizations. Designing a scalable pointer analysis with acceptable precision for use in production compilers is still an open question. Modern object oriented languages like Java and Scala promote abstractions and code reuse, both of which make it difficult to achieve precision. Collection data structures are an example of a pervasively used component in such languages. But analyzing collection implementations with full context sensitivity leads to prohibitively long analysis times.

Arbitrary program extension at run time in language-based VMs, e.g., Java's dynamic class loading, comes at a startup cost: high memory footprint and slow warmup. Cloud computing amplifies the startup overhead. Microservices and serverless cloud functions lead to small, self-contained applications that are started often. Slow startup and high memory footprint directly affect the cloud hosting costs, and slow startup can also break service-level agreements. Many applications are limited to a prescribed set of pre-tested classes, i.e., use a closed-world assumption at deployment time. For such Java applications, GraalVM Native Image offers fast startup and stable performance. GraalVM Native Image uses a novel iterative application of points-to analysis and heap snapshotting, followed by ahead-of-time compilation with an optimizing compiler. Initialization code can run at build time, i.e., executables can be tailored to a particular application configuration. Execution at run time starts with a pre-populated heap, leveraging copy-on-write memory sharing. We show that this approach improves the startup performance by up to two orders of magnitude compared to the Java HotSpot VM, while preserving peak performance. This allows Java applications to have a better startup performance than Go applications and the V8 JavaScript VM.

We present a novel approach for phase denoising in Interferometric Synthetic Aperture Radar (InSAR) images, named as Block-Matching InSAR (BMInSAR). It uses k-means clustering to solve the block matching similarity search problem, thus simplifying preprocessing steps and filtering several reference-blocks at once. Also, we propose a novel methodology based on ground-truth GPS measurements to assess the filtering quality of Digital Elevation Models (DEMs) derived from a pair of Very High-Resolution (VHR) SAR complex images. Our dataset was obtained by X-Band airborne sensor OrbiSAR-2 from BRADAR. BMInSAR significantly outperforms the state-of-the-art filtering methods in both accuracy and execution time. After filtering with BMInSAR, we achieved an accuracy of 21cm in the resulting DEM of a homogeneous lawn area, which is quite similar to that obtained by LiDAR technology.

Forest monitoring is a major concern today due to climate changes, conservation of fauna and flora and to the lack of water. Therefore, several environmental monitoring techniques have been developed and used to detect changes in the scenes. The use of SAR (synthetic aperture radar) seems appropriate to detect changes due to its independence of atmospheric and lighting conditions. The SAR change detection is a process that uses SAR images acquired in the same geometric conditions but in different moments (multitemporal) to identify changes in the surface that occurred between two acquisitions. This paper presents a new method of change detection in multitemporal SAR images using X- and P-band SAR images simultaneously to calculate a change detection indicator image (binary mask) based in the coherences between all the images used as attributes calculated from superpixel segments to define a change detection neural network. Experimental tests were conducted using real SAR data obtained by the airborne sensor OrbiSAR-2 from Bradar in the Amazon Forest (Equatorial Rain Forest) and the results showed good quality detections.

Most high-performance dynamic language virtual machines duplicate language semantics in the interpreter, compiler, and runtime system. This violates the principle to not repeat yourself. In contrast, we define languages solely by writing an interpreter. The interpreter performs specializations, e.g., augments the interpreted program with type information and profiling information. Compiled code is derived automatically using partial evaluation while incorporating these specializations. This makes partial evaluation practical in the context of dynamic languages: It reduces the size of the compiled code while still compiling all parts of an operation that are relevant for a particular program. When a speculation fails, execution transfers back to the interpreter, the program re-specializes in the interpreter, and later partial evaluation again transforms the new state of the interpreter to compiled code. We evaluate our approach by comparing our implementations of JavaScript, Ruby, and R with best-in-class specialized production implementations. Our general-purpose compilation system is competitive with production systems even when they have been heavily optimized for the one language they support. For our set of benchmarks, our speedup relative to the V8 JavaScript VM is 0.83x, relative to JRuby is 3.8x, and relative to GNU R is 5x.

Remote sensing has been widely applied for environmental monitoring by means of change detection techniques, commonly for identifying deforestation signs which is the gateway for illegal activities such as uncontrolled urban growth and grazing pasture. Monthly acquired X-Band images from airborne Synthetic Aperture Radar (SAR) provided multi-temporal scenes employed in this work resulting in environmental incident reports forwarded to the responsible authorities. The present work proposes the use of both, Superpixel segmentation by Simple Linear Iterative Clustering (SLIC) and change detection by Object Correlation Images (OCI) not yet applied to multi-temporal X-Band high resolution SAR images, and the application of a simple Multilayer Perceptron (MLP) supervised learning technique for detecting and classifying the changes into relevant activities. Experiments have been performed using acquired SAR imagery from BRADAR airborne sensor OrbiSAR-2 under Brazilian Atlantic Forest which revealed possible deforestation activities comparing achieved results with those obtained with experts.

Forest monitoring is a major concern today due to climate changes, conservation of fauna and flora and to the lack of water[1]. Therefore, several environmental monitoring techniques have been developed and used to detect changes in the scenes. The use of SAR is appropriate to detect changes due to its independence of atmospheric and lighting conditions. However, currently, also SAR change detection has been faced limitations due to human ilegal activities under the forest. This paper will present a new method of change detection by multitemporal full-polarimetric P-band SAR imagery using Pauli decomposition to separate artificial objects and, therefore, detect targets that appeared and disappeared under the canopy. Experimental tests have been performed using real SAR data obtained by the airborne sensor OrbiSAR-2 from Bradar and hidden targets in the Brazilian Atlantic Forest (Tropical Rain Forest).

We present an approach to cross-compile Java bytecodes to Java-Script, building on existing Java optimizing compiler technology. Static analysis determines which Java classes and methods are reachable. These are then translated to JavaScript using a re-configured Java just-in-time compiler with a new back end that generates JavaScript instead of machine code. Standard compiler optimizations such as method inlining and global value numbering, as well as advanced optimizations such as escape analysis, lead to compact and optimized JavaScript code. Compiler IR is unstructured, so structured control flow needs to be reconstructed before code generation is possible. We present details of our control flow reconstruction algorithm. Our system is based on Graal, an open-source optimizing compiler for the Java HotSpot VM and other VMs. The modular and VM-independent architecture of Graal allows us to reuse the intermediate representation, the bytecode parser, and the high-level optimizations. Our custom back end first performs control flow reconstruction and then JavaScript code generation. The generated JavaScript undergoes a set of optimizations to increase readability and performance. Static analysis is performed on the Graal intermediate representation as well. Benchmark results for medium-sized Java benchmarks such as SPECjbb2005 run with acceptable performance on the V8 JavaScript VM.

We built and analysed an airborne DInSAR time series of six P-band SAR images acquired every month over a region in the upper Amazon river basin. After proper residual motion compensation, water level changes under the foliage and terrain movements due to the river dynamics are clearly revealed. The estimations of a non-redundant and redundant network of interferograms are analysed and some consistent water variation measurements with LS residuals <; 3cm are obtained.

InSAeS4 is an Italian X band airborne SAR system, recently upgraded to a multi-antenna interferometric configuration. The system is able to acquire single pass across-track and along-track multi-baseline data with different acquisition modes characterized by different geometric resolutions and across-track swaths. In recent work we have analyzed the high resolution InSAeS4 products (obtained by transmitting 400 MHz bandwidth pulses), characterized by the narrowest across-track swath (1.5 Km wide). In this work, we focus on the InSAeS4 products characterized by the widest across-track swath, at expenses of the lowest geometric resolution. To this aim we show some results achieved with an interferometric dataset acquired by the system in 2013 over the Napoli area, Italy.

Forest monitoring is a major concern today due to climate changes, conservation of fauna and flora and to the lack of water. Therefore, several environmental monitoring techniques have been developed and used to detect changes in the scenes. However, the main techniques have limitations related to weather conditions and does not have the expected effect. The use of SAR seems appropriate to detect changes due to its independence of atmospheric and lighting conditions. This paper will present a new method of change detection in multitemporal SAR imagery using Gram-Schmidt process to do the orthogonalization of the X- and P-band images to calculate a change indicator image. Experimental tests have been conducted using real SAR data obtained by the airborne sensor OrbiSAR-2 from Bradar in the Amazon Forest and the preliminary results showed very good quality detections.

Java uses automatic memory management, usually implemented as a garbage-collected heap. That lifts the burden of manually allocating and deallocating memory, but it can incur significant runtime overhead and increase the memory footprint of applications. We propose a hybrid memory management scheme that utilizes region-based memory management to deallocate objects automatically on region exits. Static program analysis detects allocation sites that are safe for region allocation, i.e., the static analysis proves that the objects allocated at such a site are not reachable after the region exit. A regular garbage-collected heap is used for objects that are not region allocatable. The region allocation exploits the temporal locality of object allocation. Our analysis uses coarse-grain source code annotations to disambiguate objects with non-overlapping lifetimes, and maps them to different memory scopes. Region-allocated memory does not require garbage collection as the regions are simply deallocated when they go out of scope. The region allocation technique is backed by a garbage collector that manages memory that is not region allocated. We provide a detailed description of the analysis, provide experimental results showing that as much as 78% of the memory is region allocatable and discuss how our hybrid memory management system can be implemented efficiently with respect to both space and time.

When building a compiler for a high-level language, certain intrinsic features of the language must be expressed in terms of the resulting low-level operations. Complex features are often expressed by explicitly weaving together bits of low-level IR, a process that is tedious, error prone, difficult to read, difficult to reason about, and machine dependent. In the Graal compiler for Java, we take a different approach: we use snippets of Java code to express semantics in a high-level, architecture-independent way. Two important restrictions make snippets feasible in practice: they are compiler specific, and they are explicitly prepared and specialized. Snippets make Graal simpler and more portable while still capable of generating machine code that can compete with other compilers of the Java HotSpot VM.

Digital elevation model (DEM) generation through interferometric processing of synthetic aperture radar (SAR) data requires the calculation of a constant phase offset present in the unwrapped interferograms. This operation is usually carried out by exploiting the external information provided by GPS measurements in correspondence of corner reflectors (CRs) properly deployed over the illuminated area. This is, however, expensive in terms of cost and time. Moreover, deployment of CRs along with the corresponding in situ GPS measurements can be difficult (if not impossible) in unfriendly areas or in natural disaster scenarios. To circumvent these limitations, we address in this work the estimation of the required phase offset by exploiting a low-accuracy external DEM, without using CRs. More specifically, a two-step approach is proposed. The first step exploits the synthetic phase computed by means of the external DEM and represents a straightforward extension of the procedure that is usually applied in the presence of CRs. Subsequently, in order to refine the achieved solution, a second step is introduced. It is based on a least squares approach that properly exploits the difference between the available low-accuracy DEM and the interferometric DEM generated by means of the phase offset value roughly estimated through the first step. The presented approach is very easy to implement and allows us to achieve an accurate and fast estimate of the needed phase offset, even in the presence of an external DEM affected by a vertical bias and/or a planar shift. The algorithm performances improve in the presence of a large variation of the look angle, as it generally happens in airborne systems. On the other side, the effectiveness of the algorithm may be impaired by the possible presence of artifacts in the unwrapped interferograms, such as those due to the residual motion errors typical of repeat-pass airborne SAR scenarios. Accordingly, the proposed solution is particularly suitable for single-pass interferometric airborne SAR systems, as demonstrated through the presented experimental results achieved on real data.

Self-optimizing AST interpreters dynamically adapt to the provided input for faster execution. This adaptation includes initial tests of the input, changes to AST nodes, and insertion of guards that ensure assumptions still hold. Such specialization and speculation is essential for the performance of dynamic programming languages such as JavaScript. In traditional procedural and objectoriented programming languages it can be tedious to write selfoptimizing AST interpreters, as those languages fail to provide constructs that would specifically support that. This paper introduces a declarative domain-specific language (DSL) that greatly simplifies writing self-optimizing AST interpreters. The DSL supports specialization of operations based on types of the input and other properties. It can then use these specializations directly or chain them to represent the operation with the minimum amount of code possible. The DSL significantly reduces the complexity of expressing specializations for those interpreters. We use it in our high-performance implementation of JavaScript, where 274 language operations have an average of about 4 and a maximum of 190 specializations. In addition, the DSL is used in implementations of Ruby, Python, R, and Smalltalk.

Airborne single-pass SAR interferometry (InSAR) is a standard and operational technique for generating accurate and precise digital elevation models (DEM). But as DEM demand on fidelity and fast delivery grow over the years, the InSAR technology is challenged by the need of offering the same high-quality DEM over large areas on practically any type of surface and topography. The intent of this paper is to demonstrate the importance of the adoption of the topography- and aperture-dependent motion compensation (TAD-MoCo) for airborne single-pass InSAR in mountain areas. Furthermore, we present the DEM obtained using a TAD-MoCo and a multi-baseline (MB) interferometry framework for airborne single-pass InSAR. DEM over forested terrain in mountains with very strong height variations are generated free of residual motion errors and without need of phase unwrapping with the OrbiSAR system of Bradar.

TELAER is an Italian airborne X-Band Synthetic Aperture Radar (SAR) system recently upgraded to the interferometric mode thanks to an Italian National Research Council (CNR) funding. This system upgrading has been completed at the beginning of 2013 with a flight-test campaign carried out over the Napoli area, Italy. In this paper we present some results relevant to a single-pass interferometric dataset acquired during these flight-tests.

There are basically two methods for retrieving the ground and the canopy height from the interferometric synthetic aperture radar (InSAR) in forested areas. The first method is based on the different dual-band (DB) InSAR height estimation, typically done at X- and P-HH-bands. The second method is based on the modeling of the Polarimetric (Pol) InSAR response of the forest volumetric backscatter, typically at L- or P-band. This paper investigates the possibility of combining both methods, in the sense that the P-band derived ground height is enhanced by the use of the polarimetric data and the RVoG model. In this proposed method, only the ground phase is retrieved from the PolInSAR technique, reducing the numbers of unknowns to be inverted, while the X-band InSAR is used to estimate the canopy. Therefore, we avoid the more complex (and more failure susceptible) inversion of the PolInSAR approach. The data collected in the Amazon region with the OrbiSAR-1 sensor from Bradar (former Orbisat) is used to demonstrate the method. Better ground estimation over range is obtained with the proposed method in comparison with the single-polarization approach for different baselines.

Trace-based Just-In-Time (JIT) compilation generates machine code for frequently executed paths (so-called traces) instead of whole methods. While this has several advantages, it complicates invocation of compiled traces as well as exception handling, so that previous trace-based compilers limited the way in which traces could be invoked. We present a significantly enhanced trace-based compiler where arbitrary transitions between interpreted and compiled traces are possible. For that, we introduce suitable trace calling conventions and extend exception handling to work both within traces and across trace boundaries. Furthermore, we use the recorded trace information for optimizations and combine the tracing ideas with ideas from partial-method compilation to avoid code bloat. An extensive evaluation with the benchmark suites DaCapo 9.12 Bach and SPECjvm2008 shows that our trace-based compiler achieves up to 59% higher peak performance than the method-based Java HotSpot client compiler. On a few benchmarks, our fairly simple trace-based compiler shows a higher peak performance than the Java HotSpot server compiler, which is one of today's best optimizing JIT compilers for Java.

Method inlining is considered to be one of the most important optimizations in a compiler. However, a poor inlining heuristic can lead to significant degradation of a program's running time. Therefore, it is important that an inliner has an effective heuristic that controls whether a method is inlined or not. An important component of any inlining heuristic are the features that characterize the inlining decision. These features often correspond to the caller method and the callee methods. However, it is not always apparent what the most important features are for this problem or the relative importance of these features. Compiler writers developing inlining heuristics may exclude critical information that can be obtained during each inlining decision. In this paper, we use a machine learning technique, namely neuro-evolution [18], to automatically induce effective inlining heuristics from a set of features deemed to be useful for inlining. Our learning technique is able to induce novel heuristics that significantly out-perform manually-constructed inlining heuristics. We evaluate the heuristic constructed by our neuro-evolutionary technique within the highly tuned Java HotSpot server compiler and the Maxine VM C1X compiler, and we are able to obtain speedups of up to 89% and 114%, respectively. In addition, we obtain an average speedup of almost 9% and 11% for the Java HotSpot VM and Maxine VM, respectively. However, the output of neuro-evolution, a neural network, is not human readable. We show how to construct more concise and read-able heuristics in the form of decision trees that perform as well as our neuro-evolutionary approach.

In this work we focus on the Precise Topography- and Aperture-dependent algorithm, briefly PTA, proposed in the recent literature to remove the residual errors still affecting airborne SAR data focused with standard two-step Motion Compensation algorithms. More specifically, we first show that the azimuth-to-frequency mapping used by the PTA procedure is not fully appropriate, because it does not account for the presence of the residual motion errors themselves. Then, we show how to calculate the correct azimuth-to-frequency mapping able to fully account for the presence of the residual motion errors. Finally, we show how to modify the original PTA in such a way to properly exploit the correct azimuth-to-frequency mapping previously discussed.

Synthetic Aperture Radar Interferometry (InSAR) allows the generation of Digital Elevation Models (DEMs) exploiting the phase difference (interferogram) of SAR data pairs relevant to the same illuminated area and received by slightly different look angles. Within the processing chain leading from the acquired SAR data pair to the final InSAR DEM, it is necessary to calculate a proper phase offset value to add to the unwrapped SAR interferogram. To this aim, different algorithms have been proposed in the literature: most of them make use of very accurate information on the position of Ground Control Points (GCPs), such as Comer Reflectors (CRs), properly deployed over the observed scene. In this paper we present a novel algorithm for InSAR phase offset calculation without using CRs. The effectiveness of the proposed algorithm is assessed on real data acquired by the multi-antenna airborne OrbiSAR system operating at X-Band.

Method inlining is one of the most important optimizations in method-based just-in-time (JIT) compilers. It widens the compilation scope and therefore allows optimizing multiple methods as a whole, which increases the performance. However, if method inlining is used too frequently, the compilation time increases and too much machine code is generated. This has negative effects on the performance. Trace-based JIT compilers only compile frequently executed paths, so-called traces, instead of whole methods. This may result in faster compilation, less generated machine code, and better optimized machine code. In the previous work, we implemented a trace recording infrastructure and a trace-based compiler for [Formula: see text], by modifying the Java HotSpot VM. Based on this work, we evaluate the effect of trace inlining on the performance and the amount of generated machine code. Trace inlining has several major advantages when compared to method inlining. First, trace inlining is more selective than method inlining, because only frequently executed paths are inlined. Second, the recorded traces may capture information about virtual calls, which simplify inlining. A third advantage is that trace information is context sensitive so that different method parts can be inlined depending on the specific call site. These advantages allow more aggressive inlining while the amount of generated machine code is still reasonable. We evaluate several inlining heuristics on the benchmark suites DaCapo 9.12 Bach, SPECjbb2005, and SPECjvm2008 and show that our trace-based compiler achieves an up to 51% higher peak performance than the method-based Java HotSpot client compiler. Furthermore, we show that the large compilation scope of our trace-based compiler has a positive effect on other compiler optimizations such as constant folding or null check elimination.

A highly productive platform accelerates the production of research results. The design of a Virtual Machine (VM) written in the Java™ programming language can be simplified through exploitation of interfaces, type and memory safety, automated memory management (garbage collection), exception handling, and reflection. Moreover, modern Java IDEs offer time-saving features such as refactoring, auto-completion, and code navigation. Finally, Java annotations enable compiler extensions for low-level “systems programming” while retaining IDE compatibility. These techniques collectively make complex system software more “approachable” than has been typical in the past. The Maxine VM, a metacircular Java VM implementation, has aggressively used these features since its inception. A co-designed companion tool, the Maxine Inspector, offers integrated debugging and visualization of all aspects of the VM's runtime state. The Inspector's implementation exploits advanced Java language features, embodies intimate knowledge of the VM's design, and even reuses a significant amount of VM code directly. These characteristics make Maxine a highly approachable VM research platform and a productive basis for research and teaching.

An abstract syntax tree (AST) interpreter is a simple and natural way to implement a programming language. However, it is also considered the slowest approach because of the high overhead of virtual method dispatch. Language implementers therefore define bytecodes to speed up interpretation, at the cost of introducing inflexible and hard to maintain bytecode formats. We present a novel approach to implementing AST interpreters in which the AST is modified during interpretation to incorporate type feedback. This tree rewriting is a general and powerful mechanism to optimize many constructs common in dynamic programming languages. Our system is implemented in Java and uses the static typing and primitive data types of Java elegantly to avoid the cost of boxed representations of primitive values in dynamic programming languages.

This paper describes the capabilities of the TELAER X-Band airborne SAR system, which has been upgrading according to a Italian National Research Council (CNR) funding. Such a system upgrading consists first of all in the realization of a multi-antenna system able to carry out, simultaneously, Across-Track (XT) and Along-Track (AT) SAR Interferometry (InSAR). Moreover, the system upgrading is also aimed at improving the performances achievable in repeat-pass applications, such as Differential SAR Interferometry, (DInSAR), which require very precise measurement of the tracks described during the flight by the SAR antennas.

Optionally typed languages enable direct performance comparisons between untyped and type annotated source code. We present a comprehensive performance evaluation of two different JIT compilers in the context of ActionScript, a production-quality optionally typed language. One JIT compiler is optimized for quick compilation rather than JIT compiled code performance. The second JIT compiler is a more aggressively optimizing compiler, performing both high-level and low-level optimizations.

Recently, some experiments demonstrated that reliable DInSAR measurements can be achieved at any band and that further time-series analyses can be applied for airborne data. However, most of the airborne DInSAR results, including the time-series, published so far have focused on short-term analyses (baselines within hours or few days). This paper presents the first worldwide airborne DInSAR survey at P- and X-band for measuring the land movements occurred within 1 year and 3 months. The survey was performed by the OrbiSAR system of OrbiSat under contract with Petrobras (CENPES), as part of a experiment with the objective to identify possible threats to the pipeline due to land movements in Sao Sebastiao-SP, Brazil. The measurements at P-band show reliable and coherent movements in 80% of the imaged vegetated areas with accuracy in the order of centimeters. At X-band we were able to reliably measure coherent movements in urban areas with accuracy in the order of millimeters. Through field work evidences, the paper analyses the causes of these small scale land movements, and how they are related to geodynamic processes. A comparison between the DInSAR and in-loco inclinometer measurements is presented. The paper suggests some possible operational scenarios and discusses on the potential of the airborne DInSAR for land movement monitoring.

Since their inception, the usage pattern of web browsers has changed substantially. Rather than sequentially navigating static web sites, modern web browsers often manage a large number of simultaneous tabs displaying dynamic web content, each of which might be running a substantial amount of client-side JavaScript code. This environment introduced a new degree of parallelism that was not fully embraced by the underlying JavaScript virtual machine architecture. We propose a novel abstraction for multiple disjoint JavaScript heaps, which we call compartments. We use the notion of document origin to cluster objects into separate compartments.Objects within a compartment can reference each other directly. Objects across compartments can only reference each other through wrappers. Our approach reduces garbage collection pause times by permitting collection of sub-heaps (compartments), and we can use cross-compartment wrappers to enforce cross origin object access policy.

Dynamic updates to running programs improve development productivity and reduce downtime of long-running applications. This feature is however severely limited in current virtual machines for object-oriented languages. In particular, changes to classes often apply only to methods invoked after a class change, but not to active methods on the call stack of threads. Additionally, adding and removing methods as well as fields is often not supported.

The number and complexity of attacks on computer systems are increasing. This growth necessitates proper defense mechanisms. Intrusion detection systems play an important role in detecting and disrupting attacks before they can compromise software. Multivariant execution is an intrusion detection mechanism that executes several slightly different versions, called variants, of the same program in lockstep. The variants are built to have identical behavior under normal execution conditions. However, when the variants are under attack, there are detectable differences in their execution behavior. At runtime, a monitor compares the behavior of the variants at certain synchronization points and raises an alarm when a discrepancy is detected. We present a monitoring mechanism that does not need any kernel privileges to supervise the variants. Many sources of inconsistencies, including asynchronous signals and scheduling of multithreaded or multiprocess applications, can cause divergence in behavior of variants. These divergences cause false alarms. We provide solutions to remove these false alarms. Our experiments show that the multivariant execution technique is effective in detecting and preventing code injection attacks. The empirical results demonstrate that dual-variant execution has on average 17 percent performance overhead when deployed on multicore processors.

The linear scan algorithm for register allocation provides a good register assignment with a low compilation overhead and is thus frequently used for just-in-time compilers. Although most of these compilers use static single assignment (SSA) form, the algorithm has not yet been applied on SSA form, i.e., SSA form is usually deconstructed before register allocation. However, the structural properties of SSA form can be used to simplify the algorithm.

Differential SAR Interferometry (DInSAR) is a remote sensing technique which allows monitoring ground deformation with accuracy of the order of the transmitted wavelength by exploiting the phase difference (interferogram) of two temporally separated SAR images relevant to the same area. In addition, when more than two multi-pass acquisitions relevant to the same area are available, they can be properly combined by means of recent multitemporal DInSAR algorithms, in order to detect and follow the temporal evolution of ground deformation via the generation of spatially dense time series. Such a multitemporal DInSAR technique is nowadays developed and operative with space-borne SAR data, whereas specific problems may limit its application to airborne data. In this work, starting from the results already shown in previous works and relevant to an X-Band airborne DInSAR experiment carried out over the Perugia area (center of Italy) by using the OrbiSAR system, we carry out a DInSAR multitemporal analysis of data relevant to a 16 km (in azimuth) by 4 km (in range) region.

Object fusing is an optimization that embeds certain referenced objects into their referencing object. The order of objects on the heap is changed in such a way that objects that are accessed together are placed next to each other in memory. Their offset is then fixed, that is, the objects are colocated, allowing field loads to be replaced by address arithmetic. Array fusing specifically optimizes arrays, which are frequently used for the implementation of dynamic data structures. Therefore, the length of arrays often varies, and fields referencing such arrays have to be changed. An efficient code pattern detects these changes and allows the optimized access of such fields. We integrated these optimizations into Sun Microsystems' Java HotSpot™ VM. The analysis is performed automatically at runtime, requires no actions on the part of the programmer, and supports dynamic class loading. To safely eliminate a field load, the colocation of the object that holds the field and the object that is referenced by the field must be guaranteed. Two preconditions must be satisfied: The objects must be allocated at the same time, and the field must not be overwritten later. These preconditions are checked by the just-in-time compiler to avoid an interprocedural data flow analysis. The garbage collector ensures that groups of colocated objects are not split by copying groups as a whole. The evaluation shows that the dynamic approach successfully identifies and optimizes frequently accessed fields for several benchmarks with a low compilation and analysis overhead. It leads to a speedup of up to 76% for simple benchmarks and up to 6% for complex workloads.

Creating an interpreter is a simple and fast way to implement a dynamic programming language. With this ease also come major drawbacks. Interpreters are significantly slower than compiled machine code because they have a high dispatch overhead and cannot perform optimizations. To overcome these limitations, interpreters are commonly combined with just-in-time compilers to improve the overall performance. However, this means that a just-in-time compiler has to be implemented for each language.

This paper presents the interferometric airborne repeat-pass mode results at X-band after applying a complete residual motion compensation (MoCo) strategy. The data were acquired, over the Perugia area, Italy, by the OrbiSAR sensor from OrbiSat, Brazil, and the first X-Band D-InSAR results were published, where a space-invariant topography-dependent MoCo was applied after focusing with smoothed elevation model. Now, in this paper, we apply to the same X-band data the precise topography- and aperture-dependent (PTA) MoCo and the weighted phase curvature autofocus (WPCA) to account for high-order residual motion errors. We compare the differential interferograms and coherence map obtained after PTA-WPCA to the formerly results. The results show improvement in the interferometric accuracy after PTA-WPCA processing. The need of such complete processing chain for narrowband systems is discussed.

Today's web applications are pushing the limits of modern web browsers. The emergence of the browser as the platform of choice for rich client-side applications has shifted the use of in-browser JavaScript from small scripting programs to large computationally intensive application logic. For many web applications, JavaScript performance has become one of the bottlenecks preventing the development of even more interactive client side applications. While traditional just-in-time compilation is successful for statically typed virtual machine based languages like Java, compiling JavaScript turns out to be a challenging task. Many JavaScript programs and scripts are short-lived, and users expect a responsive browser during page loading. This leaves little time for compilation of JavaScript to generate machine code.We present a trace-based just-in-time compiler for JavaScript that uses run-time profiling to identify frequently executed code paths, which are compiled to executable machine code. Our approach increases execution performance by up to 116% by decomposing complex JavaScript instructions into a simple Forth-based representation, and then recording the actually executed code path through this low-level IR. Giving developers more computational horsepower enables a new generation of innovative web applications.

Array inlining expands the concepts of object inlining to arrays. Groups of objects and arrays that reference each other are placed consecutively in memory so that their relative offsets are fixed, i.e. they are colocated. This allows memory loads to be replaced by address arithmetic, which reduces the costs of field and array accesses. We implemented this optimization for Sun Microsystems' Java HotSpot VM. The optimization is performed automatically and requires no actions on the part of the programmer.

Version 6 of Sun Microsystems' Java HotSpot™ VM ships with a redesigned version of the client just-in-time compiler that includes several research results of the last years. The client compiler is at the heart of the VM configuration used by default for interactive desktop applications. For such applications, low startup and pause times are more important than peak performance. This paper outlines the new architecture of the client compiler and shows how it interacts with the VM. It presents the intermediate representation that now uses static single-assignment (SSA) form and the linear scan algorithm for global register allocation. Efficient support for exception handling and deoptimization fulfills the demands that are imposed by the dynamic features of the Java programming language. The evaluation shows that the new client compiler generates better code in less time. The popular SPECjvm98 benchmark suite is executed 45% faster, while the compilation speed is also up to 40% better. This indicates that a carefully selected set of global optimizations can also be integrated in just-in-time compilers that focus on compilation speed and not on peak performance. In addition, the paper presents the impact of several optimizations on execution and compilation speed. As the source code is freely available, the Java HotSpot™ VM and the client compiler are the ideal basis for experiments with new feedback-directed optimizations in a production-level Java just-in-time compiler. The paper outlines research projects that add fast algorithms for escape analysis, automatic object inlining, and array bounds check elimination.

Differential synthetic aperture radar interferometry (DInSAR) is a remote sensing technique that allows monitoring ground deformation with accuracy of the order of fractions of the radiated wavelength, by means of proper combination and processing of repeat-pass data. In contrast to the satellite case, application of such a technique to airborne data is not, today, a well-established task. Several airborne campaigns, involving mainly C/L-band data, have been planned in the last years to exploit the potentialities of these more flexible platforms for deformation monitoring. In this paper, we show the results of an airborne DInSAR X-band experiment carried out over the Perugia area (center of Italy) by using the OrbiSAR system. We discuss the processing chain applied to the acquired data, which allows achieving a satisfactory compromise between accuracy and efficiency. Eleven repeated passes were carried out in two days; two corner reflectors were located on the ground in a hilly region. One corner reflector was vertically moved between the two days to evaluate the system detection capability. Moreover, we carry out an analysis of all possible differential interferograms for a region 2 4 km wide.

In this paper we show the results of an airborne differential SAR interferometry (DInSAR) experiment carried out over the Perugia area, center of Italy, by using the X-Band OrbiSAR system. Measurements on corner reflectors allowed us evaluating the system detection capability.

Object inlining is an optimization that embeds certain referenced objects into their referencing object. It reduces the costs of field accesses by eliminating unnecessary field loads. The order of objects in the heap is changed in such a way that objects that are accessed together are placed next to each other in memory so that their offset is fixed, i.e. the objects are colocated. This allows field loads to be replaced by address arithmetic. We implemented this optimization for Sun Microsystems' Java HotSpot™ VM. The analysis is performed automatically at run time, requires no actions on the part of the programmer and supports dynamic class loading.

We present an optimized implementation of the linear scan register allocation algorithm for Sun Microsystems' Java HotSpot™ client compiler. Linear scan register allocation is especially suitable for just-in-time compilers because it is faster than the common graph-coloring approach and yields results of nearly the same quality.Our allocator improves the basic linear scan algorithm by adding more advanced optimizations: It makes use of lifetime holes, splits intervals if the register pressure is too high, and models register constraints of the target architecture with fixed intervals. Three additional optimizations move split positions out of loops, remove register-to-register moves and eliminate unnecessary spill stores. Interval splitting is based on use positions, which also capture the kind of use and whether an operand is needed in a register or not. This avoids the reservation of a scratch register.Benchmark results prove the efficiency of the linear scan algorithm: While the compilation speed is equal to the old local register allocator that is part of the Sun JDK 5.0, integer benchmarks execute about 15% faster. Floating-point benchmarks show the high impact of the Intel SSE2 extensions on the speed of numeric Java applications: With the new SSE2 support enabled, SPECjvm98 executes 25% faster compared with the current Sun JDK 5.0.

This paper describes how high-precision digital elevation models (DEMs) are obtained over the Wadden Sea using the AeS-1 airborne interferometric radar. The Wadden Sea is an intertidal zone along the coast having height variations less than 5 m over 30 km and is free of vegetation. The resulting DEM has a grid spacing of 2.5 m and an absolute height accuracy of 5 cm root mean square (rms), as verified by theodolite measurements. This paper describes the radar system, the processing techniques, the test area, the results, and the verification procedure.