D:/Projekt/ECF_trunk/ECF/AlgAEliGPEA.cpp

#include "ECF_base.h"
#include "ECF_derived.h"
#include "ECF_macro.h"

#include "AlgAEliGPEA.h"

const int MASTER = 0;
const int RANDOM = 0;
const int WORST = 1;


AlgAEliGpea::AlgAEliGpea()
{
    name_ = "AlgAEliGPEA";
    selectionOp.push_back(static_cast<SelectionOperatorP> (new SelRandomOp));
    selectionOp.push_back(static_cast<SelectionOperatorP> (new SelWorstOp));
}


void AlgAEliGpea::registerParameters(StateP state)
{
    int* tsizep = new int(3);
    state->getRegistry()->registerEntry(name_ + ".tsize", (voidP) tsizep, ECF::UINT);

    uint* jobSize = new uint(10);
    state->getRegistry()->registerEntry(name_ + ".jobsize", (voidP) jobSize, ECF::UINT);
}


bool AlgAEliGpea::initialize(StateP state)
{
    if(state->getCommunicator()->getCommRank() != MASTER)
        myJob_.resize(0);

    selectionOp[RANDOM]->initialize(state);
    selectionOp[WORST]->initialize(state);

    voidP tsizep = state->getRegistry()->getEntry(name_ + ".tsize");
    nTournament_ = *((uint*) tsizep.get());

    if(nTournament_ < 3) {
        ECF_LOG_ERROR(state, "Error: AlgAEliGPEA algorithm requires minimum tournament size of 3!");
        throw "";
    }

    voidP jobSizeP = state->getRegistry()->getEntry(name_ + ".jobsize");
    jobSize_ = *((uint*) jobSizeP.get());

    return true;
}


IndividualP AlgAEliGpea::performSingleTournament(DemeP deme)
{
    std::vector<IndividualP> tournament;
    for (uint i = 0; i < nTournament_; ++i) {
        tournament.push_back(selectionOp[RANDOM]->select(*deme));
    }

    IndividualP worst = selectionOp[WORST]->select(tournament);
    storeIndividual(worst);

    removeFrom(worst, tournament);  // remove pointer 'worst' from vector 'tournament'

    mate(tournament[0], tournament[1], worst);

    mutate(worst);

    return worst;
}


bool AlgAEliGpea::advanceGeneration(StateP state, DemeP deme)
{
    CommunicatorP comm = state->getCommunicator();

    if(comm->getCommRank() == MASTER) {

        std::vector<IndividualP> evalPool;
        uint iIter = 0;

        while(iIter < deme->size()) {

            // perform jobSize selections and operations
            for(uint ind = 0; ind < jobSize_ && iIter < deme->size(); ind++, iIter++) {
                IndividualP newInd = performSingleTournament(deme);

                if(isMember(newInd, evalPool) == false)
                    evalPool.push_back(newInd);
            }

            // evaluation-waiting loop
            do {
                // if a worker is ready
                if(!evalPool.empty() && comm->messageWaiting()) {
                    std::vector<uint> received = comm->recvFitnessVector(*deme, Comm::ANY_PROCESS);
                    state->increaseEvaluations((uint) received.size());
                    uint iWorker = comm->getLastSource();

                    // send job
                    storeGenotypes(evalPool);
                    comm->sendIndividuals(evalPool, iWorker);
                    evalPool.resize(0);

                    restoreIndividuals(received);
                    break;  // continue main loop
                }
                // do something useful in the meantime...
                else {
                    evaluate(evalPool.back());
                    setConsistency(evalPool.back());
                    evalPool.pop_back();

                    IndividualP newInd = performSingleTournament(deme);
                    iIter++;
                    if(isMember(newInd, evalPool) == false)
                        evalPool.push_back(newInd);
                }
            } while(iIter < deme->size());
        }

    }

    // WORKER
    else {
        myJob_.resize(0);
        comm->sendFitness(myJob_, MASTER);
        uint myJobSize = 1;

        // while individuals to evaluate
        while(myJobSize != 0) {

            myJobSize = comm->recvReplaceIndividuals(myJob_, MASTER);
            for(uint i = 0; i < myJobSize; i++)
                evaluate(myJob_[i]);

            comm->sendFitness(myJob_, MASTER, myJobSize);
        }
        ECF_LOG(state, 4, "Worker ends...");
    }

    return true;
}


void AlgAEliGpea::bcastTermination(StateP state)
{
    // master: if terminate condition is set, send all workers empty jobs
    if(state->getCommunicator()->getCommRank() == 0 && state->getTerminateCond()) {
        std::vector<IndividualP> empty;
        DemeP myDeme = state->getPopulation()->getLocalDeme();

        for(uint iWorker = 1; iWorker < state->getCommunicator()->getCommSize(); iWorker++) {
            if(state->getCommunicator()->messageWaiting(iWorker)) {
                std::vector<uint> received = state->getCommunicator()->recvFitnessVector(*myDeme, Comm::ANY_PROCESS);
                restoreIndividuals(received);
            }
            state->getCommunicator()->sendIndividuals(empty, iWorker);
        }

        // restore individuals to last consistent state
        restorePopulation();
    }

    // worker: evolution is over
    else if(state->getCommunicator()->getCommRank() != 0)
        state->setTerminateCond();
}