Modern computer systems are increasing in complexity, spread, and scale in order to meet the diverse and sophisticated needs of the users. In the development of these systems, we inevitably use legacy codes and off-the shelf software as black box software in order to shorten the development time and lower the development cost. These systems are often connected via a network to utilize services provided by other systems, whereas services and network performance may change while in operation. We often need to change the specification and implementation of a system due to the changes of environments and users' requirements. In addition, threats caused by viruses and unauthorized accesses have to be properly removed. Therefore, modern computer systems inherently involve incompleteness of specifications and implementations and uncertainty of environments and requirements.

The processes of adaptation in natural organisms consist of two complementary phases: learning, occurring within each individual's lifetime, and evolution, occurring over successive generations of the population. In this article, we study the relationship between learning and evolution in a simple abstract model, where neural networks capable of learning are evolved using genetic algorithms (GAs). Individuals try to maximize their life energy by learning certain rules that distinguish between two groups of materials: food and poison. The connective weights of individuals' neural networks undergo modification, that is, certain characters will be acquired, through their lifetime learning. By setting various rates for the heritability of acquired characters, which is a motive force of Lamarckian evolution, we observe adaptational processes of populations over successive generations. Paying particular attention to behaviors under changing environments, we show the following results. Populations with lower rates of heritability not only show more stable behavior against environmental changes, but also maintain greater adaptability with respect to such changing environments. Consequently, the population with zero heritability, that is, the Darwinian population, attains the highest level of adaptation to dynamic environments.

Multimedia applications must incorporate real-time task processing over networks. In most cases, there are many receivers for each data stream. Thus, a multicast resource reservation protocol for ensuring timing constraints over the network is required. In this paper, a real-time multicast protocol, called RtMP (Real-time Multicast Protocol) is presented. RtMP provides flexible connection establishment by integrating the multicast routing mechanism and the resource reservation mechanism by defining a generic interface between them. RtMP also provides a mechanism that guarantees service level of established connections according to the sender list. An implementation of RtMP on the real-time OS RT-Mach is also described along with performance evaluation. Finally, a comparison of RtMP with other real-time multicast protocols is given and its efficiency is shown.

In this paper, we describe the design and implementation of an extended concurrent object model for distributed and multiuser systems called the Multiversion Concurrent Object (MCO). In this model, an object executes multiple methods concurrently within itself, but is handled as a concurrent object. Each MCO makes a copy of its own state, called a version, for executing a method that is not interleaved with other similar copies during execution. The results of concurrent execution are merged at termination of each method. The MCO increases programmability, because it does not require any synchronization statements inside its methods. Using this model for shared objects, we can construct a system in which each user can work freely without being negatively impacted by others. Finally, a prototype implementation of MCO and performance evaluations are presented.

This paper proposes a methodology for making low-level system code of operating systems be replaceable at runtime. Our approach is to use concurrent objects as a basic programming unit for low-level system programs. To realize the different need for each type of system code and to execute these concurrent objects sufficiently efficient, we use a combination of dedicated system service layers and other implementation techniques. System service layers provide the most suitable primitive operations for each concurrent object. Under our programming model for low-level system code, which we call SCONE, it is possible to program low-level system code without hazardous operations such as explicit synchronization, direct scheduler manipulation, etc. We present the implementation of our methodology on the Apertos operating system and demonstrate its efficiency with performance evaluation.

Many applications in distributed systems consist of a set of processes over multiple network nodes. Traditionally, the communication to a set of processes or a process group has been implemented by sending unicast messages to each member of the group causing unnecessary network traffic. In this paper, we present the design and implementation of the Process Group Management Protocol (PGMP) which provides efficient and reliable process group communication using IP multicast. We also present problems faced with the design of IP multicast through our experience with PGMP and propose a network architecture that provides efficient and reliable process group communication best suited for distributed applications.>

In order to guarantee real-time services in a network architecture, resource reservation schemes seem most effective. In such protocols, dynamic protocol parameter control is necessary to support balanced quality of service for applications which are allocated the resources of the system, but timeliness of protocol control negotiation has never been emphasized.We have proposed RtP, a general purpose real-time protocol which supports virtual channels used exclusively for control information processing in an internet-work. However, our first proposal did not provide an effective mechanism for preallocating control channels thus presenting an overhead in gateways.This paper presents a simple new protocol for managing control reservations on each subnetwork of an internet; it is called the Virtual Control Setup Protocol (VCSP). It provides an interface between the network layer and the data link layer for ensuring the timeliness of control information. The effectiveness of VCSP is investigated and demonstrated by a prototype implementation.

The design and implementation of the Virtual Internet Protocol (VIP) are described. The VIP was implemented by modifying an operating system kernel based on 4.3BSD. The overhead of VIP is compared to that of IP. Measured results indicate that VIP can achieve host migration transparency in the Internet with negligible overhead.>

