This paper describes a novel approach to object serialization in remote method invocation (RMI). Object serialization transforms objects' representations between heterogeneous platforms. Efficient serialization is primary concern in RMI because the conventional approaches incur large runtime overheads. The approach described specializes a serializing routine dynamically according to a receiver's platform, and this routine converts the sender's in-memory representations of objects directly into the receiver's in-memory representations. This approach simplifies the process of RMI: the receiver can access the passed objects immediately without any data copies and data conversions. A new platform can join the existing community of senders and receivers because a specialized routine for the platform is generated as needed. Experimental results show that significant performance gains are obtained by this approach. The prototype implementation of this approach was 1.9-3.0 times faster than Sun XDR, and the time needed for generating a specialized routine was only 0.6 msec.

Mobile code is an emerging paradigm of distributed computing. It roams over a network, is linked with an application, and runs as a part of an application. In the case of Web browsers, it is commonplace to download a mobile code, called a plug-in, from a truly open network such as the Internet. Owing to the anonymity of an open network, the mobile code may be malicious; thus, it is important to protect local computing resources from attacks by malicious code. We have developed a kernel that supports fine-grained protection domains that preclude mobile code from making unauthorized accesses to the local resources. The developed scheme provides a novel mechanism, called a multi-protection page table, of virtual memory for creating fine-grained protection domains. The multi-protection page table enables efficient cross-domain calls, whereas it provides protection. Experimental results show that the developed scheme incurs only a 5.9% execution overhead even if cross domain calls occur 30000 times per second.

In cooperative applications such as group CAD and group software development systems, multiple processes communicate with each other by sharing complex data structures consisting of nested structures and pointers. Although the sharing of complex data structures in the distributed environment is achieved through the technology of distributed shared memory, a single cache coherence protocol cannot efficiently serve various access patterns generated by cooperative applications. This paper describes a framework of protocol customization for the sharing of volatile and experiment data in cooperative applications. The major obstacle in user-level customization of protocols is that there are too many states and state transitions in an unabstracted protocol to enable average users to describe them. The protocol customization system (PCS) in this paper solves this problem by introducing a high-level model for protocol description that abstracts away non-determinism of messages, synchronization among hosts, and local paging actions. Consequently, users can define with brief descriptions cache coherence protocols adapted for particular applications. The ability of PCS to describe different kinds of protocols is examined in this paper and its run-time performance and memory usages are investigated.

Remote procedure call (RPC) systems have been proven to be a practical basis for building distributed applications. The RPC technique abstracts a typical communication pattern to an ordinary procedure call. Compared with an ordinary procedure call, however, the conventional RPC technique has one evident restriction; pointers (addresses) cannot be passed to remote procedures without the explicit and nontrivial programming effort. This paper presents a method that eliminates this restriction. The method enables transparent treatment of pointers in RPC by combining three key techniques: virtual memory manipulation, pointer swizzling, and coherency protocol. The experiments performed using an implementation of the method show that the method provides performance that is scalable to the access ratio of the remotely referenced data.>

The authors propose an information management system providing distribution and persistency. By separating context from virtual address space, the system has a unified approach for both distribution and persistency. The former is achieved by moving contents between sites and the latter by moving contents between virtual address space and persistent storage. Contents include any information including data, program, and even the state of execution of a program. Contents are stored persistently in a logical space termed the distributed shared repository (DSR). A programming model for the DSR is proposed. Using the model, persistency, fine-grain mobility of information, and the passing of various distributed parameters can be obtained. The implementation anti experimental performance of the system are also presented.>

An operating system-level mechanism for memory management that enables processes to freely share and transfer arbitrary data structures in both the primary and secondary storage is presented. By using wide address spaces provided by 64-b processors, the proposed system structures the address space of each process as a set of hierarchical 'regions' of virtual memory pages. In order to avoid possible location conflicts among regions, the system restructures the hierarchy when regions are shared or transferred among processes.>

