Katsumi Maruyama

Optimization of program loading by object class clustering

It is typical that only a part of the whole program code is necessary for their successful execution. Partial program code loading optimizes the start-up delay and system resource consumption of the object-oriented programs by decomposing the program into a set of object class clusters as the units of incremental on-demand loading. Unfortunately, the lack of a systematic yet simple class clustering technique prohibits such an optimization approach. This paper presents a Java class clustering technique that is able to improve both the spatial locality and temporal affinity of an optimized program. The technique provides two clustering algorithms, resource-centric and performance-centric, to achieve different requirements in optimizations. Experimental results indicate that our algorithms are practically useful to both interactive and noninteractive programs. Among the tested Java programs, use of the performance-centric and resource-centric algorithms could significantly improve program loading, on average, by 2.9 and 2.2 times, respectively, faster than whole program loading. Both algorithms resulted in chances to economize system resources.

Proxy-and-hook: a Java-based distributed object caching

Scalability is a stringent requirement to every evolving information system. One of the key solutions to the scalability is caching. Most distributed object caching systems to date offer only coarse-grained mechanism in which an entire servant object graph is cached at once. Doing this minimizes cache miss frequency but imposes the long latency of cache miss resolution especially when the servant object graph is large or when the network load is high. Hence, it is preferable to compromise between this pair of performance metrics. Using fine-grained caching approach in which only necessary parts of the servant object graph are cached can satisfy both metrics at the same time. In this paper, we propose a framework that supports the incremental and automatic finegrained caching of Java objects at run time in transparent manner to client. This goal is efficiently achieved by means of proxy and hook mechanisms. Experimental results demonstrate that our framework incurs the latency of cache miss resolution by only one third of a remote invocation latency of Java RMI. Furthermore, the proposed framework can deliver cache hit performance closely to that of Java local invocations while outperforming Java RMI 1400 times.

Extensible distributed operating system for reliable control systems

Since most control systems software is hardware-related, real-time-oriented and complex, adaptable OSs which help program productivity and maintainability improvement are in strong demand.We are developing an adaptable and extensible OS based on micro-kernel and multi-server scheme: each server runs in a protected mode interacting only via messages, and could be added/extended/deleted easily. Since this OS is highly modularized, inter-process messaging overhead is a concern. Our implementation proved good efficiency and maintainability.

SOOM: Scalable Object-Oriented Middleware for Cooperative and Pervasive Computings

In the age of pervasive computing, ubiquitous collaboration has become an every-day life paradigm. Without an ideal computing infrastructure, issues with ubiquitous collaboration, such as network unreliability, platform heterogeneity, and clients resource constraints, are inevitable. The traditional replication scheme copes with network unreliability by replicating all the objects of a shared application together at once. This is, however, suitable for neither cooperative applications nor mobile computing devices. These problems can be naturally addressed by using a fine-grained replication scheme that enables a portion of the application objects to be replicated. This paper presents an object-oriented middleware that is capable of dynamically and transparently replicating remotely shared Java applications in a partially and on-demand incremental manner. It is also able to maintain various consistency semantics and enables the coexistence of fine-grained replications and conventional remote method invocations. Empirical results indicate several practical benefits of the middleware.

Cluster Replication for Distributed-Java-Object Caching

Object caching is a common feature in the scalable distributed object systems. Fine-grained replication optimizes the performance and resource utilization in object caching by enabling a remote object-oriented application to be partially and incrementally on-demand replicated in units of cluster. Despite these benefits, the lack of common and simple implementation framework makes the fine-grained replication scheme not extensively used. This paper proposes the novel frameworks for dynamic, transparent, partial and automatically incremental replication of distributed Java objects based on three techniques that are lazy-object creation, proxy and hook. One framework enables the fine-grained replication of server-side stateful in-memory application, and the other framework enables the fine-grained replication of server-side stateless in-memory application, client-side program, or standalone application. The experimental evaluation demonstrates that the efficiency in terms of response time of both frameworks are relatively practical to the extent of a local method invocation.

Design and Implementation of Remote Device Access Facility to Support Device Migration

Wireless connections between computers and devices introduce a new problem called device migration, which is the dynamic switching of a connection between a computer and a device. This paper describes a new system called the Network Extended Device Management System (NextD), which enables users to continue using a device even if device migration occurs. NextDs functions are device tracking, remote device access, seamless switching, and providing services over network boundaries. The system supports many device types, including a human interface device (HID) and audio and voice devices over both wireless and wired connections. We have implemented NextD on Linux. Experimental results showed that NextD is capable of supporting HIDs, and audio and voice devices, and that its processing time for a device migration is sufficient enough for actual use.

Development of an information retrieval system suitable for large-scale scholarly databases

The demand for full-fledged information retrieval services via the World Wide Web has grown as the Internet has evolved. However, existing information retrieval systems for the World Wide Web have various limitations in the search functions, and in structure and scale of databases. The information retrieval system described in this paper has been operating for a real information retrieval service, providing high-level search functions via a command line and a Web interface for large-scale scholarly databases in text form with complex structures. In this paper, the authors first describe an outline of and the design of the information retrieval functions, in particular the characteristic functions including set operations, thesaurus searches, hierarchical structure searches, and unified searches of multiple databases. Next, they describe the implementation technologies of the system focusing on the features of the search engine, the session control method, the handling of large-scale databases, and the structure of servers and processes. Then, the authors evaluate the current system based on the real operation, and finally discuss the future issues and the related researches.

Message communication facilities for distributed real-time systems based on concurrent object-oriented paradigm

With the development of high-speed communication services in public communication networks, there is a demand for the application of distributed processing based on the concurrent object-oriented paradigm to the communication service control software. This paper discusses message communication facilities with a high processing ability per unit time, a short processing time, and a high reliability that can be applied to communication service control. In the proposed facilities, a buffer with the fixed length used to store the message content is allocated to the shared space in each communication control node, which can be accessed from all user space. By passing the pointer to the buffer, communication processing is made efficient and management overhead is reduced. Reliability is improved by memory that checks unauthorized access to the message buffer in the shared space. In order to realize the efficient communication of large-scale messages, outline message communication is supported, using the page map switching and copy-on-write control. In internode communication, the internode communication control object multiplexes and processes the messages by the connection set between the nodes. Between the internode communication control object and the transmission/reception object, the number of copies is reduced by passing the pointer to the buffer.

Design and overhead estimation of device driver process

Conventional operating systems used to have device drivers as kernel modules or embedded objects. Therefore, maturity of a device driver influences on the reliability of the entire system. There is a method for constructing device driver as an user process for improving the reliability. Device driver process enhances the reliability of the operating system. However, device driver process has large overhead. In this paper, we propose a method for constructing device drivers process and evaluating these overhead. Also, this paper shows that the overhead of device driver process can be estimated.

Design and Implementation of Multi-Platform Infrastructure of Extensible Network Functions

Dynamic and flexible composition of higher-level network services, such as security, QoS, or adaptive services are required by future network applications. However, the development of such extensible applications makes them rather complex. In addition, many old applications, which do not support such services, would stick to be used. To solve these problems, we propose a generic and multi-platform infrastructure called FreeNA1 that extends existing applications by transparently incorporating the services to them. FreeNA offers abstract interfaces such that users can insert the services into each packet flow based on a configuration file. In this paper, we describe the design and implementation of FreeNA including a functionality comparison with relevant systems, and our performance evaluation results. The result shows that FreeNA offers finer configurability, composability, and usability and can be used widely than other similar systems. We also show that overhead of transparent service insertion is about 1-2% at a maximum compared to a method of inserting such services into applications directly.