ICOOOLPS 2011‎ > ‎

Program

Time table

8:50Welcome
9:00Keynote: XMF - A Language for Language Oriented ProgrammingTony Clark
9:30An Approach to Modular Object-Oriented Programming in Language-Driven Development FrameworkAleksei Sedunov and Nikolay Tyukachev
10:00Predicate-C - An Efficient and Generic Runtime System for Predicate DispatchFriedrich Gräter, Sebastian Götz and Julian Stecklina
10:30Coffee
11:00Application Optimization when Using Gradual TypingEsteban Allende and Johan Fabry
11:30Economic Utility Theory for Memory Management OptimizationJeremy Singer and Richard Jones
12:00Reducing and Eliding Read Barriers for Concurrent Garbage CollectorsIan Rogers
12:30Lunch
14:00Best paper award.
14:10Keynote: Past, Present and Future of Virtual Machines: A Personal ViewMario Wolczko
14:40A Tracing Technique using Dynamic Bytecode Instrumentation of Java Applications and Libraries at Basic Block LevelPierre Caserta and Olivier Zendra
15:00Reducing Biased Lock Revocation By LearningIan Rogers and Balaji Iyengar
15:30Coffee
16:00Pattern Matching for Object-like Structures in the Go Programing LanguageChanwit Kaewkasi and Pitchaya Kaewkasi
16:30Runtime Feedback in a Meta-Tracing JIT for Efficient Dynamic LanguagesCarl Friedrich Bolz, Antonio Cuni, Maciej Fijałkowski, Michael Leuschel, Samuele Pedroni and Armin Rigo
17:00Discussion

Details of presentations:

