ec.eval
Class MasterProblem

java.lang.Object
  extended byec.Problem
      extended byec.eval.MasterProblem
All Implemented Interfaces:
java.lang.Cloneable, GroupedProblemForm, Prototype, java.io.Serializable, Setup, SimpleProblemForm

public class MasterProblem
extends Problem
implements SimpleProblemForm, GroupedProblemForm

A MasterProblem object is a singleton object that uses remote slave processes to evaluate individuals in a distributed fashion. Evaluation of individuals is the only distributed behavior of the MasterProblem. All other behavior is delegated to a local instance of the actual problem (specified for the experiment via the eval.problem parameter). It is not intended for users to extend MasterProblem.

To take advantage of the distributed funtionality offered by MasterProblem, specify the eval.masterproblem parameter which must have a value of ec.eval.MasterProblem.

MasterProblem expects a number of slave processes to connect equal to the number of evaluation threads specified by the evalthreads parameter. The MasterProblem will not evaluate any individuals until the expected number of slave processes have registered. Any additional slave processes that register will be ignored.

There is no fault tolerance built in to the MasterProblem. If a slave process dies in the middle of evaluating an individual, the MasterProblem will become aware of the problem and abort the job. If a slave process hangs while processing an individual (if, for example, the slave is enters an infinite loop) the master process will hang waiting for a response.

Future versions of MasterProblem will take advantage of available Slave processes and adjust it's utilization of them as they come and go. This means that the MasterProblem will not abort unless all existing Slave processes die. The MasterProblem will also be equiped with a (user configurable) timeout mechanism. If the timeout expires while waiting for a response from a given slave, the evaluation will be aborted and the Slave will be considered dead. At this point, the MasterProblem will adjust it's utilization of available Slaves and restart the evaluation process.

Parameters

eval.compression
bool =true or false (default)
(whether to use compression when transmitting individuals to slave processes)
eval.master.port
int
(port to which slave process will connect and register themselves with the master process)
eval.masterproblem
classname, == ec.eval.MasterProblem
(the master problem class)

See Also:
Serialized Form

Field Summary
 boolean batchMode
           
 Problem problem
           
 ec.eval.MasterProblemServer server
           
 java.lang.Thread serverThread
           
 
Fields inherited from class ec.Problem
P_PROBLEM
 
Constructor Summary
MasterProblem()
           
 
Method Summary
 void describe(Individual ind, EvolutionState state, int threadnum, int log, int verbosity)
          "Reevaluates" an individual, for the purpose of printing out interesting facts about the individual in the context of the Problem, and logs the results.
 void evaluate(EvolutionState state, Individual[] inds, boolean[] updateFitness, boolean countVictoriesOnly, int threadnum)
          Evaluates the individuals found in ind together.
 void evaluate(EvolutionState state, Individual ind, int threadnum)
          Evaluates the individual in ind, if necessary (perhaps not evaluating them if their evaluated flags are true), and sets their fitness appropriately.
 void finishEvaluating(EvolutionState state, int threadnum)
          Will be called by the Evaluator after prepareToEvaluate(...) is called and then a series of individuals are evaluated.
 void initializeContacts(EvolutionState state)
           
 void postprocessPopulation(EvolutionState state, Population pop)
          Finish processing the population (such as fitness information) after evaluation.
 void prepareToEvaluate(EvolutionState state, int threadnum)
          May be called by the Evaluator prior to a series of individuals to evaluate, and then ended with a finishEvaluating(...).
 void preprocessPopulation(EvolutionState state, Population pop)
          Set up the population pop (such as fitness information) prior to evaluation.
 void reinitializeContacts(EvolutionState state)
           
 void setup(EvolutionState state, Parameter base)
          Sets up the object by reading it from the parameters stored in state, built off of the parameter base base.
 void shutdown()
          Called on the Problem prototype just before the system is shutting down.
 
Methods inherited from class ec.Problem
defaultBase, protoClone, protoCloneSimple, resetFromCheckpoint, restoreFromCheckpoint, setCheckpoint
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

problem

public Problem problem

server

public ec.eval.MasterProblemServer server

serverThread

public java.lang.Thread serverThread

batchMode

public boolean batchMode
Constructor Detail

MasterProblem

public MasterProblem()
Method Detail

setup

public void setup(EvolutionState state,
                  Parameter base)
Description copied from interface: Prototype
Sets up the object by reading it from the parameters stored in state, built off of the parameter base base. If an ancestor implements this method, be sure to call super.setup(state,base); before you do anything else.

