Acceleration and semantic foundations of embedded Java platforms

Tableau d'honneur de la Faculté des études supérieures et postdoctorales, 2006-200

Supporting dynamic aspect-oriented features

Aspect-oriented programming techniques extend object-oriented programming with new methods to modularize concerns that otherwise would be non-modular. For example, logging concerns are typically scattered across a system but using aspect-oriented techniques they can be localized into a single high-level module. These techniques typically take modular high-level code and statically transform it into non-modular intermediate code. The contribution of this work is the design and implementation of a flexible and dynamic intermediate-language (IL) model. The main motivation for the design of this IL model is to support a variety of dynamic aspect-oriented language constructs that are proposed in recent literature such as CaeserJ\u27s deploy, history-based pointcuts, and control flow constructs. Our IL model provides a higher level of abstraction compared to traditional object-oriented ILs as a compilation target for such constructs, which makes it easier to provide efficient implementations of these constructs. We demonstrate these benefits by providing an industrial strength implementation for our IL model, by showing translation strategies from dynamic source-level constructs to our improved IL, and by analyzing the performance of the resulting IL code. Our evaluation using the SPEC JVM98 and Java Grande benchmarks shows that the overhead of supporting a dynamic deployment model can be reduced to as little as ~1.5%, when compared to the unmodified VM

Triggering of Just-In-Time Compilation in the Java Virtual Machine

The Java Virtual Machine (Standard Edition) normally interprets Java byte code but also compiles Java methods that are frequently interpreted and runs them natively. The purpose is to take advantage of native execution without having too much overhead for Just-In-Time compilation. A former SJSU thesis tried to enhance the standard policy by predicting frequently called methods ahead of their actual frequent interpretation. The project also tried to increase the compilation throughput by prioritizing the method compilations, if there is more than one hot method to compile at the same time. The paper claimed significant speedup. In this project, we tried to re-implement the previous work on a different platform to see if we get the same results. Our re-evaluation showed some speedup for the prediction approach but with some adjustments and only for server applications. It also showed some speedup for the prioritizing approach for all the benchmarks. We also designed two other approaches to enhance the original policy. We tried to reduce the start-up delay that is due to overhead of Just-In-Time compilation by postponing some of Just-In- Time compilation. We also tried to increase the accuracy of detecting frequently interpreted methods that contain nested loops. We could not gain any speedup for our former postponing approach but we could improve the performance using our latter measuring approach