Akira Koseki

Lock reservation: Java locks can mostly do without atomic operations

Because of the built-in support for multi-threaded programming, Java programs perform many lock operations. Although the overhead has been significantly reduced in the recent virtual machines, One or more atomic operations are required for acquiring and releasing an objects lock even in the fastest cases.This paper presents a novel algorithm called lock reservation. It exploits thread locality of Java locks, which claims that the locking sequence of a Java lock contains a very long repetition of a specific thread. The algorithm allows locks to be reserved for threads. When a thread attempts to acquire a lock, it can do without any atomic operation if the lock is reserved for the thread. Otherwise, it cancels the reservation and falls back to a conventional locking algorithm.We have evaluated an implementation of lock reservation in IBMs production virtual machine and compiler. The results show that it achieved performance improvements up to 53% in real Java programs.

Effectiveness of cross-platform optimizations for a java just-in-time compiler

This paper describes the system overview of our Java Just-In-Time (JIT) compiler, which is the basis for the latest production version of IBM Java JIT compiler that supports a diversity of processor architectures including both 32-bit and 64-bit modes, CISC, RISC, and VLIW architectures. In particular, we focus on the design and evaluation of the cross-platform optimizations that are common across different architectures. We studied the effectiveness of each optimization by selectively disabling it in our JIT compiler on three different platforms: IA-32, IA-64, and PowerPC. Our detailed measurements allowed us to rank the optimizations in terms of the greatest performance improvements with the smallest compilation times. The identified set includes method inlining only for tiny methods, exception check eliminations using forward dataflow analysis and partial redundancy elimination, scalar replacement for instance and class fields using dataflow analysis, optimizations for type inclusion checks, and the elimination of merge points in the control flow graphs. These optimizations can achieve 90% of the peak performance for two industry-standard benchmark programs on these platforms with only 34% of the compilation time compared to the case for using all of the optimizations.

Lock Reservation for Java Reconsidered

Lock reservation, a powerful optimization for Java locks, is based on the observation that, in Java, each lock tends to be dominantly acquired and released by a specific thread. Reserving a lock for such a dominant thread allows the owner thread of the lock to acquire and release the lock without any atomic read-modify-write instructions.

Evolution of a java just-in-time compiler for IA-32 platforms

JavaTM has gained widespread popularity in the industry, and an efficient Java virtual machine (JVMTM) and just-in-time (JIT) compiler are crucial in providing high performance for Java applications. This paper describes the design and implementation of our JIT compiler for IA-32 platforms by focusing on the recent advances achieved in the past several years. We first present the dynamic optimization framework, which focuses the expensive optimization efforts only on performance-critical methods, thus helping to manage the total compilation overhead. We then describe the platform-independent features, which include the conversion from the stack-semantic Java bytecode into our register-based intermediate representation (IR) and a variety of aggressive optimizations applied to the IR. We also present some techniques specific to the IA-32 used to improve code quality, especially for the efficient use of the small number of registers on that platform. Using several industry-standard benchmark programs, the experimental results show that our approach offers high performance with low compilation overhead. Most of the techniques presented here are included in the IBM JIT compiler product, integrated into the IBM Development Kit for Microsoft Windows®, Java Technology Edition Version 1.4.0.

Preference-directed graph coloring

This paper describes a new framework of register allocation based on Chaitin-style coloring. Our focus is on maximizing the chances for live ranges to be allocated to the most preferred registers while not destroying the colorability obtained by graph simplification. Our coloring algorithm uses a graph representation of preferences called a Register Preference Graph, which helps find a good register selection. We then try to relax the register selection order created by the graph simplification. The relaxed order is defined as a partial order, represented using a graph called a Coloring Precedence Graph. Our algorithm utilizes such a partial order for the register selection instead of using the traditional simplification-driven order so that the chances of honoring the preferences are effectively increased. Experimental results show that our coloring algorithm is powerful to simultaneously handle spill decisions, register coalescing, and preference resolutions.

Distributed and fault-tolerant execution framework for transaction processing