Keynote: XMF - A Language for Language Oriented Programming. Tony Clark.
Languages for Language Oriented Programming (LOP) are of interest because they allow the programmer to design programming abstractions that increase the level of abstraction of a programming language. This can be used to achieve 'internal' or 'external' Domain Specific Languages or just to make certain programming idioms more convenient to use. Reflective and Meta-Circular languages are of interest because they achieve a similar aim by allowing applications to reflect on and affect their executions.
XMF is a programming language that has been designed to support both reflection and LOP. It is object-oriented and embeds its own abstract syntax as class definitions. A new language feature is embedded in XMF using syntax-classes that use extensible grammars to process concrete syntax. This talk will provide an overview of the syntax class mechanism of XMF.
An Approach to Modular Object-Oriented Programming in Language-Driven Development Framework. Aleksei Sedunov and Nikolay Tyukachev.
We report on our ongoing research of an object-oriented language for a metaprogramming framework called Turbine. The paper describes structural elements of models, their relations and intended patterns of usage and then presents an object-oriented language we've developed specifically for the Turbine framework ("base language"). We also demonstrate usage of base language constructs on examples of the modular behavior extension for the set of AST classes.
Predicate-C - An Efficient and Generic Runtime System for Predicate Dispatch. Friedrich Gräter, Sebastian Götz and Julian Stecklina.
Dynamically typed languages like Ruby recently gained a growing popularity due to the simplification of unforeseen software extensibility. Extensibility is typically driven by method dispatch which in turn uses the type system to classify objects. Common type systems only support type classifications attached to objects in advance of a method call. By that, the applicability of methods can be only described using existing classifications limiting the generic reuse of methods. Furthermore, it is difficult to classify objects by dynamic conditions according to their runtime state or current execution context. As an alternative, predicate dispatching allows the dispatch of methods on arbitrary predicates. Criteria for applicability are directly bound to methods enabling a flexible classification of objects. However, existing solutions for predicate dispatch suffer from co- NP-completeness. Furthermore, these solutions depend on high-level programming languages, which limits a systemwide and cross-language application of predicate dispatch. In this work, we present Predicate-C, a runtime environment that provides predicate dispatch with polynomial dispatching overhead. It is implemented as a lightweight C library that can be integrated into arbitrary runtime environments.
Application Optimization when Using Gradual Typing. Esteban Allende and Johan Fabry.
Static and dynamic typing have different strengths and weaknesses. Gradual typing allows a programmer to combine statically and dynamically typed sections of code in one program. This allows the best typing choice for each part of the code. Sadly, the advantages of efficient program execution that come with static typing do not yet carry over to a gradual typing system. This is because no optimizations have yet been proposed that take advantage of the type information present in this context. In this work, we propose optimizations for gradually typed applications, focused on four areas: optimizing method lookup, optimizing type checking, breaking encapsulation and improving infrastructure. We also propose how we are going to validate these optimizations.
Economic Utility Theory for Memory Management Optimization. Jeremy Singer and Richard Jones.
In this position paper, we examine how economic theory can be applied to memory management. We observe the correspondence between the economic notion of a consumer and an instance of a virtual machine running a single program in an isolated heap. Economic resource consumption corresponds to the virtual machine requesting and receiving increased amounts of heap memory from the underlying operating system. As more memory is allocated to a virtual machine’s heap, there is additional benefit (cf. economic utility) from the extra resource. We also discuss production and cost functions, which might assist in efficient memory allocation between multiple virtual machines that are competing for a fixed amount of shared system memory.
Reducing and Eliding Read Barriers for Concurrent Garbage Collectors. Ian Rogers.
In order for a garbage collector to concurrently move an object while an application mutator thread accesses it, either read or write barriers are necessary. A read barrier places certain invariants on loaded values that allow the garbage collector and mutator to progress in parallel. However, the read barrier is performed on loads and can be viewed as an impediment to the performance of the application threads. This paper builds on the work of a highly efficiency concurrent garbage collector known as the Continuously Concurrent Compacting Collector (C4) which progresses the design of read barriers to create what is known as the Loaded Value Barrier (LVB). This paper's key insight is the dynamic number of LVBs may be dramatically reduced by a compiler using the invariants the LVB provides. The paper describes three examples of this class of transformation, and reasons about their correctness and performance. We are unaware of work describing compiler optimizations to elide read barriers or restructure code to cut their dynamic execution. We detail related work on improving read barrier efficiency.
Keynote: Past, Present and Future of Virtual Machines: A Personal View. Mario Wolczko.
I've been involved with a a variety of virtual machine design and implementation projects going back to 1984. A lot has changed over that period, but the aims haven't changed much at all. In this talk I'll present a subjective history of VMs, and argue that the time is ripe for a radical rethink.
A Tracing Technique using Dynamic Bytecode Instrumentation of Java Applications and Libraries at Basic Block Level. Pierre Caserta and Olivier Zendra.
Implementing a profiler to trace a program execution is non- trivial. One way to do this on running Java programs is through bytecode instrumentation. Nowadays, tools exist that ease the instrumentation process itself, but as far as we know, none offers an entirely dynamic implementation technique which is able to include the instrumentation of Java Runtime Environement (JRE) classes. In this paper we present the main principles of our technique, which performs such online bytecode instrumentation of both application and JRE classes, at basic block level.
Reducing Biased Lock Revocation By Learning. Ian Rogers and Balaji Iyengar.
For languages supporting concurrency the implementation of synchronization primitives is important for achieving high-performance. Many concurrent languages use object based locks to control access to critical regions. When lock ownership doesn't change for most of its lifetime, lock biasing allows a thread to take ownership of an object so that atomic operations aren't necessary on lock entry and exit. Revoking ownership of locks biased to a thread is an expensive operation compared to the atomic operation, as the thread that holds the lock must be suspended. 
When lock revocation occurs it is common for the object being locked to be modified so that future lock attempts use atomic operations. When repeated revocations occur the locking policy can reduce the amount of lock biasing that the system performs. Factors that can drive this include the type of the object being revoked and how recently it was allocated. The system must achieve a balance between being pessimistic about biased lock use and avoiding revocations. 
This work introduces a new locking protocol where revocations can be sampled by the locker without having to bias. The mechanism provides locking information specific to a particular instance that can be used to avoid unprofitable bias lock speculation and create a better locking policy. We demonstrate a new instance specific locking policy implemented in the Zing Virtual Machine, an extension of the HotSpot Java Virtual Machine. We present results on how the sampling window effects the number of atomic lock operations and revocations for the SPECjvm2008 and DaCapo Bach benchmark suites.
Pattern Matching for Object-like Structures in the Go Programing Language. Chanwit Kaewkasi and Pitchaya Kaewkasi.
This paper explores the feasibility of implementing pattern matching for the Go programming language. The design of pattern matching is taken from Scala, and reimplemented using Go’s constructs and new language extensions, namely casestruct and trait.
The evaluations show that pattern matching allows ex- pressing decomposition for struct in concise forms. The concepts of casestruct and trait are suggested to add to the Go language in order to make it properly supports pattern matching. However, the performance of the current implementation is still slower than hand-written struct decompositions. The evaluations also suggest that performance penalty of the type embedding feature proposed by Go for inheritance-like relationship is found in the GCCGO implementation, but not in another implementation, namely 8g.
Runtime Feedback in a Meta-Tracing JIT for Efficient Dynamic Languages. Carl Friedrich Bolz, Antonio Cuni, Maciej Fijałkowski, Michael Leuschel, Samuele Pedroni and Armin Rigo.
Meta-tracing JIT compilers can be applied to a variety of differ- ent languages without explicitly encoding language semantics into the compiler. So far, they lacked a way to give the language im- plementor control over runtime feedback. This restricted their per- formance. In this paper we describe the mechanisms in PyPy’s meta-tracing JIT that can be used to control runtime feedback in language-specific ways. These mechanisms are flexible enough to express classical VM techniques such as maps and runtime type feedback.
Comments