Java Message Passing

1

• Java Message Passing

Mark Baker Computer Science University of
Portsmouth, UK http//www.csm.port.ac.uk/mab/Tal
ks/
2
Contents

• Introduction
• Related projects
• mpiJava
• Introduction,
• Architecture,
• Demos.
• MPJ
• Introduction,
• API infrastructure,
• Lite/Jini versions.
• Conclusions and Future work.

3
Introduction

• Lots interest in Java may be a good language
  for scientific and engineering computation, and
  in particular for parallel computing.
• A basic prerequisite for parallel computing is a
  good communication API.
• Existing ready-made packages for communications
  in Java (RMI/Sockets) - better suited to
  Client/Server set up.
• Parallel computing community are more interested
  in symmetric communication, occurring in groups
  of interacting peers.
• This symmetric model is captured in the
  successful Message Passing Interface (MPI).

4
The mpiJava wrapper

• Idea to implement a Java API for MPI suggested
  in late 97.
• Builds on work on Java wrappers for MPI started
  at NPAC about a year earlier in the HPJava
  project
• Producing an HPspmd compiler and a runtime
  library communication library needed!
• People Mark Baker, Bryan Carpenter, Geoffrey
  Fox, Sung Hoon Ko, Guansong Zhang and Sang Lim.

5
Related projects

• mpiJava (Indiana) Java MPI-like interface to
  native MPI via JNI - ongoing!
• JavaMPI (Westminster) converts Java to CMPI
  Dec 99.
• MPIJ (Brigham Young) Java MPI-like system
  June 01.
• jmpi (Basknet) deceased!
• CCJ Object-based Message Passing and Collective
  Communication in Java - http//www.cs.vu.nl/manta/
  - ongoing.
• MP (Douglas Pase, IBM) pure Java MPJ-like
  interface ongoing
• MPJ (Java Grande) Java MPJ implementation
  ongoing (more later).

6
mpiJava

• Fully featured Java interface to MPI 1.1
• Object-oriented API based on MPI 2 standard C
  interface.
• Initial implementation used JNI to native MPI.
• Comprehensive test suite translated from IBM MPI
  suite (C)
• Available for Solaris, Linux, Windows and other
  platforms

7
mpiJava API

• The class MPI only has static members.
• It acts as a module containing global services,
  such as initialisation, and many global constants
  including the default communicator COMM_WORLD.
• The most important class in the package is the
  communicator class Comm.
• All communication functions in mpiJava are
  members of Comm or its subclasses.
• Another very important class is the Datatype
  class.
• The Datatype class describes the type of elements
  in the message buffers to send and receive.

8
Class hierarchy
9
Basic Datatypes
10
mpiJava send()/recv()

• Send and receive members of Comm
• void send(Object buf, int offset, int count,
  Datatype type, int dst, int tag)
• Status recv(Object buf, int offset, int count,
  Datatype type, int src, int tag)
• buf must be an array.
• offset is the element where message starts.
• Datatype class describes type of elements.

11
Minimal mpiJava program
import mpi. class Hello static public void
main(String args) MPI.Init(args)
int myrank MPI.COMM_WORLD.Rank() if(myrank
0) char mess Hello,
there.toCharArray() MPI.COMM_WORLD.Send(me
ss, 0, mess.length, MPI.CHAR, 1, 99) else
char mess new char 20
MPI.COMM_WORLD.Recv(mess, 0, 20, MPI.CHAR, 0,
99) System.out.println(received new
String(mess) ) MPI.Finalize()

12
mpiJava implementation issues

• mpiJava is currently implemented as a Java
  interface to an underlying MPI implementation
  such as MPICH or some other native MPI
  implementation.
• The interface between mpiJava and the underlying
  MPI implementation is via the Java Native
  Interface (JNI).

13
mpiJava - Software Layers
14
The PingPong Program

• Increasing sized messages are sent back and forth
  between processes
• This benchmark is based on standard blocking
  MPI_Send/MPI_Recv.
• PingPong provides information about latency and
  uni-directional bandwidth.
• To ensure that anomalies in message timings do
  not occur the PingPong is repeated for all
  message lengths.