We investigate a formal model for reasoning about real-time object-oriented computations.The model is an extension of CCS with the notion of time, called RtCCS(Real-time Calculus of Communication Systems).It can naturally model real-time concurrent objects as communicating processes and represent the timed properties of objects.We define two timed equivalences based on CCS's bisimulation and derive algebraic laws for reasoning about real-time processes.The equivalences provide a formal framework for analyzing the behavior and timing of real-time computations.Also, we define a sound and complete equational proof system for finite processes.Some examples in RtCCS are shown in order to demonstrate its usefulness.

The continued expansion of computer networks and the miniaturization of computers increase the desire to use one's computer in a consistent computational environment, regardless of location and time.In this situation, host migration transparency is very important.This paper introduces a new network architecture which provides host migration transparency in large interconnected networks and proposes a protocol based on the propagating cache method.We introduce the concept virtual network and divide the conventional network layer into two sublayers to realize host migration transparency.Virtual Internet Protocol, or VIP for short, is derived from DARPA-IP as an example of the architecture.We estimate the overhead of VIP.Host migration transparency can be realized without significant processing and traffic overhead.This architecture also preserves host migration transparency across virtual circuits in radio networks.

ConcurrentSmalltalk is an object-oriented concurrent programming language/system which has been running since late 1985. ConcurrentSmalltalk has the following features:

Orient84/K is an object oriented concurrent programming language for describing knowledge systems. In Orient84/K, an object is composed of the behavior part, the knowledge-base part, and the monitor part, in order to provide object-oriented, logic-based, demon-oriented, and concurrent-programming paradigms in the object framework. Every object is capable of concurrent execution in Orient84/K.

ConcurrentSmalltalk is a programming language/system which incorporates the facilities of concurrent programming in Smalltalk-801. Such facilities are realized by providing concurrent constructs and atomic objects. This paper first gives an outline of ConcurrentSmalltalk. Then, the design of ConcurrentSmalltalk is described. The implementation of ConcurrentSmalltalk is presented in detail.

In this paper, methods for displaying solid objects represented by a three-dimensional array of voxels are described. The Linear Interpolating Projection Method is proposed as a method by which such objects can be projected onto the screen in perspective. In order to shade the projected images, the Depth only Shading Method is proposed. These methods are so simple that three-dimensional perspective images with shading can be produced rapidly. This paper also describes an architecture based on these methods for generating animation interactively.

This paper proposes a new object model, called the distributed object model, wherein the model is unified as a protection unit, as a method of data abstraction, and as a computational unit, so as to realize reliable, maintainable, and secure systems. An object oriented architecture called ZOOM is designed based on this object model. A software simulator and cross assembler for this architecture have been implemented. The feasibility and performance of the architecture are discussed according to program sizes and estimated hardware size and execution speed.

This paper discusses the concept of the working set for data-flow machines in order to establish one of the criteria for the realization of cost effective data-flow machines. The characteristics of program execution in conventional machines and data-flow machines are compared. Then, a definition of the working set for data-flow machines is proposed, based on the simultaneity of execution and the principle of locality. Several segmentation, fetch, and removal policies are described. Evaluation is made in terms of feasibility, efficiency, and performance, through computer simulations.

An important strategy to enhance both the reliability and performance of high-level program execution is to have computer architecture provided with the mechanisms, such as i) to address information in a unified manner regardless of the structure and/or of the size of information objects, and ii) to dynamically check the eligibility of information accesses. This paper firstly gives the foundation for such abstraction mechanisms through examining the semantic structure of information objects. Information is hereby formalized as a set of relations between an access and the entity that is accessed. The relations are hierarchically classified into four categories, each of which associates to the corresponding level of abstraction. Object-oriented architecture which reflects this hierarchical classification directly in its storage organization is then proposed. This architecture is called the abstract storage architecture. Issues in designing the abstract storage architecture are described. The effectiveness of such architecture is concluded from the view points of both the implementation of existing high-level languages and the design of future high-level languages.

This paper describes a microprogram optimization technique called MORIF. The technique is general enough to treat machines whose microoperations require multiple machine cycles on a subcycle basis. The technique is applicable to microinstruction formats varying from horizontal to partially encoded, and to vertical. The technique includes global optimization algorithms for microprograms containing loops and recursive subroutines. Evaluation of the technique is performed from both the viewpoints of the complexity of the devised algorithms, and efficiency of generated object microcodes.

KMP/II is a multiprocessor system designed to work as a multi-lingual high level language computer in a distributed processing environment. The multiprocessor system is composed of up to 15 dynamically microprogrammable LSI processors. One processor executes OS functions. Another processor executes I/O functions. All the rest execute user programs as high level language job processors, emulating individual high level language. Allocation of high level language emulators to processors changes dynamically depending upon the load of user jobs in terms of the languages. Behaviour of processes of user jobs written in high level languages and system jobs are measured through monitoring typical minicomputers. Hardware characteristics of the system are also collected by measuring the prototype system. Simulations are done by a computer using the data obtained through the above measurements to determine the process scheduling and processor assignment algorithm and to prove the effectiveness of the design concept.