For prototypes, setup(...) is typically called once for the prototype instance; cloned instances do not receive the setup(...) call. setup(...) may be called more than once; the only guarantee is that it will get called at least once on an instance or some "parent" object from which it was ultimately cloned.

Specified by:
setup in interface Prototype
Overrides:
setup in class Problem

prepareToEvaluate

public void prepareToEvaluate(EvolutionState state,
                              int threadnum)
Description copied from class: Problem
May be called by the Evaluator prior to a series of individuals to evaluate, and then ended with a finishEvaluating(...). If this is the case then the Problem is free to delay modifying the individuals or their fitnesses until at finishEvaluating(...). If no prepareToEvaluate(...) is called prior to evaluation, the Problem must complete its modification of the individuals and their fitnesses as they are evaluated as stipulated in the relevant evaluate(...) documentation for SimpleProblemForm or GroupedProblemForm. The default method does nothing.

Overrides:
prepareToEvaluate in class Problem

finishEvaluating

public void finishEvaluating(EvolutionState state,
                             int threadnum)
Description copied from class: Problem
Will be called by the Evaluator after prepareToEvaluate(...) is called and then a series of individuals are evaluated. However individuals may be evaluated without prepareToEvaluate or finishEvaluating being called at all. See the documentation for prepareToEvaluate for more information. The default method does nothing.

Overrides:
finishEvaluating in class Problem

evaluate

public void evaluate(EvolutionState state,
                     Individual ind,
                     int threadnum)
Description copied from interface: SimpleProblemForm
Evaluates the individual in ind, if necessary (perhaps not evaluating them if their evaluated flags are true), and sets their fitness appropriately.

Specified by:
evaluate in interface SimpleProblemForm

describe

public void describe(Individual ind,
                     EvolutionState state,
                     int threadnum,
                     int log,
                     int verbosity)
Description copied from interface: SimpleProblemForm
"Reevaluates" an individual, for the purpose of printing out interesting facts about the individual in the context of the Problem, and logs the results. This might be called to print out facts about the best individual in the population, for example.

Specified by:
describe in interface SimpleProblemForm

preprocessPopulation

public void preprocessPopulation(EvolutionState state,
                                 Population pop)
Description copied from interface: GroupedProblemForm
Set up the population pop (such as fitness information) prior to evaluation. Although this method is not static, you should not use it to write to any instance variables in the GroupedProblem instance; this is because it's possible that the instance used is in fact the prototype, and you will have no guarantees that your instance variables will remain valid during the evaluate(...) process. Do not assume that pop will be the same as state.pop -- it may not. state is only provided to give you access to EvolutionState features.

Specified by:
preprocessPopulation in interface GroupedProblemForm

postprocessPopulation

public void postprocessPopulation(EvolutionState state,
                                  Population pop)
Description copied from interface: GroupedProblemForm
Finish processing the population (such as fitness information) after evaluation. Although this method is not static, you should not use it to write to any instance variables in the GroupedProblem instance; this is because it's possible that the instance used is in fact the prototype, and you will have no guarantees that your instance variables will remain valid during the evaluate(...) process. Do not assume that pop will be the same as state.pop -- it may not. state is only provided to give you access to EvolutionState features.

Specified by:
postprocessPopulation in interface GroupedProblemForm

evaluate

public void evaluate(EvolutionState state,
                     Individual[] inds,
                     boolean[] updateFitness,
                     boolean countVictoriesOnly,
                     int threadnum)
Description copied from interface: GroupedProblemForm
Evaluates the individuals found in ind together. If updateFitness[i] is true, then you should use this evaluation to update the fitness of the individual in ind[i]. Individuals which are updated should have their fitnesses modified so that immediately after evaluation (and prior to postprocessPopulation(...) being called) individuals' fitnesses can be checked to see which is better than which. Do not assume that the individuals in ind will actually be in state.pop (they may not -- this method may be called at the end of a run to determine the best individual of the run in some kind of contest).

If countVictoriesOnly is true, you should update fitnesses such that if two individuals' fitnesses are compared, the one which has won the most times has a superior fitness. This will be used in single elimination tournament style evaluators.

Specified by:
evaluate in interface GroupedProblemForm

initializeContacts

public void initializeContacts(EvolutionState state)
Overrides:
initializeContacts in class Problem

reinitializeContacts

public void reinitializeContacts(EvolutionState state)
Overrides:
reinitializeContacts in class Problem

shutdown

public void shutdown()
Description copied from class: Problem
Called on the Problem prototype just before the system is shutting down. This allows the Problem to clean up open sockets it's created, etc.

Overrides:
shutdown in class Problem