The Cell Broadband Enginee processor employs multiple accelerators, called synergistic processing elements (SPEs), for high performance. Each SPE has a highspeed local store attached to the main memory through direct memory access (DMA), but a drawback of this design is that the local store is not large enough for the entire application code or data. It must be decomposed into pieces small enough to fit into local memory, and they must be replaced through the DMA without losing the performance gain of multiple SPEs. We propose a new programming model, MPI microtask, based on the standard Message Passing Interface (MPI) programming model for distributed-memory parallel machines. In our new model, programmers do not need to manage the local store as long as they partition their application into a collection of small microtasks that fit into the local store. Furthermore, the microtasks by exploiting explicit communications in the MPI model. We have created a prototype that includes a novel static scheduler for such optimizations. Our initial experiments have shown some encouraging results.

Abstract.OpenJIT is an open-ended, reective JIT compiler framework for Java being researched and developed in a joint p r o j e c t by T okyo Inst. Tech. and Fujitsu Ltd. Although in general self-descriptive systems have been studied in various contexts such as reection and interpreter/compiler bootstrapping, OpenJIT is a rst system we know t o d a t e that oers a stable, full-edged Java JIT compiler that plugs into existing monolithic JVMs, and oer competitive performance to JITs typically written i n C o r C + + . T h i s i s i n c o n trast 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 p r o p o s e a n architecture for a reective JIT compiler on a monolithic VM, and identify the technical challenges as well as the techniques employed, 2) We dene an API that adds to the existing JIT compiler APIs in \classic" JVM to allow reective 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, and 4) we demonstrate how reective JITs could be useful class-or application specic customization and optimization by p r o viding an important reective \hook" into a Java system. Being an object-oriented compiler framework, OpenJIT can be congured to be small and portable or fully-edged optimizing compiler framework in the spirit of SUIF. It is fully JCK compliant, and runs all large Java applications we h a ve tested to date including HotJava. We are currently distributing OpenJIT for free to foster further research i n to advanced compiler optimization, compile-time reection, advanced run-time support for languages, as well as other areas such a s e m bedded computing, metacomputing, and ubiquitous computing.

Rapid commoditization of advanced hardware and progress of networking technology is now making wide area high-performance computing a.k.a, the 'Grid' Computing a reality. Since a Grid will consist of vastly heterogeneous sets of compute nodes, especially commodity clusters, some have articulated the use of Java as a suitable technology to satisfy portability across different machines. Since Java's natural model of parallelism is shared memory multithreading, one will have to support distributed shared memory (DSM) in a portable manner; however, none of the previous work on implementing Java on DSM has been a portable solution. Instead, we propose a software architecture whose goal is to achieve portability of DSM implementations across different commodity clustering platforms, while restricting the programming model somewhat, and implemented a prototype system, JDSM. Benchmark resuits show that the current implementation on Java incurs increased memory coherency maintenance cost compared to C-based DSMs, thus limiting scalability to some degree, and we are currently working on a solution to alleviate this cost.

Abstract. Platform portability is one of the utmost demanded properties of a system today, due to the diversity of runtime execution environment o f wide-area networks, and parallel programs a r e n o e x c e ptions. However, parallel execution environments are VERY d i v erse, 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 reection 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 dierent 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.

No abstract