Many recent complex object database systems support the concepts of object identity and object identifier. Following an object identifier to access the referenced object is called navigation operation and is an essential operation in dealing with complex objects. Navigation operation is a difficult operation to implement efficiently since every navigation operation inherently causes one disk access operation. A scheme to notably accelerate the navigation operation among a sea of complex objects, by increasing the effective number of objects in one disk page is proposed. The main concept of the presented technique is threefold. The first idea is to store a cached value within a complex object that is referencing another complex object. The second is that when the referenced object is to be updated the update propagation is delayed until the time when the cached value is referenced. The third is to utilize a hashed table on main memory to efficiently validate the consistency between the cached values and the original values.>

The mechanisms for executing concurrent applications proposed so far fall into one of three groups: processes, kernel-level threads, and user-level threads. Each of them is insufficient in terms of either parallelism, the flexibility to combine separately developed programs at run-time, or costs of operations such as creation, switching, and destruction. A thread facility in the XERO operating system overcomes this problem and provides a uniform framework for executing concurrent applications. To achieve parallelism of threads, the flexibility to combine separately developed programs at run-time, and fast thread operations, the operating system kernel and a thread management module in a user address space manage threads cooperatively. The authors implemented the cooperative thread management mechanism and measured its performance to examine the effectiveness of the approach.>

A parallel processing scheme and software architecture of SMASH, a parallel processing system for supporting a wide variety of database applications is presented. The main feature of this system is that functional programming concepts are applied to define new database operations and data types and to exploit parallelism inherent in an arbitrary set of database operations. A primitive set (SMASH primitive set) of the software architecture is presented that defines an abstract machine interface between high-level database languages and general-purpose hardware systems for parallel processing. The primitive set is used to implement functional computation systems for executing arbitrary database operations in parallel. A previously proposed stream-oriented parallel processing scheme for relational database operations is extended to support more complex database operations which deal with complex data structures. Several experimental results of parallel processing for database operations are shown to clarify feasibility of the proposed architecture.>

The authors describe a way of noticeably reducing the description cost of database operations executed in distributed computing environments through the design of a declarative language to describe database operations, the development of program transformation techniques to improve efficiency at execution time, and the clarification of prerequisites to execute the programs in distributed computing environments. With the language, database operations are described as functions which manipulate streams. To describe stream manipulation at a higher level, the language SPL (Set Programming Language) is based on mathematical comprehensive notation for sets (ZF expressions). With this language, database operation implementors need not specify any communication primitives; a language processing system automatically translates the programs into procedural programs which include communication primitives.>

Several effective algorithms are presented for the optimal allocation of computer resources in a proposed stream-oriented parallel-processing scheme for database operations. These algorithms can be utilized to obtain the optimal allocation of memory resources for every type of query in sequential-processing environments, parallel-processing environments with shared-memory multiprocessors, and distributed-processing environments. The computation complexities of the proposed algorithms are analyzed and used to clarify the effectiveness of those algorithms.>

It is known that the locality of reference of a program can be improved by restructuring it. One approach for program restructuring is to rearrange the order of relocatable program sectors and to repackage those sectors of a program, that are needed within a relatively short time of one another, into the same virtual page. This approach needs no reprogramming of the source program. However, microscopic analysis of the internal structure of repackaged sectors often shows the existence of sectors only few portions of which are actually referenced while the sectors are in use.

Programs tend to reference pages unequally and cluster references to certain pages in short time intervals. These properties depend on the tendency of program locality references and program phase transitions. The significant effects on system performances arise from the phase transition behavior. However, the phase transition behavior of programs has been rarely taken into account in the analysis of memory management strategies. This paper investigates the effect of the phase transition behavior on the total system performance. For this purpose, an elaborate simulation model of the multiprogrammed memory management has been developed for a time-sharing environment. The working set strategy and the local LRU strategy are modeled in the simulation system. A simple phase transition model and the simple LRU stack model are used as a program paging behavior model. Both cases are analyzed where (1) locality variations exist and phase transitions occur, and (2) only locality variations exist and phase transitions do not occur. The relations between the phase transition rate and the system performance are found in the above memory management strategies.