An Approach to Portable Distributed Systems Dennis M. Ritchie
Bell Labs, Lucent Technologies
dmr@bell-labs.com

http://www.lucent.com/inferno (business) http://www.cs.bell-labs.com/~dmr (personal)


What is Portability?



Definition: the ability of the same program to work in a variety of environments

Advantage to users: Ability to use a familiar or useful tool everywhere Escape from single-suppliers

Advantage to suppliers: Engineer an application only once


Stages of Portability



Standardized Languages (Cobol, Fortran, C)

Standardized, Portable Operating Systems (Unix/Posix)

Supplier-generated standards (PC-compatible hardware, MS software)


Today's Software World



Fragmented software base MS Windows, Macintosh, Unix (PC and workstations) Mainframe systems (MVS and successors) Tiny systems (QNX, VxWorks, Forth, etc.)

Complex networks Internet Dial-up ISDN/Frame Relay/ATM/xDSL etc. Intranets


Interesting non-desktop computing environments



Good hardware is becoming cheap (e.g. Sony Playstation is US$200)

System software for set-tops, specialized devices, phone switching remains `primitive'

How can we broaden the availability of interesting services without re-engineering the programs for every environment?


New programming languages



New languages and their implementations improve portability:

Define a virtual machine and and a programming language Compile applications written in this language into virtual machine's instructions Interpret these instructions on real hardware

This can provide real portability across hardware

Does this provide the whole solution?


Java and associated technology



Java: new language based on C++ ­ restricts pointers for safety ­ defines basic types completely ­ includes libraries for useful operations like graphics

Achieved notice for WWW applets: download program, run locally

Plans for future JavaOS, Java hardware; Microsoft, Netscape interest


New Levels of Abstraction



Technology should now supply not only Virtual Machine but also Virtual Operating System Virtual Network Interface

Can we provide a complete environment for distributed, very portable applications?


Styles of Distributed Systems

­ explicit communication over channels (e.g. sockets)

­ remote procedure calls, sometimes hidden automatically (e.g. OSF DCE, ANSA)

­ globally shared memory (e.g. SHRIMP, GSM)

­ shared resources, like files (e.g. Plan 9, Inferno)


Inferno

Inferno provides

A distributed operating system ­that operates either standalone on economical hardware ­or as an application under conventional systems (MS Windows, Unix)

An identical application interface everywhere

Transparent sharing of resources among instances

Security and control over resource sharing


Inferno Components



The Inferno Operating System (file system, threads, basic services)

The Limbo Language (C-based, but type-safe and adding new types)

Interpreter and on-the-fly compiler for Limbo

Built-in, transparent access to networks


Inferno Operating System



Runs ­ stand-alone on small hardware ­ hosted as an application under standard operating systems

Identical environment is supplied everywhere


Stand-alone Inferno Arrangement





Hosted Inferno Arrangement





Key Technical Ideas



All resources are represented as files (real files, devices, servers)

Files are shared between clients and servers-thus, resources are shared


Implications



Same application can run either on client or server, depending on resources available

Applications are independent of hardware and of underlying operating system - stand-alone on hardware (set-top box, network computer, game console) - Windows 95 & NT, Unix, Linux

Applications are independent of networks through abstraction of network services


Peer-to-peer approach: video



Application runs on client


Peer-to-peer approach: mail



Application runs on server


Gathering File Resources





Gathering File Resources 2





Limbo Programming Language



C-like language, but incorporating ­ modular programming ­ communication channels for distributed programming ­ abstract data types, strings, other new types

Multi-threaded, with process creation and inter-process communication

Automatic "instant-free" garbage collection ­ all resources (windows, channels) destroyed when they become unused

Portable, machine-independent ­ data types exactly defined ­ object code identical across hardware architectures


Inferno summary



Inferno is a complete operating system with rich resources

It runs either natively, on modest hardware (Intel x86, MIPS, AMD29K, ARM, M68K) with small memory (<1 MByte)

or as a subsystem under MS/Windows, Unix, Linux

Applications are identical everywhere and share distributed resources among all these environments

Application development in either Limbo or Java


Grand summary



­ Advancing technology makes portability and universality of programs more possible

­ Hardware and software suppliers don't necessarily find real portability to their advantage

­ Users need to continue to demand solutions that work across a broad range of platforms, from many different suppliers


Inferno is now a Commercial Business



­ Business Unit launched 5/96

­ Release 1.0 available 3/97

­ Release 2.0 available 4Q/97

­ Over 70 customers to date




Copyright © 1998 Lucent Technologies Inc. All rights reserved.