15
PingPong Example details

• mpiJava v1.2.3 http//aspen.ucs.indiana.edu/pss/HP
  Java/mpiJava.html
• WMPI v1.5.2, Critical Software,
  http//www.criticalsoftware.com/wmpi
• Java 1.4
• http//java.sun.com
• PingPong v 1.0 (SPMD)
• http//www.csm.port.ac.uk/mab/TOPIC

16
PingPong Example code

• import mpi.
• class PingPong
• public static void main(String args) throws
  MPIException
• // decs
• MPI.Init(args)
• my_pe MPI.COMM_WORLD.Rank()
• npes MPI.COMM_WORLD.Size()
• for (log2nbyte 0 log2nbyte lt LOG2N_MAX
  log2nbyte)
• nbyte ( 1 ltlt log2nbyte )
• byte A new byte nbyte
• for (j_pe 1 j_pe lt npes-1 j_pe)
• MPI.COMM_WORLD.Barrier()
• tf0 MPI.Wtime()
• for (n_pp 0 n_pp lt PINGPONGS n_pp)
  
• if (my_pe j_pe)
• MPI.COMM_WORLD.Send(A, 0, nbyte,
  MPI.BYTE, 0, 10)
• status MPI.COMM_WORLD.Recv(A, 0,
  nbyte, MPI.BYTE, 0, 20)
• if (my_pe 0)

NB Incomplete code!
17
PingPong Example code

• import mpi.
• class PingPong
• public static void main(String args) throws
  MPIException
• // decs
• MPI.Init(args)
• my_pe MPI.COMM_WORLD.Rank()
• npes MPI.COMM_WORLD.Size()
• for (log2nbyte 0 log2nbyte lt LOG2N_MAX
  log2nbyte)
• nbyte ( 1 ltlt log2nbyte )
• byte A new byte nbyte
• for (j_pe 1 j_pe lt npes-1 j_pe)
• MPI.COMM_WORLD.Barrier()
• tf0 MPI.Wtime()
• for (n_pp 0 n_pp lt PINGPONGS n_pp)
  
• if (my_pe j_pe)
• MPI.COMM_WORLD.Send(A, 0, nbyte,
  MPI.BYTE, 0, 10)
• status MPI.COMM_WORLD.Recv(A, 0,
  nbyte, MPI.BYTE, 0, 20)
• if (my_pe 0)

Normal MPI-like initialisation
18
PingPong Example code

• import mpi.
• class PingPong
• public static void main(String args) throws
  MPIException
• // decs
• MPI.Init(args)
• my_pe MPI.COMM_WORLD.Rank()
• npes MPI.COMM_WORLD.Size()
• for (log2nbyte 0 log2nbyte lt LOG2N_MAX
  log2nbyte)
• nbyte ( 1 ltlt log2nbyte )
• byte A new byte nbyte
• for (j_pe 1 j_pe lt npes-1 j_pe)
• MPI.COMM_WORLD.Barrier()
• tf0 MPI.Wtime()
• for (n_pp 0 n_pp lt PINGPONGS n_pp)
  
• if (my_pe j_pe)
• MPI.COMM_WORLD.Send(A, 0, nbyte,
  MPI.BYTE, 0, 10)
• status MPI.COMM_WORLD.Recv(A, 0,
  nbyte, MPI.BYTE, 0, 20)
• if (my_pe 0)

Binary loop from 20 ? 2n
19
PingPong Example code

• import mpi.
• class PingPong
• public static void main(String args) throws
  MPIException
• // decs
• MPI.Init(args)
• my_pe MPI.COMM_WORLD.Rank()
• npes MPI.COMM_WORLD.Size()
• for (log2nbyte 0 log2nbyte lt LOG2N_MAX
  log2nbyte)
• nbyte ( 1 ltlt log2nbyte )
• byte A new byte nbyte
• for (j_pe 1 j_pe lt npes-1 j_pe)
• MPI.COMM_WORLD.Barrier()
• tf0 MPI.Wtime()
• for (n_pp 0 n_pp lt PINGPONGS n_pp)
  
