Hiroshi Horii

Compiling X10 to Java

X10 is a new programming language for improving the software productivity in the multicore era by making parallel/distributed programming easier. X10 programs are compiled into C++ or Java source code, but X10 supports various features not supported directly in Java. To implement them efficiently in Java, new compilation techniques are needed.n This paper discusses problems in translating X10-specific functions to Java and provides our solutions. By using appropriate implementations, sequential execution performance has been improved by about 5 times making it comparable to native Java. The parallel execution performance has also been improved and the gap from Java Fork/Join performance is about 3 times when run at a single place. Initial evaluation of distributed execution shows good scalability. Most of the results in this paper have already been incorporated in X10 release 2.1.2.n Many of the compilation techniques described in this paper can be useful for implementing other programming languages targeted for Java or other managed environments.

Event Processing over a Distributed JSON Store: Design and Performance

Web applications are increasingly built to target both desktop and mobile users. As a result, modern Web development infrastructure must be able to process large numbers of events (e.g., for location-based features) and support analytics over those events, with applications ranging from banking (e.g., fraud detection) to retail (e.g., just-in-time personalized promotions). We describe a system specifically designed for those applications, allowing high-throughput event processing along with analytics. Our main contribution is the design and implementation of an in-memory JSON store that can handle both events and analytics workloads. The store relies on the JSON model in order to serve data through a common Web API. Thanks to the flexibility of the JSON model, the store can integrate data from systems of record (e.g., customer profiles) with data transmitted between the server and a large number of clients (e.g., location-based events or transactions). The proposed store is built over a distributed, transactional, in-memory object cache for performance. Our experiments show that our implementation handles high throughput and low latency without sacrificing scalability.

A Distributed Quorum System for Ensuring Bounded Staleness of Key-Value Stores

Modern storage systems employing quorum replication are often configured to use partial, non-strict quorums to prioritize performance over consistency. These systems return the most recently changed data item only from a set of replicas to respond more quickly to a read request without guaranteeing that the data item is the most recently changed for all of the data. Because these partial quorum mechanisms provide only basic eventual consistency guarantees, with no limit on the freshness of the data returned, sometimes these configurations are not acceptable for certain applications. In this work, we have devised a new key-value store with partial quorums while ensuring bounded staleness. Our store reports the expected bounds on staleness with respect to wall clock. We evaluated our new key-value store with Yahoo! Cloud Service Benchmarks and show its performance.

Balanced double queues for GC work-stealing on weak memory models

Work-stealing is promising for scheduling and balancing parallel workloads. It has a wide range of applicability on middleware, libraries, and runtime systems of programming languages. OpenJDK uses work-stealing for copying garbage collection (GC) to balance copying tasks among GC threads. Each thread has its own queue to store tasks. When a thread has no task in its queue, it acts as a thief and attempts to steal a task from another threads queue. However, this work-stealing algorithm requires expensive memory fences for pushing, popping, and stealing tasks, especially on weak memory models such as POWER and ARM. To address this problem, we propose a work-stealing algorithm that uses double queues. Each GC thread has a public queue that is accessible from other GC threads and a private queue that is only accessible by itself. Pushing and popping tasks in the private queue are free from expensive memory fences. The most significant point in our algorithm is providing a mechanism to maintain the load balance on the basis of the use of double queues. We developed a prototype implementation for parallel GC in OpenJDK8 for ppc64le. We evaluated our algorithm by using SPECjbb2015, SPECjvm2008, TPC-DS, and Apache DayTrader.

Memory-Efficient index for cache invalidation mechanism with OpenJPA

OpenJPA is an implementation of the Java Persistence API (JPA) for Apache, with a caching layer for database queries. However the caching performance is poor when an application includes write transactions, because the OpenJPA cache-invalidation mechanism is coarse-grained and this results in a low cache hit rate. In this research, we implemented an index mechanism for cache invalidation optimized for the data access patterns. The sizes of the index can be adjusted for the available cache memory. The results of our benchmark indicated that the optimized index drastically improved the performance of OpenJPA even with a small index size in various data access pattern scenarios.