Grasshopper

1
Grasshopper

• Peter Kamara Mburu
• Dec-6-1999

2
Overview

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

3

• What is ?
• Why ?

4

• 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.

5

• Most existing operating systems suffer from the
  discontinuity between permanent and temporary
  data, lack of resilience to failure.
• In conventional OSs 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.

6
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.

7
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.

8
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.

9
More containers

• Single flat address space
• This is similar to conventional OSs. 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.

10
Container Mapping
11
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.

12
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.

13
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.

14
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.

15
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.

16
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 as
  manager container b requesting it to service the
  page fault.

17
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.

18
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/Ander
  s.ACSC.94/index.html A Model For User-Level
  Memory Management in a Distributed, Persistent
  Environment

19
Finally

• Good Luck in your Finals

• Happy Holidays

20

• Questions ????