source: branches/OKBJavaConnector/ECJClient/src/ec/exchange/README @ 6152

This package contains two implementations of the Exchange facility in ECJ to
perform island models.  The first implementation:

  ec.exchange.InterPopulationExchange

... works within a single evolutionary process, and treats each subpopulation 
as a separate "island", performing a synchronous island model among the
subpopulations.  This is mostly of academic interest, as it only runs on a 
single evolutionary process.  Note that it's also incompatable with other
uses of subpopulations, such as coevolution.  See the inter.params file for
an example.


The second implementation:

  ec.exchange.IslandExchange

... is an elaborate multi-process, multi-machine island model.  The system
can perform both synchronous and asynchronous island models of any topology
you like.  It is graceful in handling islands which disappear but cannot handle
new islands or replacement islands.  The system is (or should be!) entirely
compatible with the distributed evaluator, so you can have multiple islands,
each with their own little master/slave evaluation facility.  The system also
handles (or should) checkpointing properly.

IslandExchange requires that you define an ECJ process as a "server" and
the others as "clients".  If you like, a process can serve both as a server
and as a client.  The clients all connect to the server and are told by the
server how to hook up with one another in the desired topology.  The server
also communicates signals to the clients, notably telling them to shut 
themselves down when one of the clients has discovered an optimal solution.

The directories

  3-Island  8-Island

...contain examples of 3- and 8-island models where the server is also a
client.  The directory

  2-Island

... contains an example of a simple 2-Island model with a separate server 
(thus 2 clients and 1 server).  Note that to run the server separately, you
fire up ECJ not with ec.Evolve but with ec.exchange.IslandExchange.  See the
README file in that directory for more information.

There are a number of options in the island model, described more fully
in the IslandExchange class documentation.  Here's a quick overview of some
of them.

A process is told to be a server (possibly in addition to being a client) with
the parameter

  exch.i-am-server=true

Servers work by listening in on a socket port.  You specify this port as an
integer, ideally above 2000 or so.  The clients will all need to know this
port number as well.  The port is defined as:

  exch.server-port= ...

Communication between clients is by default compressed.  Note that Java's
compression routines are broken (they don't support PARTIAL_FLUSH), so we
have to rely on a third-party library called JZLIB.  You can get the jar
file for this library on the ECJ main web page or at
http://www.jcraft.com/jzlib/

To turn compression OFF for some reason, you'd say

  exch.compression = false

A synchronous island model (where all islands send and receive at the same
time) is defined by the server parameter:

  exch.sync=true

If this is the case, then the server can specify when the at what generation
the exchanges begin with

  exch.start= ...

... and also specify the interval between exchanges as:

  exch.mode= ...

By default, ECJ does *asynchronous* exchanges instead, where each island is
told independently what generation it should start at and what interval it
should use, and the islands are free to go at their own pace rather than wait
for the other islands synchronously.  

Islands each have a "mailbox" which receives incoming individuals from the 
other islands, and after breeding they check and empty that mailbox, 
replacing some individuals in the current population with the incoming 
immigrants.  The selection procedure for the individuals to be replaced is by 
default random selection, but you can change that (see below).

The server defines the number of islands as:

  exch.num-islands= ...

Each island is defined with several parameters in the server's parameter files.
In the examples below, replace n with the numbers 0 through the number of
islands (minus 1).

  exch.island.n.id  The name of island number n (a string)
  exch.island.n.num-mig How many islands this island sends to.
  exch.island.n.mig.m The name of island number m that this island
        sends to.  (m is a number from 0 to
        exch.island.n.num-mig minus 1).
  exch.island.n.size
  exch.size (default) How many individuals this island sends to
        each of the other islands at one time.
  exch.island.n.start 
  exch.start (default)  What generation the island should start sending
        (only used if asynchronous)
  exch.island.n.mod 
  exch.mod (default)  The interval between sends (only used with
        asynchronous)
  exch.island.n.mailbox-capacity  
  exch.mailbox-capacity (default) How large the island's mailbox should
          be.  This should be large enough to
          accept enough individuals from other
          islands, but not so big that it's
          larger than your population size!
          The mailbox will overflow if full.
          You'll need to tune this size if
          you have some islands that are much
          faster at sending out individuals
          than others are at incorporating them.

Once your server has defined all these topology elements, you just need to make
some clients.  Client parameters are quite simple.  The primary ones are:

  exch.server-addr  The IP address of the server, so the client
        knows where to connect and get its marching
        orders.
  exch.server-port  The socket port of the server.
  exch.client-port  The desired socket port of the client that
        other clients will connect to it via to set up
        the island model.  This should be different 
        than server-port if you have a client which is
        also a server.
  exch.id     The name of the client's island.  The server
        will use this name information to determine the
        topology as above.
  exch.select   The selection method used to pick individuals
        to emigrate TO other islands.
  exch.select-to-die  The selection method used to pick individuals
        to be replaced by incoming immigrants.  By
        default this is random selection.

There's more than this, but it's sufficient to understand what's going on in
the example directories.  For more description of how things work, see
the IslandExchange class documentation.