• if (my_pe j_pe)
• MPI.COMM_WORLD.Send(A, 0, nbyte,
  MPI.BYTE, 0, 10)
• status MPI.COMM_WORLD.Recv(A, 0,
  nbyte, MPI.BYTE, 0, 20)
• if (my_pe 0)

Buffer byte A - sent back and forth.
20
PingPong Example code

• import mpi.
• class PingPong
• public static void main(String args) throws
  MPIException
• // decs
• MPI.Init(args)
• my_pe MPI.COMM_WORLD.Rank()
• npes MPI.COMM_WORLD.Size()
• for (log2nbyte 0 log2nbyte lt LOG2N_MAX
  log2nbyte)
• nbyte ( 1 ltlt log2nbyte )
• byte A new byte nbyte
• for (j_pe 1 j_pe lt npes-1 j_pe)
• MPI.COMM_WORLD.Barrier()
• tf0 MPI.Wtime()
• for (n_pp 0 n_pp lt PINGPONGS n_pp)
  
• if (my_pe j_pe)
• MPI.COMM_WORLD.Send(A, 0, nbyte,
  MPI.BYTE, 0, 10)
• status MPI.COMM_WORLD.Recv(A, 0,
  nbyte, MPI.BYTE, 0, 20)
• if (my_pe 0)

Loop over number of processes
21
PingPong Example code

• import mpi.
• class PingPong
• public static void main(String args) throws
  MPIException
• // decs
• MPI.Init(args)
• my_pe MPI.COMM_WORLD.Rank()
• npes MPI.COMM_WORLD.Size()
• for (log2nbyte 0 log2nbyte lt LOG2N_MAX
  log2nbyte)
• nbyte ( 1 ltlt log2nbyte )
• byte A new byte nbyte
• for (j_pe 1 j_pe lt npes-1 j_pe)
• MPI.COMM_WORLD.Barrier()
• tf0 MPI.Wtime()
• for (n_pp 0 n_pp lt PINGPONGS n_pp)
  
• if (my_pe j_pe)
• MPI.COMM_WORLD.Send(A, 0, nbyte,
  MPI.BYTE, 0, 10)
• status MPI.COMM_WORLD.Recv(A, 0,
  nbyte, MPI.BYTE, 0, 20)
• if (my_pe 0)

process barrier
22
PingPong Example code

• import mpi.
• class PingPong
• public static void main(String args) throws
  MPIException
• // decs
• MPI.Init(args)
• my_pe MPI.COMM_WORLD.Rank()
• npes MPI.COMM_WORLD.Size()
• for (log2nbyte 0 log2nbyte lt LOG2N_MAX
  log2nbyte)
• nbyte ( 1 ltlt log2nbyte )
• byte A new byte nbyte
• for (j_pe 1 j_pe lt npes-1 j_pe)
• MPI.COMM_WORLD.Barrier()
• tf0 MPI.Wtime()
• for (n_pp 0 n_pp lt PINGPONGS n_pp)
  
• if (my_pe j_pe)
• MPI.COMM_WORLD.Send(A, 0, nbyte,
  MPI.BYTE, 0, 10)
• status MPI.COMM_WORLD.Recv(A, 0,
  nbyte, MPI.BYTE, 0, 20)
• if (my_pe 0)

Start round trip timer
End round trip timer
23
PingPong Example code

• import mpi.
• class PingPong
• public static void main(String args) throws
  MPIException
• // decs
• MPI.Init(args)
• my_pe MPI.COMM_WORLD.Rank()
• npes MPI.COMM_WORLD.Size()
• for (log2nbyte 0 log2nbyte lt LOG2N_MAX
  log2nbyte)
• nbyte ( 1 ltlt log2nbyte )
• byte A new byte nbyte
• for (j_pe 1 j_pe lt npes-1 j_pe)
• MPI.COMM_WORLD.Barrier()
• tf0 MPI.Wtime()
• for (n_pp 0 n_pp lt PINGPONGS n_pp)
  
• if (my_pe j_pe)
• MPI.COMM_WORLD.Send(A, 0, nbyte,
  MPI.BYTE, 0, 10)
