(This page uses CSS style sheets)

ECOOP 2008 logo


for the
Third International Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS 2008)
July 7, Paphos (Cyprus)

Session Chair: Eric Jul

 9:00Welcome and ICOOOLPS introduction
 9:10Short introduction of participants (time according to number of attendees)

approx. 9:20 - 10:15     SESSION 1: Lookup, method invocation, reflection
Session Chair: TBA

 9:20 Coloring in Incremental Compilation of Object-Oriented Languages
Jean Privat and Floréal Morandat / UQAM, Montreal (CA) and LIRMM, CNRS, Université de Montpellier II (FR)

Abstract: In this short paper we propose a variation of the coloring technique that makes it compatible with shared libraries. Our proposal is usable for the three main object-oriented mechanisms method invocation, attribute access, and subtype check; and respects five functional and efficiency requirements: constant time, quadratic space3 , short code, compatible with multiple inheritance, and incremental. We validate our proposal with theoretical evaluations, simulations and real executions.
Full paper (PDF).
 9:30Approaches to Reflective Method Invocation
Ian Rogers, Jisheng Zhao, and Ian Watson / The University of Manchester (UK).

Abstract: Reflective method invocation is a long known performance bottle neck in Java. Different approaches to optimizing reflective method invocation are adopted by JVMs. In this paper we present an overview of the different approaches and a performance analysis using synthetic and the DaCapo benchmarks. We implement all of the approaches in the Jikes RVM.
Full paper (PDF).
 9:40 Precomputing Method Lookup
Eric Jul / DIKU (DK)

Abstract: This paper looks at Method Lookup and discusses the Emerald approach to making Method Lookup more efficient by precomputing method lookup as early as possible --- even moving it back into the compilation phase, if possible, thus eliminating method lookup entirely for many simple procedure calls.
Full paper (PDF).
 9:50 Discussion 1
"Method lookup, reflection and dispatch techniques"

10:15 - 11:30    SESSION 2: Types, annotations, analyses
Session Chair: TBA

 10:15 Cast Elimination for Containers in Java
Yuji Chiba / Systems Development Laboratory, Hitachi (JP).

Abstract: Concept checking is a new and powerful construct being introduced in the next standard of C++ . Using concepts we can define the properties a template requires from its type arguments. If a type does not fulfill the requirements syntactically, but semantically, the connection must be declared with the use of a concept map. Often the description of the semantic matching results in long codes that need to be modularized. In this paper we present an extension to the concept map language constructs that enables this transformation. We introduce the well-known public, protected, private class arrangement scheme into concept maps. We present our preprocessor, that transforms the modularized code into regular code to be compiled by ConceptGCC, the experimental Concept C++ compiler.
Full paper (PDF).
 10:35 The Use of a Pure Method Attribute in a Dynamic Compilation Environment
Jisheng Zhao, Ian Rogers, Chris Kirkham, and Ian Watson / The University of Manchester (UK)

Abstract: Not all compiler analysis can determine a method call will have no side effects, for example if the method called is performing memoization of common results. Having a pure attribute allows such methods to be flagged to the compiler and their values evaluated at compile time. This allows a greater amount of partial evaluation with little compile time overhead. The lack of overhead to the compiler motivates us to look for other instances of pure methods, where rather than spend time trying to inline and reduce code, we merely evaluate a call at runtime using reflection. This paper presents a study of different methods of in- ferring pure methods in the dynamic compilation environment of a Java Virtual Machine (JVM). We look at programmer specified annotations, determining pure method information from naive bytecode analysis and more sophisticated analysis in an optimizing compiler. The optimizing compiler analysis is able to achieve to speed up the runtime environment by an average of 1.29% on a range of DaCapo and SpecJVM benchmarks.
Full paper (PDF).
 10:25 Optimizing Higher-Order Functions in Scala
Iulian Dragos / EPFL (CH).

Abstract:Scala relies on libraries as the default mechanism for language extension. While this provides an elegant solution for growing the language, the performance penalty incurred by call-by-name parameters, boxing and anonymous functions is high. We show that inlining alone is not enough to remove this overhead, and present a solution based on decompilation of library code combined with inlining, dead code elimina- tion, and copy propagation. We evaluate our approach on two language extensions, Java-like assert and C-like for-loops and show improvements of up to 45%.
Full paper (PDF).
 10:45 Discussion 2

11:30 - 12:00     Coffee break

12:00 - 13:30     SESSION 3: Memory, garbage collection
Session Chair: TBA

 12:00 C++ Move Semantics for Exception Safety and Optimization in Software Transactional Memory Libraries
Justin Gottschlich, Jeremy G. Siek and Daniel A. Connors / University of Colorado at Boulder (USA)

Abstract: The goal of transactional memory (TM) is to reduce the complexity of parallel programming. Software transactional memory (STM) is an effective near-term solution for gaining experience with transactional memory and taking advantage of its benefits. STM systems rely on either traditional lock-based synchronization or non-blocking techniques. While non-blocking techniques offer natural scalability, the lock-based approaches require fewer changes to user-defined data structures. Some lock-based STM libraries rely on user-defined copy assignment operators during the commit phase of a transaction (under the deferred update policy) or during the abort phase of a transaction (under the direct update policy). Unfortunately, such operations may throw exceptions and prevent the commit or abort from completing, thereby leaving the program in a partially-committed or inconsistent state. In this paper we present a solution to this problem: our STM library moves objects back to global memory instead of copying them. The move operation transfers the resources of the source object to the target object and then zeroes out the source object. Implementing move operations in an exception safe manner is straightforward. The ability to move objects is a new feature in the next version of the C++ standard, supported by the addition of rvalue references. We demonstrate our solution within DracoSTM, a C++ lock-based STM library, and present a performance comparison of move versus copy for both direct and deferred updating.
Full paper (PDF).
 12:10 Boot Image Layout for Jikes RVM
Ian Rogers, Jisheng Zhao, and Ian Watson / The University of Manchester (UK)

Abstract: A boot image is a view of memory created in a bootstrap environment, written to disk and loaded to perform as the running environment. Creating a boot image is a staple of runtime environments that are written in their own programming language and using their own runtime services. A prominent example is Jikes RVM, a Java Virtual Machine (JVM) written in Java. In this paper we will look at the issue of boot image layout. We show that static layout methods can be used to reduce the number of pages accessed by garbage collection of the boot image by over 48%. An average speed up of 0.61% is found for a range of DaCapo and SpecJVM benchmarks.
Full paper (PDF).
 12:30 Discussion 3
"Memory management: is it that important ?"
"Type safe Garbage Collection: is it possible in Real-Time applications ?"
"Transactional memory: language extension or library solution ?"

13:30 - 15:30     Lunch break

15:30 - 16:45 (at the latest)     SESSION 4: Power and Energy
Session Chair: TBA

 15:30 Discussion 4
"Power/energy usage optimization: is it only a hardware issue ?"

(if time permits, 16:15 - 16:45)    (SESSION 5: Java)
Session Chair: TBA

 (if time permits 16:15) (Discussion 5
"Java in embedded systems: where is it, concretely ?"
"Java threads and synchronization model", aka "Do threads make sense ?")

16:45 - 17:00     WRAP-UP AND FAREWELL

17:00 - ...     ICOOOLPS PC Meeting

Updated 7th July 2008 by OZ.