|
|
||||
|
|
|||||
|
|
What is Rambler? [Chinese Version] Rambler is a general-purpose,
Object-Oriented
Operating System (OOOS) that is designed from scratch and intended
to provide a platform on which many new ideas can be tried. These ideas
are listed below:
With these ideas, Rambler
seeks to fulfill the following goals:
The objective of the Rambler
project is to advance the art of operating system design and implementation,
and therefore provide a research-oriented, experimental platform for
exploring potential requirements of computing technologies. So far,
Rambler is not yet a product though some efforts have been made on getting
it ready for customers. In the heart of Rambler, there is a simple protocol named Object Connecting Protocol (OCP), which organizes all computer resources, transient or persistent, local or distributed, objects or data, into a single and unified address system. This unified address system provides a system image that represents/maps all resources as objects so that programs can access these resources in a uniform manner. This uniform manner, with the object style, is termed uniform object access. Based on the concept of uniform object access, Rambler enables different programs to talk to each other easily, and so fulfills interoperability among different systems. More details about OCP can be found at the OCP page. To date, most existing operating systems use different access models to manage different types of computer resources. For example, they usually use memory addresses to reference transient data, file pathnames to reference persistent data, some symbolic names like domain names or Uniform Resource Locators (URLs) to reference web resources, and so on. Different access models lead to non-uniform treatments on resources of different lifetimes and locations, and bring programmers a lot of coding work. What is more, the non-uniform treatments suffer from the interoperability issue when we integrate different systems. To address this challenge and achieve a single, unified object space, Rambler introduces the following ideas: 1) Treats a memory address space (or called a process) as an object container, which allows objects to be exposed and so enables remote access. 2) Provides OCP-based object containers to store persistent objects so that applications can easily manipulate long-term resources. 3) Provides an OCP-based agent named File Mapper to map the hierarchical file system into a hierarchical object space. 4) Offers some OCP-based agents mapping other namespaces like the WWW into the single, unified object space. Persistence A new persistence model named Persistence By Location (PBL) is introduced and used to implement OCP-based object containers. Compared with the model of Persistence By Reachability (PBR), a popular persistence model proposed by M. P. Atkinson, PBL is easier to implement. About more details, please click the Persistence page. As an experimental operating system, Rambler seeks to support fine-grained parallelism with fine-grained, application-level threads. These threads are based on a new multitasking model named Preemptively Cooperative Multitasking (PCMT). PCMT makes a great improvement on reducing thread overhead, minimizing memory usage and increasing data locality. For example, thread creation of the PCMT system is up to 1500 times faster than that of a traditional operating system like Windows 2000. On thread switching, PCMT achieves tenfold improvement. The philosophy of PCMT is different from that of Time-sharing Multitasking. About more details, please click the Multitasking page. Efficient
IPC Mechanisms Inter Process Communication (IPC) is the key concern of Rambler. Rambler supports some efficient IPC mechanisms, comparable to the state-of-the-art implementations on L4 and Aegis. With these efficient IPC mechanisms, Rambler allows interrupt/exception handling to be implemented by applications, and so supports application-level device drivers. About more details, please click the IPC page. With the efficient IPC mechanisms, Rambler can be regarded as a kernelless design in a sense. This philosophy is similar with the concept of second-generation u-kernel, proposed by Jochen Liedtke, or the concept of Exo-kernel, proposed by Dawson R. Engler. In practice, Rambler abstracts the kernel as a collection of exposed device objects, and allows applications to manipulate these objects through methods and event handlers. Whereas, L4 and Aegis use function-level interfaces to abstract the kernel. About more details, please click the Architecture page. Purely
Object-Oriented Device Model Based on the IPC mechanisms, Rambler introduces a purely Object-Oriented device model, in which all devices are encapsulated as device objects. Most of these device objects can work at application level. Stage-Centric
User Interface Finally, a new-style user interface (UI) is under development for bringing users a more intimate use experience. This UI is named Stage-Centric User Interface (SCUI), which uses "stages" but not windows to create a more intimate relationship between users and computers. Within these "stages", users will experience in some friendly scenes like home, office, supermarket, and so on. A stage is like a maximized window, where the user sees only what he/she wants to see. That is, objects in other stages are at that time invisible for the user. Thus, the user can focus on the current stage, with the attention not distracted from some unrelated objects. In contrast, the traditional user interfaces, like overlapped windows, often distract the user's attention. A stage can help immerse the user in a scene and get the computer easier to use. Different from a conventional window, a stage can persist. That is, the visual presentation of a stage will not disappear even when the computer powers off. A user will often stay in the same stage unless he/she leaves the stage. Implementation: So far, Rambler has three versions: Rambler/i386, Rambler/8086, Rambler/i8051. Rambler is designed to support good portability, and permitted to move from one brand of computer to another with a minimum of code changes. It is because Rambler is written in an extension of C, called C-X. C-X uses C macros to implement some new keywords supporting OO programming. With this macro implementation, most C compilers can compile C-X code. Therefore, architectures with C support are applied to Rambler. More details about C-X can be found at the C-X page. Rambler/i386 is a full-blown operating system, which supports many features such as isolated address spaces, page protection, preemptive multitasking and multithreading, distributed access, PE image loading, loadable device drivers, FAT file system, and Graphical User Interface (GUI). Rambler GUI, built on object containers, is persistent. That is, GDI objects and GUI objects are allowed to persist. Rambler GUI is a purely OO GUI, which is based on a concept named Coupled Class, introduced by C-X. In contrast, most existing GUIs are not purely Object-Oriented since they are based on message passing. With message passing, programmers have to translate method calling into message-passing requests and vice versa. Whereas, Rambler programmers need not perform this translation since Rambler GUI dispatches events by method calling but not message passing. Therefore, Rambler programmers work in a purely OO environment. Based on the concept of Preemptively Cooperative Multitasking (PCMT) and the efficient IPC mechanisms, mentioned before, Rambler/i386 supports application-level interrupt/exception handling, application-level device drivers, and allows application-level pager to be implemented. More details of the features can be found at the Feature page. Rambler/8086 is a subset of Rambler/i386, where the paging component and the graphics support are removed. Rambler/8086 isolates programs in separated segments thus a program has an address space of up to 64K bytes. Rambler/i8051 is the minimal subset of Rambler/i386, where only the multithreading system and the related synchronization mechanisms are supported. It is probable to combine some lightweight object containers and OCP proxies into this version so that Rambler/i8051 can support orthogonal persistence and distributed access.
|
|
|||
|
Updated July 30, 2003 by Ge Liu
|
|||||
|
|
|||||
