Yasuhiko Yokote

The muse object architecture: a new operating system structuring concept

A next generation operating system should accommodate an ultra large-scale, open, self-advancing, and distributed environment. This environment is dynamic and versatile in nature. In it, an unlimited number of objects, ranging from fine to coarse-grained, are emerging, vanishing, evolving, and being replaced; computers of various processing capacities are dynamically connected and disconnected to networks; systems can optimize object execution by automatically detecting the users and/or programmers requirements. In this paper, we investigate several structuring concepts in existing operating systems. These structuring concepts include layered structuring, hierarchical structuring, policy/mechanism separation, collective kernel structuring, object-based structuring, open operating system structuring, virtual machine structuring, and proxy structuring.We adjudge that these structuring concepts are not sufficient to support the environment described above because they lack the abilities to handle dynamic system behavior and transparency and to control dependency. Thus, we propose a new operating system structuring concept which we call the Muse object architecture. In this architecture, an object is a single abstraction of a computing resource in the system. Each object has a group of meta-objects which provide an execution environment. These meta-objects constitute a meta-space which is represented within the meta-hierarchy. An object is causally connected with its meta-objects: the internal structure of an object is represented by meta-objects; an object can make a request of meta-computing; a meta-object can reflect the results of meta-computing to its object. We discuss object/meta-object separation, the meta-hierarchy, and reflective computing of the architecture. We then compare the Muse object architecture with the existing structuring concepts.We also demonstrate that the Muse object architecture is suitable for structuring future operating systems by presenting several system services of the Muse operating system such as class systems, a real-time scheduler with hierarchical policies, and free-grained objects management. Class systems facilitate programming by several classes of programming languages. A real-time scheduler with hierarchical policies can meet various types of real-time constraints presented by applications. Free-grained objects management can suit the object granularity to the application, so that an object is efficiently managed according to its granularity. Finally, we present the implementation of the Muse operating system which is designed based on the Muse object architecture. Version 0.3 of the Muse kernel is running on the MC68030 based Sony NEWS workstations.

Experience and evolution of concurrent Smalltalk

ConcurrentSmalltalk is an object-oriented concurrent programming language/system which has been running since late 1985. ConcurrentSmalltalk has the following features: Upper-compatibility with Smalltalk-80. Asynchronous method calls and CBox objects yield concurrency. Atomic objects have the property of running one at a time so that it can serialize the many requests sent to it. Through experience in writing programs, some disadvantages have become apparent related to concurrency control and the behavior of a block context. In this paper, these issues are re-examined in detail, and then the evolution of the solutions for overcoming these shortcomings is described along with the model of computation in ConcurrentSmalltalk. New features are explained with an example program. The implementation of the ConcurrentSmalltalk virtual machine is also presented along with the evaluation of it.

The design and implementation of Concurrent Smalltalk

ConcurrentSmalltalk is a programming language/system which incorporates the facilities of concurrent programming in Smalltalk-80 1 . 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.

Reflective object management in the Muse operating system

Presents reflective object management as a set of facilities for handling objects with various properties such as grain-size and lifespan efficiently and naturally. The facilities are classes, variable-length identifiers, memory management, and efficient communication between objects. These facilities are based on the Muse object architecture and implemented on the Muse operating system. Reflective object management can define objects in such a way that there is no distinction between objects supported by operating systems and objects supported by programming languages in a multi-lingual environment. The authors also show their preliminary evaluation of the implementation.<<ETX>>

Naming and addressing of objects without unique identifiers

The hierarchical naming scheme, a method for naming and addressing shared objects in large-scale distributed computer systems, is described. The scheme constructs global identifications (IDs) and addresses from locally unique ones. The IDs have relative representations that are translated if they are transmitted among naming contexts. This ensures uniqueness of IDs while preserving efficiency and availability. Methods that make the scheme suitable for mobile naming contexts and dynamic reconfiguration of networks and systems are reviewed. Implementation issues and solutions are presented.<<ETX>>

SCONE: using concurrent objects for low-level operating system programming

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.

Separation of concerns and operating systems for highly heterogeneous distributed computing

Highly heterogeneous distributed computing applications present a tremendous challenge for operating system implementors. These applications present an extremely wide range of demands and must run in an extremely wide range of environments. In order to recognize the wide range of environments, without losing the benefits of traditional modularity, we propose a separation of concerns approach to the design of operating systems for this domain. In this paper, we first discuss importance of separation of concerns particularly in highly heterogeneous distributed computing. The discussion is based on the issues we encounter when programming of distributed applications such as for networked copiers, settop boxes for cablenets, networked analyzers/oscilloscopes, or palmtop computers. We then propose a way to solve them without sacrifice of performance. This paper contributes to this workshop in the sense that it addresses frustrations of programmers, particularly of embedded systems, and demonstrates our technology to solve their frustration from an operating systems perspective.

Unification of active and passive objects in an object-oriented operating system

This paper proposes the unification of active and passive objects in object-oriented operating systems. With such a unification, programmers can concentrate on programming an algorithm without having to consider how objects are used and executed. Also, all objects can be migrated in a distributed system. To achieve this unification, meta level scheduling control is introduced, and the scheduling policy is determined at object creation time. We named this system Cognac. In Cognac, the execution domain of an object is an object cluster, in which some metaobjects control the execution of member objects at run-time. The scheduler metaobject manages method invocation and the status of its member objects. Since all objects attributes are managed by metaobjects, mutual exclusion is guaranteed.<<ETX>>

The new structure of an operating system: the Apertos approach

This paper proposes the new structure for an operating system in an open and mobile computing environment. The structure is characterized by object/metaobject separation, metahierarchy, and object migration. We then present the practical implementation of the Apertos operating system based on the proposed structure, where reflectors are introduced for metaobject programming and MetaCore for providing the common primitives. We also present some measurement results of the Apertos operating system.

Constructing IPv6 protocol stack on Apertos

The paper discusses the implementation of IPv6 protocol stack on the top of the reflective object oriented operating system, Apertos. The Internet community is working on a transition from IPv4 to a new Internet protocol, IPv6. Though IPv6 has good design choices, IPv6 is much more complex and harder to implement than IPv4. To reduce complexity and ease the implementation, the paper introduces a reflective OO method to implement protocol handlers. This can reduce the hurdles for implementation and make the software update cost cheaper.