Hirotaka Ogawa

OpenJIT: An Open-Ended, Reflective JIT Compiler Framework for Java

OpenJIT is an open-ended, reflective JIT compiler framework for Java being researched and developed in a joint project by Tokyo Inst. Tech. and Fujitsu Ltd. Although in general self-descriptive systems have been studied in various contexts such as reflection and interpreter/compiler bootstrapping, OpenJIT is a first system we know to date that offers a stable, full-fledged Java JIT compiler that plugs into existing monolithic JVMs, and offer competitive performance to JITs typically written in C or C++. This is in contrast to previous work where compilation did not occur in the execution phase, customized VMs being developed ground-up, performance not competing with existing optimizing JIT compilers, and/or only a subset of the Java language being supported. The main contributions of this paper are, 1) we propose an architecture for a reflective JIT compiler on a monolithic VM, and identify the technical challenges as well as the techniques employed, 2) We define an API that adds to the existing JIT compiler APIs in classic JVM to allow reflective JITs to be constructed, 3) We show detailed benchmarks of run-time behavior of OpenJIT to demonstrate that, while being competitive with existing JITs the time- and space-overheads of compiler metaobjects that exist in the heap are small and manageable. Being an object-oriented compiler framework, OpenJIT can be configured to be small and portable or fully-fledged optimizing compiler framework in the spirit of SUIF. It is fully JCK compliant, and runs all large Java applications we have tested to date including HotJava. We are currently distributing OpenJIT for free to foster further research into advanced compiler optimization, compile-time reflection, advanced run-time support for languages, as well as other areas such as embedded computing, metacomputing, and ubiquitous computing.

OMPI: Optimizing MPI Programs using Partial Evaluation

MPI is gaining acceptance as a standard for message-passing in high-performance computing, due to its powerful and flexible support of various communication styles. However, the complexity of its API poses significant software overhead, and as a result, applicability of MPI has been restricted to rather regular, coarse-grained computations. Our OMPI (Optimizing MPI) system removes much of the excess overhead by employing partial evaluation techniques, which exploit static information of MPI calls. Because partial evaluation alone is insufficient, we also utilize template functions for further optimization. To validate the effectiveness for our OMPI system, we performed baseline as well as more extensive benchmarks on a set of application cores with different communication characteristics, on the 64-node Fujitsu AP1000 MPP. Benchmarks show that OMPI improves execution efficiency by as much as factor of two for communication-intensive application core with minimal code increase. It also performs significantly better than previous dynamic optimization technique.

Multi-client LAN/WAN Performance Analysis of Ninf: a High-Performance Global Computing System

Rapid increase in speed and availability of network of supercomputers is making high performance global computing possible, in which computational and data resources in the network are collectively employed to solve large-scale problems. There have been several recent proposals of global computing including our Ninf system. However, critical issues regarding system performance characteristics in global computing have been little investigated, especially under multi-clients, multi-sites WAN settings. In order to investigate the feasibility of Ninf and similar systems, we conducted benchmarks with different communication/computation characteristics on a variety of combinations of clients and servers in their performance, architecture, etc. under LAN, single-site WAN, multi-site WAN situations.

Autonomous configuration of grid monitoring systems

The problem with practical, large-scale deployment of grid monitoring system is that it takes considerable management cost and skills to maintain the level of quality required by production usage since the monitoring system is fundamentally distributed, need to be running continuously, and in itself likely be affected by the various faults and dynamic reconfigurations of the grid itself. Although their automated management would be desirable, there are several difficulties, distributed faults and reconfigurations, component interdependencies, and scaling to maintain performance while minimizing probing effect. Given our goal to develop a generalized autonomous management framework for grid monitoring, we have built a prototype, on top of NWS, featuring automatic configuration of its clique groups as well as coping with single-node faults without user intervention. An experimental deployment on the Tokyo Institute of Technologys Campus Grid (the Titech Grid) consisting of over 15 sites and 800 processors has shown the system to be robust in handling faults and reconfigurations, automatically deriving an ideal clique configuration for the head login nodes of each PC cluster in less than two minutes.

The second trans-Pacific Grid Datafarm testbed and experiments for SC2003

The Grid Datafarm architecture is designed for global petascale data-intensive computing. It provides a global parallel file system (Gfarm file system) with online petascale storage, scalable I/O bandwidth, and scalable parallel processing by federating thousands of local file systems in a grid of clusters securely using Grid security infrastructure. One of features is that it manages file replicas in filesystem metadata for fault tolerance and load balancing. Here, we present an overview of our planned experiment performed as the SC2003 Bandwidth Challenge at the Supercomputing 2003 site in Phoenix, Arizona, USA. In the experiment, five clusters in Japan and three clusters in US comprise a Gfarm file system, on which world-wide largescale data analysis is performed. In the Gfarm file system, a file is dispersed in several cluster nodes, each of which is replicated independently and in parallel by multiple third-party transfers between multiple cluster nodes. For the Challenge, terabyte-scale experimental data is replicated between US and Japan via APAN/TransPAC and SuperSINET (about 10,000 km or 6,000 miles). At the workshop we present the full detail of the experiment.

OMPC++ - A Portable High-Performance Implementation of DSM using OpenC++ Reflection

Platform portability is one of the utmost demanded properties of a system today, due to the diversity of runtime execution environment of wide-area networks, and parallel programs are no exceptions. However, parallel execution environments are VERY diverse, could change dynamically, while performance must be portable as well. As a result, techniques for achieving platform portability are sometimes not appropriate, or could restrict the programming model, e.g., to simple message passing. Instead, we propose the use of reflection for achieving platform portability of parallel programs. As a prototype experiment, a software DSM system called OMPC++ was created which utilizes the compile-time metaprogramming features of OpenC++ 2.5 to generate a message-passing MPC++ code from a SPMD-style, shared-memory C++ program. The translation creates memory management objects on each node to manage the consistency protocols for objects arrays residing on different nodes. Read- and write- barriers are automatically inserted on references to shared objects. The resulting system turned out to be quite easy to construct compared to traditional DSM construction methodologies. We evaluated this system on a PC cluster linked by the Myrinet gigabit network, and resulted in reasonable performance compared to a high-performance SMP.

OpenJIT Frontend System: An Implementation of the Reflective JIT Compiler Frontend

OpenJIT is an open-ended, reflective JIT compiler framework for Java being researched and developed in a joint project by Tokyo Inst. Tech. and Fujitsu Ltd. Although in general self-descriptive systems have been studied in various contexts such as reflection and interpreter/compiler bootstrapping, OpenJIT is a first system we know to date that offers a stable, full-fledged Java JIT compiler that plugs into existing monolithic JVMs, and offer competitive performance to JITs typically written in C or C++. We propose an architecture for a reflective JIT compiler on a monolithic VM, and describe the details of its frontend system. And we demonstrate how reflective JITs could be useful class-or application specific customization and optimization by providing an important reflective hook into a Java system. We will focus on the Frontend portion of the OpenJIT system for this article; the details of the backend is described in [20].

Towards a Parallel C++ Programming Language Based on Commodity Object-Oriented Technologies

To become widespread, parallel computing should be based on advanced commodity technology, and parallel languages are no exception. But parallel languages must also support a wide range of parallel programming styles, ease of programming, and high performance. We show that C++ can support a wide range of parallel programming styles without special language extensions. More concretely, we used MPC++, a parallel dialect of C++ extended using only templates and inheritance, to create a prototype class/template library which supports three kinds of parallel programming styles. We tested the library performance with representative programs in each of the programming styles.