Version française
Home     About     Download     Resources     Contact us    
Browse thread
Horus/ML, a distributed communication toolkit for Objective Caml
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Mark Hayden <hayden@c...>
Subject: Horus/ML, a distributed communication toolkit for Objective Caml


It is my pleasure to announce Horus/ML (alpha2), a toolkit for building
distributed applications in the Objective Caml programming language.
Below, I briefly describe what Horus/ML is, what it does, and how to go
about getting a copy. For more information about the Horus project at
Cornell University, you can visit to the following URL:

   http://www.cs.cornell.edu/Info/Projects/HORUS/

There you'll find more information about Horus, papers on group
communication, and pointers to other sites with related information.  I
particularly recommend the Scientific American and CACM articles at the
main URL as general background for Horus.  Note that the information is
primarily about Horus/C which is very similar to, but not exactly the same
as, Horus/ML (Horus/ML is a complete reimplementation in ML of Horus/C).

Some changes for this release:

* Horus/ML runs on all of Ocaml's platforms which support the Unix library 
  (with sockets).  In addition, a port to Windows is almost complete.

* Byte code distribution.  In addition to the full source code distribution
  (which requires filling out a non-disclosure agreement), there is now a
  bytecode release that is freely available.  Included in the bytecode
  release is all the documentation, bytecode versions of all the libraries,
  and full source code for all the application demos.

Mark Hayden (hayden@cs.cornell.edu)



What is Horus/ML?

  For the application builder, Horus/ML is a toolkit that can be used for
  quickly building complex distributed applications.  For instance, through
  the Objective Caml marshaling facility, you can automatically pass
  (non-functional) data structures between applications.  To use Horus/ML,
  an application installs 10 or so event handlers, and then Horus/ML
  transparently handles all the details of sending and receiving messages,
  transferring state, detecting failures, and managing reconfigurations in
  the system.

  For the distributed systems researcher, Horus/ML is a highly modular and
  reconfigurable toolkit.  The high-level protocols provided to
  applications are really stacks of tiny protocol "layers."  These protocol
  layers each implement several simple properties: they are composed to
  provide high-level properties, such as total ordering, virtual synchrony,
  etc....  Individual layers can be modified or rebuilt to experiment with
  new properties or change the performance characteristics of the system.
  This makes it a very flexible platform on which to do research.

How can I see what it does?

  Horus/ML comes with several demonstration applications, including a
  collaborative white board demo and remote execution demo (similar to
  rsh).  For the white board demo you execute several instances and then
  anything drawn on one gets replicated to the others.  Each white board is
  assigned a color for its owner.  When a new white board is added, it is
  assigned a color and the others automatically transfer their state to it.
  When a white board is killed, the others automatically reconfigure the
  system and reassign colors.

Horus/ML, Caml/Tk, and the Web!

  We've interfaced Horus/ML with Caml/Tk, so you can access all the Tk GUI
  functionality.  In addition, Horus/ML can be compiled with the MMM
  browser by Francois Rouaix.  This can then support collaborative applets
  on the Web.  The white board described above can be compiled both as a
  stand-alone executable and as an MMM applet.  The MMM version is
  something we are still preparing to distribute and will be made available
  soon.

What does Horus/ML do that protocols like TCP/IP don't?

  There is no answer to this question that is both short and complete.
  I'll give a short one here; for a longer answer you can go to the Horus
  URL given above.

  TCP/IP sockets are great for communication between pairs of processes.
  Horus/ML can be viewed as a generalization of TCP communication to groups
  (i.e., one or more) of processes.  TCP provides FIFO communication on
  point-to-point channels; Horus/ML provides FIFO (and other more strongly
  ordered) channels between all members in a group.  TCP alerts each
  endpoint when the other end has failed; Horus/ML also detects failures
  and alerts all members of them (and guarantees that they all see the same
  set of failures).

  Other issues arise when you have groups of processes communicating
  instead of just pairs.  Horus/ML provides solutions to many of these.
  For instance, network outages can cause groups to partition.  Horus/ML
  detects these partitions *and* automatically heals them when
  communication is restored.  Also, when the membership of a group changes
  it is often useful for the members to transfer state.  Horus/ML provides
  protocols for coordinating this state transfer.

What does it use for communication?  What platforms does it run on?

  Horus/ML primarily uses UDP/IP sockets.  It supports IP multicast, but
  does not require it.  Supporting new communication transports is simple
  (the UDP transport is around 150 lines of ML).

  Horus/ML is written entirely in ML and should run on any platform that
  supports sockets.  In addition, we have ported the socket library to
  Windows, so Horus/ML also runs under Windows.  Horus/ML has been run on
  Windows, SunOS4, Solaris, Linux, and RS6000-AIX (running on the SP2
  supercomputer at Cornell!).

Distributed communication in ML!?!?  It must be slow....

  Actually, it isn't.  Using specially optimized protocols, Horus/ML can be
  around 10% slower than raw UDP socket communication. (The version
  distributed contains these protocols, but they are not used by default.)
  With these protocols in use, the performance of Horus/ML is comparable to
  other group communication systems written in C -- and faster than most.
  ML has helped us evolve the system so that in the normal case Horus/ML
  costs very little.

If you are interested in Horus, you may wish to add yourself to the Horus
mailing list in order to stay in touch with us.  You can find out how to
join the mailing list here:

   http://www.cs.cornell.edu/Info/Projects/HORUS/general/maillist.html


FTP-ING HORUS/ML

Horus/ML is available by ftp.

  ftp ftp.cs.cornell.edu    # login as anonymous
  binary
  cd pub/isis/horus
  dir

You will find one or more distributions under the name distr.[date]
(e.g. distr.Jul23.96). Go to the most recent one.  You'll find a collection
of files under names that end in ".tar.gz.crypt" or ".tar.gz". This means
they are tar archives, compressed with gzip, and possibly encrypted with
crypt.  For Horus/ML, you will want hml.bc.tar.gz or hml.tar.gz.crypt:

A.  Unencrypted bytecode distribution:

      get hml.bc.tar.gz	   
      quit

      # uncompress and untar distribution
      zcat hml.bc.tar.gz | tar xvf -
      more hml/INSTALL          # read this first

B.  Encrypted full source distribution.

      get README # instructions for getting password
      get hml.tar.gz.crypt
      quit

      # decrypt, uncompress, untar distribution
      crypt PASSWORD < hml.tar.gz.crypt | zcat | tar xvf -
      more hml/INSTALL          # read this first

    If you don't have crypt, pick it up from:

      ftp://idea.sec.dsi.unimi.it/pub/crypt/code/crypt1.c

    Compile it as:

      gcc -o crypt crypt1.c