Seiji Umatani

Pursuing Laziness for Efficient Implementation of Modern Multithreaded Languages

Modern multithreaded languages are expected to support advanced features such as thread identification for Java-style locks and dynamically-scoped synchronization coupled with exception handling. However, supporting these features has been considered to degrade the effectiveness of existing efficient implementation techniques for fine-grained fork/join multithreaded languages, e.g., lazy task creation. This paper proposes efficient implementation techniques for an extended Java language OPA with the above advanced features. Our portable implementation in C achieves good performance by pursuing ‘laziness’ not only for task creation but also stealable continuation creation, thread ID allocation, and synchronizer creation.

Parallel Graph Traversals using Work-Stealing Frameworks for Many-core Platforms

Parallel programming/execution frameworks for many/multi-core platforms should support as many applications as possible. In general, work-stealing frameworks provide efficient load balancing even for irregular parallel applications. Unfortunately, naive parallel programs which traverse graph-based data structures (e.g., for constructing spanning trees) cause stack overflow or unacceptable load imbalance. In this study, we develop parallel programs to perform probabilistically balanced divide-and-conquer graph traversals. We propose a programming technique for accumulating overflowed calls for the next iteration of repeated parallel stages. In an emerging backtracking-based work-stealing framework called “Tascell, ” which features on-demand concurrency, we propose a programming technique for long-term exclusive use of workspaces, leading to a similar technique also in the Cilk framework.

Extending a Work-Stealing Framework with Probabilistic Guards

We propose probabilistic guards and analyze their performance. To reduce the total task division cost, probabilistic guards can prevent thief workers from stealing small tasks from victim workers probabilistically. In this study, we have implemented probabilistic guards on a work-stealing framework called Tascell and have confirmed that they perform well. In theory, a thief may repeat an unbounded number of probabilistically prevented steal attempts until success if a victim uses a probabilistic guard that rejects steal attempts with a non-zero probability. Therefore, in this paper, we also propose a mechanism that invalidates probabilistic guards on demand by setting an upper limit to the number of repeated probabilistically prevented steal attempts. We evaluate its potential effects on probabilistic guards by measuring the actual numbers of repeated attempts until success. We also evaluate the performance of probabilistic guards with various upper limits. Finally, we propose and evaluate virtual probabilistic guards that act as probabilistic guards without repeating probabilistically prevented steal attempts and they exhibit superior performance.

Evaluation of an MPI-Based Implementation of the Tascell Task-Parallel Language on Massively Parallel Systems

Tascell is a task parallel language that supports distributed memory environments. The conventional implementation of Tascell realizes inter-node communication with TCP/IP communication via Tascell servers. This implementation is suitable for dynamic addition of computation nodes and wide-area distributed environments. On the other hand, in supercomputer environments, TCP/IP may not be available for inter-node communication and there may be no appropriate places for deploying Tascell servers. In this study, we have developed a server-less implementation of Tascell that realizes inter-node communication with MPI communication in order to evaluate its performance on massively parallel systems. It performs well on four Xeon Phi coprocessors (with 456 workers) and the K computer, for instance, our 19-queens solver achieves a 4615-fold speedup relative to a serial implementation with 7168 workers on the K computer. Our server-less implementation realizes deadlock freedom, although it only requires the two-sided communication paradigm and the MPI_THREAD_FUNNELED support level. On Xeon Phi coprocessors, we compare our implementation with other implementations that employ TCP/IP or the MPI_THREAD_MULTIPLE support level.

Design and Implementation of a Java Bytecode Manipulation Library for Clojure

Recently, the Java Virtual Machine (JVM) has become widely used as a common execution platform for various applications. There is often the need to manipulate bytecodes at class-load time, particularly in application domains that demand dynamic modification of program behaviors. Whereas several bytecode manipulation tools for Java exist for implementing such behaviors, JVM is also the platform for various modern programming languages, and there is no need to write bytecode manipulation programs exclusively in Java. In this paper, we propose a novel bytecode manipulation library for Clojure, a Lisp dialect running on JVM. Our library is as expressive and flexible as ASM, the de facto standard bytecode manipulation tool in Java, while enabling more concise representation of typical manipulation cases. Our library works at class-load time as a series of rewrites of (parts of) the tree representing the target class file, basically in a similar way to Lisp’s macro system. However, our library differs from Lisp’s macro system in the following significant respects. First, instead of matching a single name against the first item of the target form (tree), our library matches a tree pattern against the target tree itself during macro expansion so that users can define rewriting rules for raw class files that cannot contain any special tags (names) for pattern matching. Furthermore, along with matching tree patterns, our library can extract any information from the static context easily and thus allows users to avoid cumbersome manual management of such information.

Practical implementation techniques of ambient calculus in conventional dynamic languages

This paper is about a concrete implementation of Safe Ambients (SA) in a conventional dynamic language that can be used for practical distributed programming. Although there have been several studies about the distributed implementation of SA, these implementations have involved the use of special-purpose abstract machines. Specifically, network communication mechanisms supporting secure packets and mobile codes are assumed to be embedded in the abstract machines at a high-level of communication abstraction. Furthermore, the interpretation of Safe Ambient programs by the abstract machine incurs significant runtime overheads. To overcome such problems, we propose a compiler from SA to the higher-order applied π-calculus, which has constructs for explicitly representing both cryptographic communication and code migration. The compiled code can be easily translated to the actual code in any dynamic programming language that supports the standard network communication and eval. Furthermore, by taking advantage of the low-level representation of the generated code, we discuss several security concerns related to the secure implementation of SA in public networks.

Abstract machines for safe ambients in wide-area and mobile networks

Recently, there have been several studies focusing on the implementation of process calculi with distribution and mobility. Among these, Pan and GcPan are distributed abstract machines for executing Safe Ambients, a variant of the Ambient calculus. However, in order to use them or to exploit their implementation techniques, we must assume all-to-all and permanent connectivity in the underlying network; this is inappropriate for most real-world wide-area and mobile networks, in which each private network is delimited by network boundaries and each mobile device may become disconnected at any moment. In this paper, we propose novel abstract machines PANmov, GcPANmov, and GcPANshift that can handle such network boundaries and mobile devices by using a special kind of agents called boundary forwarders. Especially in Gc-PAN shift, operations related to boundary forwarders improve the fault tolerance of user programs. Finally, we prove the correctness of the proposed machines by using weak barbed bisimulation.