Tatsurou Sekiguchi

Bytecode Transformation for Portable Thread Migration in Java

This paper proposes a Java bytecode transformation algorithm for realizing transparent thread migration in a portable and efficient manner. In contrast to previous studies, our approach does not need extended virtual machines nor source code of target programs. The whole state of stack frames is saved, and then restored at a remote site. To accomplish this goal, a type system for Java bytecode is used to correctly determine valid frame variables and valid entries in the operand stack. A target program is transformed based on the type information into a form so that it can perform transparent thread migration. We have also measured execution efficiency of transformed programs and growth in bytecode size, and obtained better results compared to previous studies.

A Simple Extension of Java Language for Controllable Transparent Migration and Its Portable Implementation

A scheme has been developed that enables a Java program to be migrated across computers while preserving its execution state, such as the values of local variables and the dynamic extents of try-and-catch blocks. This scheme provides the programmer with flexible control of migration, including transparent migration. It is based on source-code-level transformation. The translator takes as input code a Java program written in a Java language extended with language constructs for migration, and outputs pure Java source code that uses JavaRMI. The translated code can run on any Java interpreter and can be compiled by any just-in-time compiler. We have measured some execution performance for several application programs, and found that the translated programs are only about 20% slower than the original programs. Because migration is completely controlled by using only three language constructs added to the Java language (go, undock and migratory), the programmer can write programs to be migrated easily and succinctly. Our system is available in the public domain.

Fail-Safe ANSI-C Compiler: An Approach to Making C Programs Secure Progress Report

It is well known that programs written in C are apt to suffer from nasty errors due to dangling pointers and/or buffer overflow. In particular, such errors in Internet servers are often exploited by malicious attackers to “crack” an entire system, which becomes even social problems nowadays. Nevertheless, it is yet unrealistic to throw away the C language at once because of legacy programs and legacy programmers. To alleviate this dilemma, many approaches to safe implementations of the C language-such as Safe C and CCured—have been proposed and implemented. To our knowledge, however, none of them support all the features of the ANSI C standard and prevent all unsafe operations. (By unsafe operations, we mean any operation that leads to “undefined behavior”, such as array boundary overrun and dereference of a pointer in a wrong type.) This paper describes a memory-safe implementation of the full ANSI C language. Our implementation detects and disallows all unsafe operations, yet conforming to the full ANSI C standard (including casts and unions) and even supporting many “dirty tricks” common in programs beyond ANSI C. This is achieved using sophisticated representations of pointers (and integers) that contain dynamic type and size information. We also devise several techniques—both compile-time and runtime—to reduce the overhead of runtime checks.

A calculus with code mobility

Mobile agent systems have attracted a great deal of attention in recent years. Various agent systems have been proposed and implemented so far. But their systems are usually equipped with their own features that are hard to simulate by other systems even with respect to agent movement mechanisms. Therefore, a generalized framework that can describe various mechanisms in a formal manner is strongly needed. This paper proposes a simple and flexible calculus λdist, which provides a neat tool for describing movement mechanisms of code, data and execution states.

Portable implementation of continuation operators in imperative languages by exception handling

This paper describes a scheme of manipulating (partial) continuations in imperative languages such as Java and C++ in a portable manner, where the portability means that this scheme does not depend on structure of the native stack frame nor implementation of virtual machines and runtime systems. Exception handling plays a significant role in this scheme to reduce overheads. The scheme is based on program transformation, but in contrast to CPS transformation, our scheme preserves the call graph of the original program. This scheme has two important applications: transparent migration in mobile computation and checkpointing in a highly reliable system. The former technology enables running computations to move to a remote computer, while the latter one enables running computations to be saved into storages.

A Complete Type Inference System for Subtyped Recursive Types

Since record polymorphism is one of essential factors for object-oriented languages, various approaches to incorporate record polymorphism into type systems have been proposed to lay the foundation for object-oriented languages. Recursive types, which are essentially types of lists or trees, are major programming tools. In object-oriented languages, a pseudo variable “self” has a recursive type, which requires that type systems be able to treat recursive types. The purpose of this paper is to provide a type system and its type inference algorithm which can handle subtyping, recursive types and parametric polymorphism without any kind of type declaration or unnatural restrictions. We prove soundness and completeness of the type inference algorithm. Our system integrates subtyping and recursive types into Damas and Milners type system and preserves important properties such as existence of principal typing. The basic idea is that we consider a type as a regular tree.

Application of an effective geometric clustering method to the color quantization problem

Geometric clustering is the grouping of similar objects in some high dimensional space with an metric defined appropriately for similarity. The color quantization problem in computer graphics is a geometric clustering problem in the three-dimensional space, typically the RGB-space with Euclidean or LI metric, and there have been proposed many methods [1, 6, 9]. The geometric clustering problem for a set S of n points ~i in the d-dimensional space such that each cluster of points has its representative point, not necessarily in S, is stated in general as a problem of finding a k-clustering of S into Sj (j = 1,..., k) minimizing

Implementing an applet system without fixing virtual‐machine designs

An applet is program code which is downloaded dynamically from a server on the World Wide Web and which can be executed while maintaining security on the client side. The majority of applet systems at present, as represented by the Java Applet, implement the applets using virtual machine code which is independent of computer architecture. This is advantageous in terms of installation and use in different machine environments. Because virtual machine code is associated with execution by an interpreter or conversion to native code, the design of the virtual machine code greatly impacts performance during execution. Normally, however, representation of virtual machine code is fixed for each applet system and cannot be altered. The authors focused on the independence of virtual machine code and implementing an applet execution environment which is independent of the design of virtual machine code by making the Just-In-Time (JIT) compiler which converts virtual machine code to native code mobile. In this approach, native code conversion modules which are appropriate for the virtual machine code being used in the applet description are downloaded dynamically. In addition, this applet execution environment provides monitoring functions during applet execution so that a native code applet generated from any virtual machine code can be executed safely. The applet execution monitoring mechanism allows for the programming of system control policies for users, and allows for flexible applet execution control for various levels of monitoring. In this paper, the authors describe an implementation using their newly designed virtual machine code representation in both the SPARC and Intel x86 architecture environments, as well as experiments using this implementation.