Grasshopper - PowerPoint PPT Presentation

1 / 20
About This Presentation



... is known as invocation point. ... maintains a call chain of invocations between containers. ... The exception handler invocate containers a's manager container b ... – PowerPoint PPT presentation

Number of Views:94
Avg rating:3.0/5.0
Slides: 21
Provided by: peterk56


Transcript and Presenter's Notes

Title: Grasshopper

  • Peter Kamara Mburu
  • Dec-6-1999

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

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

Container Mapping
  • Loci are the agents of change in the Grasshopper.
    These are processes.
  • In the simplest form, they are the content of the
  • 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.

  • 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 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
  • Local container Descriptors (LCDs) are used to
    store address translation information such as the
    correspondence between virtual and physical

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.

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.

  • Communications of ACM September 1996/Vol. 39, No
    9 Operating systems support for persistent and
    recoverable computations
  • http//
    gh10.html Grasshopper An orthogonally
    persistent operating System
  • http//
    s.ACSC.94/index.html A Model For User-Level
    Memory Management in a Distributed, Persistent

  • Good Luck in your Finals
  • Happy Holidays

  • Questions ????
Write a Comment
User Comments (0)