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.h
A Model For User-Level Memory Management in a Distributed,
Persistent Environment”
 Finally
 Good Luck in  Happy Holidays
your Finals
Θυ ε σ τ ι
ο ν σ ????