/*!
* \brief Read individuals of a bag.
* \param inIter XML iterator to read the individuals from.
* \param ioContext Evolutionary context.
*/
void IndividualBag::readIndividuals(PACC::XML::ConstIterator inIter, Context& ioContext)
{
Beagle_StackTraceBeginM();
clear();
Individual::Handle lPrevIndivHandle = ioContext.getIndividualHandle();
unsigned int lPrevIndivIndex = ioContext.getIndividualIndex();
for(PACC::XML::ConstIterator lIter=inIter; lIter; ++lIter) {
if(lIter->getType() != PACC::XML::eData) continue;
if(lIter->getValue() == "NullHandle") {
push_back(NULL);
continue;
} else if(lIter->getValue() != "Individual") continue;
Individual::Alloc::Handle lIndivAlloc = NULL;
std::string lIndivTypeName = lIter->getAttribute("type");
const Factory& lFactory = ioContext.getSystem().getFactory();
if(lIndivTypeName.empty()) {
lIndivAlloc =
castHandleT<Individual::Alloc>(lFactory.getConceptAllocator("Individual"));
} else {
lIndivAlloc =
castHandleT<Individual::Alloc>(lFactory.getAllocator(lIndivTypeName));
}
Individual::Handle lReadIndiv = castHandleT<Individual>(lIndivAlloc->allocate());
const unsigned int lBackIndex = size();
push_back(lReadIndiv);
ioContext.setIndividualHandle(lReadIndiv);
ioContext.setIndividualIndex(lBackIndex);
lReadIndiv->readWithContext(lIter, ioContext);
}
ioContext.setIndividualIndex(lPrevIndivIndex);
ioContext.setIndividualHandle(lPrevIndivHandle);
Beagle_StackTraceEndM();
}
void Beagle::MPI::EvaluationOp::evaluatorOperate(Deme& ioDeme, Context& ioContext) {
try {
//char lMessage[4096];
int lMessageSize;
MPI_Status lStatus;
int lSource;
bool lDone = false;
while(!lDone) {
//Receive an individual to evaluate
MPI_Recv(&lMessageSize, 1, MPI_INT, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &lStatus);
lSource = lStatus.MPI_SOURCE;
if(lStatus.MPI_TAG == eEvolutionEnd) {
Beagle_LogDetailedM(
ioContext.getSystem().getLogger(),
"evaluation", "Beagle::MPIEvaluationOp",
std::string("End of evolution received from process ") + int2str(lSource)
);
lDone = true;
} else {
char *lMessage = new char[lMessageSize];
unsigned int lGeneration;
MPI_Recv(lMessage, lMessageSize, MPI_CHAR, lSource, MPI_ANY_TAG, MPI_COMM_WORLD, &lStatus);
MPI_Recv(&lGeneration, 1, MPI_INT, lSource, MPI_ANY_TAG, MPI_COMM_WORLD, &lStatus);
ioContext.setGeneration(lGeneration);
Beagle_LogTraceM(
ioContext.getSystem().getLogger(),
"evaluation", "Beagle::MPIEvaluationOp",
std::string("Evaluating individual send from process ") + int2str(lSource)
);
//Parse the received individual
std::istringstream lStreamIn(lMessage);
PACC::XML::Document lXMLParser;
lXMLParser.parse(lStreamIn);
PACC::XML::ConstIterator lIndividualRootNode = lXMLParser.getFirstRoot();
//Read the received individual
ioContext.getDeme().resize(0);
Individual::Handle lIndividual = castHandleT<Individual>(ioContext.getDeme().getTypeAlloc()->allocate());
lIndividual->readWithContext(lIndividualRootNode,ioContext);
ioContext.setIndividualHandle(lIndividual);
ioContext.setIndividualIndex(0);
// Beagle_LogDebugM(
// ioContext.getSystem().getLogger(),
// "evaluation", "Beagle::MPIEvaluationOp",
// std::string("Individual received: ") + lIndividual->serialize()
// );
//Free message string
delete [] lMessage;
//Evaluated the fitness of the received individual
Fitness::Handle lFitness = evaluate(*lIndividual, ioContext);
//Send back the fitness
std::ostringstream lStreamOut;
PACC::XML::Streamer lXMLStream(lStreamOut);
lFitness->write(lXMLStream);
//std::cout << "Sending fitness of size " << lStreamOut.str().size()+1 << ":" << std::endl << lStreamOut.str() << std::endl;
lMessageSize = lStreamOut.str().size()+1;
Beagle_LogTraceM(
ioContext.getSystem().getLogger(),
"evaluation", "Beagle::MPIEvaluationOp",
std::string("Sending back fitness")
);
MPI_Send(&lMessageSize, 1, MPI_INT, lSource, eMessageSize, MPI_COMM_WORLD);
MPI_Send(const_cast<char*>(lStreamOut.str().data()), lMessageSize, MPI_CHAR, lSource, eFitness, MPI_COMM_WORLD);
}
}
} catch(Exception& inException) {
std::cerr << "Exception catched in evaluator:" << std::endl << std::flush;
std::cerr << inException.what() << std::endl << std::flush;
exit(1);
}
catch(std::exception& inException) {
std::cerr << "Standard exception catched in evaluator:" << std::endl << std::flush;
std::cerr << inException.what() << std::endl << std::flush;
exit(1);
}
}