• status MPI.COMM_WORLD.Recv(A, 0,
  nbyte, MPI.BYTE, 0, 20)
• if (my_pe 0)

Loop over PingPong times per byte sized buffer
24
PingPong Example code

• import mpi.
• class PingPong
• public static void main(String args) throws
  MPIException
• // decs
• MPI.Init(args)
• my_pe MPI.COMM_WORLD.Rank()
• npes MPI.COMM_WORLD.Size()
• for (log2nbyte 0 log2nbyte lt LOG2N_MAX
  log2nbyte)
• nbyte ( 1 ltlt log2nbyte )
• byte A new byte nbyte
• for (j_pe 1 j_pe lt npes-1 j_pe)
• MPI.COMM_WORLD.Barrier()
• tf0 MPI.Wtime()
• for (n_pp 0 n_pp lt PINGPONGS n_pp)
  
• if (my_pe j_pe)
• MPI.COMM_WORLD.Send(A, 0, nbyte,
  MPI.BYTE, 0, 10)
• status MPI.COMM_WORLD.Recv(A, 0,
  nbyte, MPI.BYTE, 0, 20)
• if (my_pe 0)

Slave
Master
25
PingPong Example code

• import mpi.
• class PingPong
• public static void main(String args) throws
  MPIException
• // decs
• MPI.Init(args)
• my_pe MPI.COMM_WORLD.Rank()
• npes MPI.COMM_WORLD.Size()
• for (log2nbyte 0 log2nbyte lt LOG2N_MAX
  log2nbyte)
• nbyte ( 1 ltlt log2nbyte )
• byte A new byte nbyte
• for (j_pe 1 j_pe lt npes-1 j_pe)
• MPI.COMM_WORLD.Barrier()
• tf0 MPI.Wtime()
• for (n_pp 0 n_pp lt PINGPONGS n_pp)
  
• if (my_pe j_pe)
• MPI.COMM_WORLD.Send(A, 0, nbyte,
  MPI.BYTE, 0, 10)
• status MPI.COMM_WORLD.Recv(A, 0,
  nbyte, MPI.BYTE, 0, 20)
• if (my_pe 0)

Slave send buffer
Master receive buffer
26
PingPong Example code

• import mpi.
• class PingPong
• public static void main(String args) throws
  MPIException
• // decs
• MPI.Init(args)
• my_pe MPI.COMM_WORLD.Rank()
• npes MPI.COMM_WORLD.Size()
• for (log2nbyte 0 log2nbyte lt LOG2N_MAX
  log2nbyte)
• nbyte ( 1 ltlt log2nbyte )
• byte A new byte nbyte
• for (j_pe 1 j_pe lt npes-1 j_pe)
• MPI.COMM_WORLD.Barrier()
• tf0 MPI.Wtime()
• for (n_pp 0 n_pp lt PINGPONGS n_pp)
  
• if (my_pe j_pe)
• MPI.COMM_WORLD.Send(A, 0, nbyte,
  MPI.BYTE, 0, 10)
• status MPI.COMM_WORLD.Recv(A, 0,
  nbyte, MPI.BYTE, 0, 20)
• if (my_pe 0)

Slave receive buffer
Master send buffer
27
PingPong Example code

• import mpi.
• class PingPong
• public static void main(String args) throws
  MPIException
• // decs
• MPI.Init(args)
• my_pe MPI.COMM_WORLD.Rank()
• npes MPI.COMM_WORLD.Size()
• for (log2nbyte 0 log2nbyte lt LOG2N_MAX
  log2nbyte)
• nbyte ( 1 ltlt log2nbyte )
• byte A new byte nbyte
• for (j_pe 1 j_pe lt npes-1 j_pe)
• MPI.COMM_WORLD.Barrier()
• tf0 MPI.Wtime()
• for (n_pp 0 n_pp lt PINGPONGS n_pp)
  
• if (my_pe j_pe)
• MPI.COMM_WORLD.Send(A, 0, nbyte,
  MPI.BYTE, 0, 10)