There is a growing need for efficient distributed computing for transaction processing. One of the key requirements for runtime systems in distributed environments is fault tolerance. Such a system needs to preserve the data consistency at transaction boundaries so as to resume the ongoing tasks from checkpoints with consistent data for any component failure. Another key requirement is that the system needs to be lightweight enough in normal execution to provide scalable performance. This paper presents the design and implementation of a new fault tolerant execution framework that addresses both of these requirements. We replicate each partition of the distributed persistent data on three nodes (triplet) with two different types of backups, one using warm replication and the other using cold replication. For node failures, the system is automatically recoverable unless all three nodes in any triplet fail at the same time. The system tolerates simultaneous two-node failures in any triplet most of the cases. We obtained a new trade-off in that 43% performance improvements can be achieved by slightly compromising the system availability.

Spill code minimization by spill code motion

We aim at minimizing the spill costs. Spill cost minimization heuristics that have been researched sometimes work in unexpected ways due to the lack of precise knowledge of registers availability, which can be obtained only after register allocation is all finished. Different from previous techniques, our approach, called spill code motion, tries to eliminate redundancy among spill code. This works as a variation of commonly used code motion techniques. After Chaitin-style graph coloring with naive live range splitting, spill-in instructions are first hoisted as long as registers are available and until they reach spill-out instructions. Unnecessarily hoisted spill-in instructions are then sunk. The experimental results show our approach yields up to a 10% performance increase compared to the latest spill code minimization technique in the case of using small number of registers.

Parallel programming framework for large batch transaction processing on scale-out systems

A scale-out system is a cluster of commodity machines, and offers a good platform to support steadily increasing workloads that process growing data sets. Sharding [4] is a method of partitioning data and processing a computation on a scale-out system. In a database system, a large table can be partitioned into small tables so each node can process its part of the computation. The sharding approach in a large batch transaction processing, which is important in financial area, presents two hard problems to programmers. Programmers have to write complex code (1) to transfer the input data so as to align the computations with the data partitions, and (2) to manage the distributed transactions. This paper presents a new parallel programming framework that makes parallel transactional programming easier by specifying transaction scopes and partitioners to simplify the code. Transaction scopes include series of subtransactions, each of which performs local operations. The system manages the distributed transactions automatically. A partitioner represents how the computation should be decomposed and aligned with the data partitions to avoid remote database accesses. Between paired of subtransactions, the system handles the data shuffling across the network. We implemented our parallel programming framework as a new Java class library. We hide all of the complex details of data transfer and distributed transaction management in the library. Our programming framework can eliminate almost 66% of the lines of code compared to a current programming approach without programming framework support. We also confirmed good scalability, with a scaling factor of 20.6 on 24 nodes using our modified batch program for the TPC-C benchmark.

Effective data curation for frequently asked questions

Frequently-asked-question (FAQ) systems are effective in operating and reducing costs of IT services. Basically, FAQ data preparation requires data curation of available heterogeneous question-and-answer (QA) data sets and creating FAQ clusters. We identified that the labor intensiveness of data curation is a major problem and that it strongly affects the final FAQ output quality. To deal with this problem, we designed a FAQ creation system with a strong focus on the effectiveness of its data-curation component. We conducted a field study by inspecting two sources: incident reports and a QA forum. The first source of incident reports showed a high F-score of 89.9% (precision: 82.5%, recall: 100%). We also applied the same set of parameters to 300 entries of the QA forum and achieved an F-score of 94.3% (precision: 94.9%, recall: 93.8%).

A financial risk evaluation service for integrating private portfolios securely

Value at Risk (VaR) is a widely accepted measure of counting the risk of loss on a specific portfolio of a collection of financial assets such as stocks, bonds and cash, held by a financial institution or individual. It is quite useful to compute “Integrated VaR”, a VaR for a portfolio which combines all of the portfolios in the group. However, the downside of the integration is that every financial institution needs to disclose its own portfolio to others to obtain integrated portfolio. We propose a novel approach to realize an efficient and secure protocol for N participants who hold each portfolio s1,...,sN to compute Integrated VaR for integrated portfolio s=s1+...+sN collaboratively without disclosing the value of each portfolio. This allows the financial institutions or individuals to compute cross-institutional risk more accurately to make the financial risk more transparently. Our protocol achieves high efficiency by specializing message structure and exchange to compute an integrated VaR in a privacy preserving manner.