Grasshopper Grasshopper

Overview

Grasshoppers (An introduction) Orthogonal Persistence Containers Loci Container mapping Capabilities Data Management Summary Sources

What is ?

Why ?

Grasshopper is an operating system that is being developed as a joint effort by University of Sydney and University of Stirling . Two professors (John Rosenberg - University of Sydney and Alan Dearle - University of Stirling) together with three graduate assistants (David Hulse,Anders Lindstorm and Stephen Norris) are working on Grasshopper

It is not only an OS but also an OS that supports orthogonal persistence.

Grasshopper relies upon three powerful abstractions, Containers, Loci and capabilities.

Most existing operating systems suffer from the discontinuity between permanent and temporary data, lack of resilience to failure.

In conventional OS’s permanent data must be accessed via the files system and it is not consistent with data in the virtual memory.

Resilience of data and computations is essential for many applications.

That where Grasshopper comes in. - Orthogonal Persistence and resilience.

What is Orthogonal Persistence?

In 1981, Atkinson proposed that all data in a system should persist for as long as they are required. He called the aspect of longetivity Persistence.

He also proposed that all the data should be treated uniformly regardless of the length of time it has persisted, that is, the persistence of data is orthogonal to its other attributes size, type and ownership.

Orthogonal Persistence has two principles– Data may persist for as long or a short as it is required– the objects are manipulated in the same manner regardless of the

time they have persisted.

Architecture of Grasshopper

Relies on three basic abstractions -– Containers

• These provide the only abstraction on storage. It combines the address spaces and filesytem eliminating the need for complex file systems.

– Loci• This is an abstraction over execution. It handles process and it

simply contains the contents of registers of the machine.

– Capabilities• These provide inter container communications. It consists of a

unique name (key), rights associated with that capability. Determines what operations can be performed on a system.

Containers

Containers are the single abstraction over storage. They eliminate the need for the file system and address space.

In orthogonal persistent systems, using container eliminate the need for programmers to know the location of data. This means that whether data is in RAM or backing storage, the programmer perceives no difference.

This raises the question of addressing in orthogonal systems. There there models employed.

– Single flat address space– Single partitioned address space– Fully partitioned address space.

More containers

Single flat address space – – This is similar to conventional OS’s. In this model all data

resides in a single address space with no structure imposed.– There is a limitation on the size of address space. But with the

advent of 64 bit address spaces, this is possible. Single partitioned

– The idea of a large address space is retained. However, this address space is partitioned into semi independent regions. These regions contain logically related set of data.

Fully partitioned address space– The store is fully partitioned with each address being treated as

an instance of the flat address space.

Container Mapping

Loci

Loci are the agents of change in the Grasshopper. These are processes.

In the simplest form, they are the content of the registers. Each loci is associated with a host container. The locus

executes in only one container (host container)at time but can move from container to container. This is done by locus invocation.

There are two methods of interactions between entities in an operating system.– Message Oriented– Procedure Oriented.

Invocation

A container may include a single entry point as one of its attribute. This point is known as invocation point.

When a locus invokes a container, it begins to execute the code at the invocation point.

A locus may invoke and return through many containers. The kernel maintains a call chain of invocations between containers.

When the locus returns to the root container it is deleted. However, if a locus does not need to return to the root container it, the invoke parameter informs the kernel not to keep a chain of invocations.

Capabilities

Capabilities provide inter process(container) communications. Each container and loci contains a list of capabilities.

The list consists of unique key(name), the operations which that container and loci are allowed to perform in a system.

When code executed by a locus call for the manipulation of another object, a list of capabilities must be presented. This identifies the calling objects and the operations it is allowed to perform.

More capabilities

The only way an operation can be performed is by that operation providing a valid capability.

Capabilities derive their power from two points– Names are unique– Capabilities cannot be forged.

They are created and modified by the system in controlled manner.

Data Management

Of great importance in Grasshopper is how to give loci direct access to data and provide resilience and recovery.

At present the container abstraction is implemented using user level entities called container managers.

Grasshopper kernel implements 3 ADTs that allow the container abstraction to work.– Disks – allow container managers to access physical disks– Physical page sets – allow for memory manipulation– Local container Descriptors (LCDs) – are used to store address

translation information such as the correspondence between virtual and physical address.

Handling page faults

Container a request data that is not in memory.

This cause a page fault that is handled by the kernels exception handler.

The exception handler invocate containers a’s manager container b requesting it to service the page fault.

Access violations

Access Violations occur when a locus attempts to for example write to a container in which writing is not allowed.

At some some point, the memory of a local node is filled with copies pages hence page faults cannot be serviced.

The Kernel is responsible for maintaining system wide stability. When check points occur it decides what containers need to be stabilized an then invokes the appropriate managers.

Sources

Communications of ACM September 1996/Vol. 39, No 9 “Operating systems support for persistent and recoverable computations”

http://www.gh.cs.su.oz.au/Grasshopper/Papers/GH10/gh10.html “ Grasshopper: An orthogonally persistent operating System”

http://www.gh.cs.su.oz.au/Grasshopper/Papers/Anders.ACSC.94/index.html A Model For User-Level Memory Management in a Distributed, Persistent Environment”

Finally

Good Luck in your Finals

Happy Holidays

????