• status MPI.COMM_WORLD.Recv(A, 0,
  nbyte, MPI.BYTE, 0, 20)
• if (my_pe 0)

Finalize and clean up
28
PingPong Demo
29
PingPong Demo notes

• Under WMPI the first process spawns the others
  processes.
• Need to produce a dummy executable to act as the
  spawning process when using mpiJava.

30
mpiJava issues

• Interfacing Java to MPI not always trivial,
  e.g., see low-level conflicts between the Java
  runtime and interrupts in MPI.
• Situation improved with JDK 1.2.
• Release reliable Solaris MPI (SunHPC, MPICH),
  shared memory, Windows (WMPI) and Linux (MPICH).
• Installation and set up of mpiJava on a platform
  not ideal!

31
mpiJava under WMPI

• To create a release of mpiJava for WMPI the
  following steps were undertaken
• Step 1 Compile the mpiJava JNI C interface into
  a Win32 Dynamic Link Library (mpiJava.dll).
• Step 2 Modify the name of the library loaded by
  the mpiJava Java interface (MPI.java) to that of
  the of the newly compiled library.
• Step 3 Create a JNI interface to WMPI -
  idiosyncrasy of WMPI !!
• Step 4 Place libraries and other files in the
  correct places and get the CLASSPATH and PATH
  variables correct!

32
mpiJava - Summary

• mpiJava provides a fully functional Java
  interface to MPI.
• mpiJava works well on most platforms (UNIX and
  Windows).
• Tests show that the additional latencies that
  mpiJava imposes is due to the relatively poor
  performance of the JVM rather than traversing
  more software layers.
• Syntax of mpiJava is logical, easy to understand
  - easy to take up
• We believe that mpiJava provides a popular and
  practical parallel programming teaching tool.
• Downloaded over 600 times

33
MPJ Introduction

• The Message-Passing Working Group of the Java
  Grande Forum was formed in late 1998 as a
  response to the appearance of several prototype
  Java bindings for MPI-like libraries.
• An initial draft for a common API specification
  was distributed at Supercomputing '98.
• Since then the working group has met in San
  Francisco and Syracuse.
• The present API is now called MPJ.

34
MPJ Introduction

• Java Grande Message-Passing Working Group
• formed as a subset of the existing Concurrency
  and Applications working group of Java Grande
  Forum.
• Discussion of a common API for MPI-like Java
  libraries.
• To avoid confusion with standards published by
  the original MPI Forum the forming API is called
  MPJ.
• java-mpi mailing list hosted at CSIT in FSU has
  about 125 subscribers.

35
MPJ Introduction

• No complete implementation of the draft
  specification.
• mpiJava, is moving towards the standard.
• The new version (1.2) of the software supports
  direct communication of objects via object
  serialization,
• Version 1.3 of mpiJava will implement the new
  API.
• The mpiJava wrappers rely on the availability of
  platform-dependent native MPI implementation for
  the target computer.

36
MPJ Introduction

• While this is a reasonable basis in many cases,
  the approach has some disadvantages.
• The 2-stage installation procedure get and
  build native MPI then install and match the Java
  wrappers tedious/off-putting to new users.
• On several occasions we saw conflicts between the
  JVM environment and the native MPI runtime
  behaviour. The situation has improved, and
  mpiJava now runs on various combinations of JVM
  and MPI implementation.
• This strategy simply conflicts with the ethos of
  Java write-once-run-anywhere software is the
  order of the day.

37
MPJ Message Passing in Java,

• An MPJ reference implementation could be
  implemented as
• Java wrappers to a native MPI implementation,
• Pure Java,
• Principally in Java with a few simple native
  methods to optimize operations (like marshalling
  arrays of primitive elements) that are difficult
  to do efficiently in Java.
• We are aiming at pure Java to provide an
  implementation of MPJ that is maximally portable
  and that hopefully requires the minimum amount of
  support effort.

38
Benefits of a pure Java implementation of MPJ

• Highly portable assumes only a Java development
  environment.
• Performance moderate may need JNI inserts for
  marshalling arrays. Network speed limited by
  Java sockets.
• Good for education/evaluation.
• Vendors provide wrappers to native MPI for
  ultimate performance?

