This section is meant to give you a quick idea of how your program can be made to work with Simdist. This distribution also comes with a number of demo programs in various languages, described at the end of this section.

As mentioned in the introduction, the basic idea is to create a master process that contains the following loop:
do until termination:
  write n genomes (or any other type of job description) to standard output
  read n fitnesses (or any other type of result) from standard input
done


and a slave that performs the following loop:
while input is available:
  process input
  print output


The following steps suggest a process to get things working. The list is extensive to give you an idea of the process. Many of these steps may be skipped, but they might be useful for debugging. It may also be an idea to try some of them out on the demo programs.

1. Decide on a way of printing your genomes. The most straightforward is to put everything on a single line, but other options are possible. More about this below.
2. Write your master program, and run it to see that the output looks as expected.
3. Save the output from the master to a file and start work on the slave. For an EA, set population size to small, say 10, and run master >genomes.txt. The file genomes.txt will now typically contain 10 lines of text.
4. Write a slave that can read the genomes and test it by feeding it the genomes file: slave <genomes.txt. When done like this, the slave program should write ten lines of fitness values, AND THEN TERMINATE when it reaches the end of the file genomes.txt.
5. Do it the other way around, to see that the master correctly reads fitness values: slave <genomes.txt >fitnesses.txt, and then master <fitnesses.txt. The program master should now produce 20 lines of output, since it first prints 10 genomes, then reads the fitnesses for these, and finally prints the 10 genomes of the next generation.
6. Try the two together. First by master | slave, which should produce 10 fitness values, then pipeio master slave, which should run the entire evolution for the desired number of generations. It's a good idea to have master print status messages to standard error, so you can see that the program progresses as expected. If any of the programs take arguments, you must wrap the commands to pipeio in apostrophes or quotation marks, e.g. $ pipeio 'master --pop-size=10' "slave --speed=superfast"
7. Run them in parallel:
   $ simdist --master='master --pop-size=10' --slave=slave


IMPORTANT:

There is, of course, one snag: when moving from serial to parallel processing, Simdist must be able to tell your genomes apart, otherwise it will not be able to distribute them correctly to the slaves. Simdist accepts four ways of doing this:

• Every output spans a fixed number of lines. By default, Simdist expects each genome to occupy one line. If your genomes always use 3 lines, pass the following option to Simdist: --master-output-mode='SIMPLE 3'
• Each genome is wrapped in tags. The tag can be anything, but it must be a single line of text. Use --master-output-mode=EOF for this. The following is an example of three perfectly valid genomes:
  EOF
1 0 1 1 0 1
EOF
Hello,
1 0 1 1
1 0 0 0 0 1
1 1 0
Hello,
how are you
1 1 1 0 0 1 1 0
1 0 1 0 0 1 1 0
how are you

• The genomes are binary strings, prepended by a 4-byte integer indicating the length (in bytes) of the genome. Use --master-output-mode=BYTES.
• The genomes are binary and wrapped in EOF-markers taking a predefined number of bytes, e.g. 5: --master-output-mode='BIN-EOF 5'.

Demos for Matlab, Python and Lisp are found under the demos directory. In the src directory, you'll find the programs test-master, test-slave, s-test-master.sh and s-test-slave.sh. The two former are C++ programs, while the two latter are shell scripts.

A good place to start may be either the C++ programs in the src directory, or the Python programs in the demos directory.