Newsgroups: comp.parallel.pvm
From: demeure@enst.fr (Isabelle Demeure)
Subject: Phosphorus - adding shared variables to PVM
Keywords: shared variables, PVM, DSM
Organization: Ecole Nationale Superieure des Telecommunications, Paris France
Date: 2 Jan 1996 10:12:02 +0100
Mime-Version: 1.0
Content-Type: text/plain; charset=iso-8859-1
Content-Transfer-Encoding: 8bit
Message-ID: <4cast2$hm@khamsin.enst.fr>


         Phosphorus (1): Distributed Shared Memory on Top of PVM

            Ecole Nationale Superieure des Telecommunications
	    Computer Science Department
	    46, rue Barrault - 75634 Paris Cedex 13, France

            Authors: V. Bartro, R. Cabrera, I. Demeure, P. Meunier
            Contact: isabelle.demeure@inf.enst.fr

                     (C) 1995 All Rights Reserved


(1) The phosphorus is a mineral that is said to play an important role
    in the performance of the human memory. 

-------------------------------------------------------------------------------
NOTICE
	
 Permission to use, copy, modify, and distribute this software and
 its documentation for any purpose and without fee is hereby granted
 provided that the above copyright notice appear in all copies and
 that both the copyright notice and this permission notice appear in
 supporting documentation.

 The authors do not make any representations about the suitability of this
 software for any purpose.  This software is provided ``as is'' without
 express or implied warranty.

 This is an alpha version of the Phosphorus system.

-------------------------------------------------------------------------------
PHOSPHORUS

The goal of the Phosphorus project is to provide PVM users with shared 
variables. This led us to the development of a Distributed Shared Memory
system on top of PVM. This system has been designed and prototyped. It
is based on Li and Hudak's work and on the Munin system. Data management
is dynamic and distributed. Various consistency models are used including
a relaxed consistency model for the management of the multiple writers
multiple readers sharing pattern (the relaxed consistency model is
not provided in this distribution).

This distribution provides the source code in C for SUN4 workstations 
(running under sunOs or Solaris). The system was not tested on any other
platform. However it was written with portability in mind (the only
functions invoked, beside PVM functions, are printf and gettimeofday).

Both the source code and an introductory technical report are available
by anonymous ftp to ftp.enst.fr (the files of interest are in
/pub/unix/pvm/phos).

VERSION

This is the first version of Phosphorus. It supports PVM3 up to the 3.3.9
version. It has been developed on SUN4 Workstations (under sunOS and Solaris).
As of today  it implements all protocols described in the introductory 
technical report, except for WRITE_SHARED. All functions are developed
except for "phos_barrier" (which is necessary only for the WRITE_SHARED
protocol).

CONTACT
	Please direct all questions and comments to:
	Dct Isabelle Demeure
	isabelle.demeure@inf.enst.fr

PHOSPHORUS WEB PAGES:
	http://www-inf.enst.fr/~demeure/phosphorus/contents.html

USER INTERFACE

  Process Control
  ~~~~~~~~~~~~~~~
  int phos_init();
    The routine phos_init() allows processes to enter the sharing service.
    phos_init() must be called after enrolling PVM (similar to pvm_mytid()).

  int phos_end();
    The routine phos_end() informs the local daemon that the calling task
    no longer needs the sharing service (similar to pvm_exit()).   

  Variable Declaration
  ~~~~~~~~~~~~~~~~~~~~
  int phos_declare(int desc, int type, int count, int protocol);
    This routine allows the declaration of a shared variable.  The desc
    argument is a unique identifier given by the programmer as a
    descriptor for the shared variable. type corresponds to one
    of the data types supported by PVM (through the pack/unpack functions).
    count refers to the number of items (this is for shared arrays).
    protocol determines the protocol associated with this variable: 
    READ_ONLY (Multiple Readers but variable only initialized once),
    MIGRATORY (Single Reader/Single Writer, owner migrates),
    CONVENTIONAL (Multiple Readers/Single Writer) or WRITE_SHARED (Multiple
    Readers/Multiple Writers on distinct parts of the variable). This latter
    protocol is not implemented yet. Phosphorus also supports synchronization
    variables (for mutual exclusion access). For synchronization variables the 
    parameter protocol should be SYNCH.

  int phos_free(desc);
    This routine liberates the shared variable designated by the desc
    descriptor.

  Access to Variables
  ~~~~~~~~~~~~~~~~~~~
  int phos_read(int desc, void *buffer);
    Called to obtain a copy of the variable associated to the desc
    descriptor.

  int phos_write(int desc, void *buffer);
    Called to write on a shared variable with desc descriptor.

  Synchronization
  ~~~~~~~~~~~~~~~
  int phos_lock(int desc);
    This routine may be called either with the descriptor of a 
    synchronization variable (SYNCH), or with a shared variable descriptor.

  int phos_unlock(int desc);
    Liberates the previously acquired lock.

-------------------------------------------------------------------------------