39
Design of the MPJ Environment

• Need an infrastructure to support groups of
  distributed and interacting processes
• Resource discovery,
• Communications,
• Handle failure,
• Spawn processes on hosts,
• Environment consists of a MPJ infrastructure, a
  message passing API and a low-level
  communications infrastructure.

40
MPJ Development Plans

• MPJ API
• Fairly well defined.
• Some issues though!
• Low-Level API
• ADI based on isend()/irecv()
• mpjdev used in HPspmd (JNI).
• Underlying messaging system
• Sockets,
• VIA.
• MPJ Infrastructure
• Java Daemon-based
• Jini Based
• Jini-Grid based.

41
MPJ API

• Early draft specification of API on JavaGrande
  site http//www.javagrande.org.
• mpiJava close API to draft specification.
• MPJ API will continue to develop this is
  unfortunate, but a necessary evil due to reliance
  of the spec on the MPI C API and not taking
  full advantage of the Java language.
• Datatypes tag, Object datatype, etc

42
Low-level API

• MPICH has a Abstract Devise Interface (ADI)
  provides a common API between the higher-level
  calls and the low-level devise interfaces (JNI,
  Sockets, VIA, etc).
• Byran Carpenter and his students at Indiana have
  produced mpjdev
• Low-level API for MPJ
• mpjdev is the MPJ ADI
• First alpha release in May (works on Linux and
  Windows).
• Communicates to the native MPI implementation via
  JNI.
• Need to produce code to link mpjdev API to MPJ
  API and also produce non-JNI devises, such as
  Sockets and VIA this is being looked.

43
Low-level API Where we are!
MPJ API
mpjdev
JNI
VIA
Native MPI
Sockets
44
mpjdev

• Meant for library developer.
• Application level communication libraries like
  Java version of Adlib or MPJ might be implemented
  on top of mpjdev.
• mpjdev may be implemented on top of Java sockets
  in a portable network implementation, or on HPC
  platforms through a JNI interface to a subset
  of MPI.
• The initial version of the mpjdev has been
  targeted to HPC platforms the latter case.
• A Java sockets version which will be provide more
  portable network implementation will be added in
  the future.

45
mpjdev

• API for mpjdev is small compared to MPI (only
  includes point-to-point communications) or MPJ
• Blocking mode (like MPI_SEND, MPI_RECV).
• Non-blocking mode (like MPI_ISEND, MPI_IRECV).
• The sophisticated data types of MPI are omitted.
• Provide a reasonably flexible suit of operations
  for copying data to and from the buffer (like
  gather- and scatter-style operations).

46
HPJava communication layers
47
MPJ Infrastructure

• We envisage that a user will download a jar file
  of MPJ library classes onto machines that may
  host parallel jobs, and install a daemon on those
  machines.
• Parallel MPJ codes are compiled on a local host.
• An mpjrun program invoked on that host
  transparently loads the user's class files into
  JVMs created on remote hosts by the MPJ daemons,
  and the parallel job starts.

48
Layers of an MPJ Reference Implementation
Socket manager
MPJ API
mpjdev
MPJDaemon
49
Slave 1
Slave 2
Slave 3
Slave 4
MpjRun
Host
MpjDeamon
http server
Mpjrun myproggy np 4
50
MPJ Infrastructure

• Java Daemon-based.
• MPJRun
• MPJDaemon

51
MPJ Infrastructure Schematic
52
MPJ Infrastructure Schematic
53
MPJRun
54
MPJRun GUI
55
MPJRun GUI
56
MPJRun GUI
57
MPJRun GUI
58
MPJRun GUI
59
MPJRun GUI
60
MPJDaemon
61
Jini Architecture
62
Lookup service

• Repository of available services.
• Stores each service as an extensible set of Java
  objects.
• Service objects may be downloaded to clients as
  required.
• May be federated with other lookup services.
• Lookup service interface provides
• Registration, Access, Update, Search, Removal.

63
Jini Lookup
64
Leasing protocol in Jini

• Protocol for managing resources using a
  renewable, duration-based model.
