Island distribution scheme 🔗

The evolutionary algorithms implemented in OpenMOLE supports the island distribution scheme. This scheme make it possible to run multiple model execution on the remote environment and therefore reducing the queuing and initialisation overhead implied by the workload delegation.
In the islands distribution scheme, islands of population evolve for a while on a remote node before being merged back into the global population of your OpenMOLE instance. It means that each node run a small evolution algorithm and the results of each of these evolution is used to evolve the central population.
Each of the island are executed on the remote node unit until a termination criterion. This termination criterion can be either expressed as a total number of model evaluation or an execution time.
The island scheme is enabled using the by Island syntax. For instance:

// Generate a workflow that orchestrates 100 concurrent islands.
// The workflow stops when 10,000 individuals have been evaluated.
val evolution =
  NSGA2Evolution(
    genome = Seq(x in (0.0, 1.0), y in (0.0, 1.0)),
    objective = Seq(o1, o2),
    evaluation = model,
    termination = 100000,
    parallelism = 100
  ) by Island(5 minutes) hook (workDirectory / "evolution")

// For the sake of simplicity the generated workflow will run using 4 threads of the local machine.
// Island are generally more useful for remote execution environments
evolution on LocalEnvironment(4)

In the example above a 100 islands are submitted to the environment. Each of these island runs for 5 minutes. Once an island has ended the result is merge in the global population and a new island is submitted. The evolution stops when 100000 model evaluations have been executed within the islands.
Here is the syntax to stop the islands based on a given number of model executions (here 10 execution).

val evolution =
  NSGA2Evolution(
    genome = Seq(x in (0.0, 1.0), y in (0.0, 1.0)),
    objective = Seq(o1, o2),
    evaluation = model,
    termination = 10000,
    parallelism = 100
  ) by Island(10) hook (workDirectory / "evolution")

evolution on LocalEnvironment(4)

Steady state grouping 🔗

In some cases you might want to group the job execution generated by while not using island. This could happen, for instance, when the genetic algorithm consumes several gigs of memory (i.e. large PSE or OSE) but the node of the execution environment only provides a few gigs of RAM per job. In that case you can use steady state grouping:

val evolution =
  NSGA2Evolution(
    genome = Seq(x in (0.0, 1.0), y in (0.0, 1.0)),
    objective = Seq(o1, o2),
    evaluation = model,
    termination = 100000,
    parallelism = 1000
  ) by SteadyState(10) hook (workDirectory / "evolution")

evolution on LocalEnvironment(4)

This will keep the steady state evolution scheme, while grouping the job execution by 10. This will result in 100 concurrent jobs, submitted to the execution environment, each performing 10 model executions sequentially.