• Contract between objects.
• Resources can be shared or non-shared.
• Provides a method of managing resources in an
  environment where failures can, and do, occur.

65
Distributed events in Jini

• Enables Java event model to work in a distributed
  network.
• Register interest, receive notification.
• Allows for use of event managers.
• Can use numerous distributed delivery models
• Push, pull, filter...
• Uses leasing protocol.

66
Transaction model in Jini

• Designed for distributed object coordination
  light weight, object-oriented.
• Supports
• Nested transactions
• Various levels of ACID properties (Atomicity,
  Consistency, Isolation, Durability).
• Uses leasing protocol.
• Implemented in Transaction Manager service
  another Jini service.

67
Jini Infrastructure for MPJ
Daemon
MPJ Process
mpjrun
68
MPJ Jini

• Jini-enabled Daemon
• Find LUSs.
• Registers with Jini LUS
• Advertises capabilities.
• Updates current status.
• Jini-enabled MPJRun client
• Finds LUSs.
• Search for required MPJ services.
• Interact directly with MPJDaemons.

69
Handling failures with Jini

• We will use Jini leasing to provide fault
  tolerance.
• If any slave dies, a client generates a Jini
  distributed event, MPIAbort all slaves are
  notified and all processes killed.
• Other failures (network, client chrash, death of
  controlling daemon, ) client leases on slaves
  expire in a fixed time, and processes are killed.
• It is likely there will be a hierarchy of leases
  consequently this area needs to be carefully
  designed.

70
Describing A Service Using Attributes

• Want to somehow let clients know recent MPJ node
  status.
• Typical information may be
• Machine information processor and memory
  utilisation, OS type, Jini services running, etc.
• Daemon information number of MPJ tasks it is
  already handling, JDK/Jini versions, etc.
• Every node has an MPJ daemon that is registered
  with LUS (s).
• We can use Jini attributes to describe a service.

71
Describing A Service Using Attributes

• It appears to be two ways of providing dynamic
  information about a service (such as the MPJ
  daemon)
• Directly, via the lookup service (s).
• Indirectly, via a broker which pulls status from
  individual daemons, which in turn is queried by
  clients that require the services.

72
Describing A Service Using Attributes

• Current view is that we should use the direct
  method
• The MPJ daemons can be instructed to push their
  status out a frequent intervals to the LUS
• Good Points
• Minimise the additional infrastructure that needs
  to be design, developed, implemented and tested
• Appears to be using the LUS the way that it was
  designed.
• Bad Points
• Unsure how much pushing status will be impact
  performance of the MPJ Infrastructure.
• This model will not fit in with an activatable
  MPJ daemon.

73
Scheduling

• You can create a status flag for each service and
  then filter on the flag during discovery.
• Or create a scheduling service (a broker) and
  then MPJ jobs are queued with the scheduling
  service, which then handles allocating jobs onto
  the available MPJ hosts.
• The former is a simple solution as many users
  will probably prefer to choose their hosts with
  geographic location even if it means waiting
  rather than finding the next available host.

74
Checkpointing

• Checkpointing and restarting of interrupted jobs
  may be quite useful.
• Checkpointing would not happen without explicit
  invocation in the user-level code, or that
  restarting would happen automatically.
• A serialized (marshalled) object can be saved to
  disk and restarted.

75
Summary

• A Message Passing interface similar to MPI is
  need for Java-based SPMD application.
• mpiJava has been around for a number of years and
  is converging on the draft MPJ specification.
• Still lots of interest in mpiJava
• Need consensus on MPJ API.
• Need pure Java system!
• Need easy means to install, configure and use.
• Currently have parts of MPJ release, still some
  parts to complete.

76
MPJ Future Work

• On-going (unfunded) effort UoP/Indiana.
• Infrastructure being developed in parallel with
  MPJ message passing system.
• Currently working on components of MPJ
  infrastructure,
• lite version Java daemons GUI.
• Jini enabled version designed, awaiting
  implementation.
• Concerned about Jini Security.
• Also looking at the means of integrating Jini
  with Grid systems tutorial at CCGrid 2002
  earlier in the week.