nojhan/eodev
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Added store management to eoPopEvalFunc.

Browse source
This commit is contained in:
Benjamin Bouvier 2012-07-04 10:53:57 +02:00
commit 603268b053
5 changed files with 148 additions and 62 deletions
Download patch file Download diff file Expand all files Collapse all files

8
eo/src/apply.h
View file

@ -88,15 +88,13 @@ void apply(eoUF<EOT&, void>& _proc, std::vector<EOT>& _pop)
#ifdef WITH_MPI #ifdef WITH_MPI
template<class EOT> template<class EOT>
void parallelApply( void parallelApply(
eoUF<EOT&, void>& _proc,
std::vector<EOT>& _pop, std::vector<EOT>& _pop,
eo::mpi::AssignmentAlgorithm& _algo, eo::mpi::AssignmentAlgorithm& _algo,
int _masterRank, int _masterRank,
int _packetSize, eo::mpi::ParallelEvalStore<EOT> & _store )
int _maxTime)
{ {
eo::mpi::ParallelEvalStore<EOT> store( _proc, _pop, _masterRank, _packetSize ); _store.data( _pop );
eo::mpi::ParallelApply<EOT> job( _algo, _masterRank, store ); eo::mpi::ParallelApply<EOT> job( _algo, _masterRank, _store );
job.run(); job.run();
} }
#endif #endif

100
eo/src/eoPopEvalFunc.h
View file

@ -80,48 +80,72 @@ private:
#ifdef WITH_MPI #ifdef WITH_MPI
// TODO TODOB commenter // TODO TODOB commenter
template<class EOT> template<class EOT>
class eoParallelPopLoopEval : public eoPopEvalFunc<EOT> { class eoParallelPopLoopEval : public eoPopEvalFunc<EOT>
public: {
/** Ctor: set value of embedded eoEvalFunc */ public:
eoParallelPopLoopEval( /** Ctor: set value of embedded eoEvalFunc */
eoEvalFunc<EOT> & _eval, eoParallelPopLoopEval(
eo::mpi::AssignmentAlgorithm& _assignAlgo, eoEvalFunc<EOT> & _eval,
int _masterRank, eo::mpi::AssignmentAlgorithm& _assignAlgo,
int _packetSize = 1, int _masterRank,
int _maxTime = 0 int _packetSize = 1
) : ) :
eval(_eval), eval(_eval),
assignAlgo( _assignAlgo ), assignAlgo( _assignAlgo ),
masterRank( _masterRank ), masterRank( _masterRank ),
packetSize( _packetSize ), packetSize( _packetSize ),
maxTime( _maxTime ) needToDeleteStore( true )
{ {
// empty store = new eo::mpi::ParallelEvalStore<EOT>( _eval, _masterRank, _packetSize );
} }
~eoParallelPopLoopEval() eoParallelPopLoopEval(
{ eoEvalFunc<EOT> & _eval,
if( eo::mpi::Node::comm().rank() == masterRank ) eo::mpi::AssignmentAlgorithm& _assignAlgo,
{ eo::mpi::ParallelEvalStore<EOT>* _store,
eo::mpi::EmptyJob job( assignAlgo, masterRank ); int _masterRank,
job.run(); int _packetSize = 1
} ) :
} eval(_eval),
assignAlgo( _assignAlgo ),
masterRank( _masterRank ),
packetSize( _packetSize ),
needToDeleteStore( false ),
store( _store )
{
// empty
}
/** Do the job: simple loop over the offspring */ ~eoParallelPopLoopEval()
void operator()(eoPop<EOT> & _parents, eoPop<EOT> & _offspring) {
{ if( eo::mpi::Node::comm().rank() == masterRank )
(void)_parents; {
parallelApply<EOT>(eval, _offspring, assignAlgo, masterRank, packetSize, maxTime); eo::mpi::EmptyJob job( assignAlgo, masterRank );
} job.run();
}
private: if( needToDeleteStore )
eoEvalFunc<EOT> & eval; {
delete store;
}
}
eo::mpi::AssignmentAlgorithm & assignAlgo; /** Do the job: simple loop over the offspring */
int masterRank; void operator()(eoPop<EOT> & _parents, eoPop<EOT> & _offspring)
int packetSize; {
int maxTime; (void)_parents;
parallelApply<EOT>(_offspring, assignAlgo, masterRank, *store);
}
private:
eoEvalFunc<EOT> & eval;
eo::mpi::AssignmentAlgorithm & assignAlgo;
eo::mpi::ParallelEvalStore<EOT>* store;
int masterRank;
int packetSize;
bool needToDeleteStore;
}; };
#endif #endif

14
eo/src/mpi/eoMultiParallelApply.h
View file

@ -24,6 +24,11 @@ namespace eo
d->comm.recv( d->masterRank, Channel::Commands, order ); d->comm.recv( d->masterRank, Channel::Commands, order );
} }
} }
~ProcessTaskParallelEval()
{
delete _wrapped;
}
}; };
template< class EOT > template< class EOT >
@ -33,15 +38,20 @@ namespace eo
ParallelEvalStore( ParallelEvalStore(
eoUF<EOT&, void> & _proc, eoUF<EOT&, void> & _proc,
std::vector<EOT>& _pop,
int _masterRank, int _masterRank,
// long _maxTime = 0, // long _maxTime = 0,
int _packetSize = 1 int _packetSize = 1
) : ) :
ParallelApplyStore< EOT >( _proc, _pop, _masterRank, _packetSize ) ParallelApplyStore< EOT >( _proc, *( new std::vector<EOT> ), _masterRank, _packetSize )
// FIXME memory leak because of vector ==> use const correctness
{ {
wrapProcessTask( new ProcessTaskParallelEval<EOT> ); wrapProcessTask( new ProcessTaskParallelEval<EOT> );
} }
void data( std::vector<EOT>& _pop )
{
ParallelApplyStore<EOT>::_data.init( _pop );
}
}; };
} }
} }

12
eo/src/mpi/eoParallelApply.h
View file

@ -21,7 +21,7 @@ namespace eo
{ {
ParallelApplyData( ParallelApplyData(
eoUF<EOT&, void> & _proc, eoUF<EOT&, void> & _proc,
std::vector<EOT>& _pop, std::vector<EOT> & _pop,
int _masterRank, int _masterRank,
// long _maxTime = 0, // long _maxTime = 0,
int _packetSize int _packetSize
@ -35,6 +35,14 @@ namespace eo
tempArray = new EOT[ _packetSize ]; tempArray = new EOT[ _packetSize ];
} }
void init( std::vector<EOT>& _pop )
{
index = 0;
size = _pop.size();
data = _pop;
assignedTasks.clear();
}
~ParallelApplyData() ~ParallelApplyData()
{ {
delete [] tempArray; delete [] tempArray;
@ -180,7 +188,7 @@ namespace eo
ParallelApplyData<EOT>* data() { return &_data; } ParallelApplyData<EOT>* data() { return &_data; }
~ParallelApplyStore() virtual ~ParallelApplyStore()
{ {
delete _stf; delete _stf;
delete _hrf; delete _hrf;

66
eo/test/mpi/eval.cpp
View file

@ -82,10 +82,40 @@ class eoRealSerializable : public eoReal< eoMinimizingFitness >, public eoserial
typedef eoRealSerializable EOT; typedef eoRealSerializable EOT;
struct CatBestAnswers : public eo::mpi::HandleResponseParallelApply<EOT>
{
CatBestAnswers()
{
best.fitness( 1000000000. );
}
using eo::mpi::HandleResponseParallelApply<EOT>::_wrapped;
using eo::mpi::HandleResponseParallelApply<EOT>::d;
void operator()(int wrkRank)
{
int index = d->assignedTasks[wrkRank].index;
int size = d->assignedTasks[wrkRank].size;
(*_wrapped)( wrkRank );
for(int i = index; i < index+size; ++i)
{
if( best.fitness() < d->data[ i ].fitness() )
{
eo::log << eo::quiet << "Better solution found:" << d->data[i].fitness() << std::endl;
best = d->data[ i ];
}
}
}
protected:
EOT best;
};
int main(int ac, char** av) int main(int ac, char** av)
{ {
eo::mpi::Node::init( ac, av ); eo::mpi::Node::init( ac, av );
eo::log << eo::setlevel( eo::debug ); eo::log << eo::setlevel( eo::quiet );
eoParser parser(ac, av); eoParser parser(ac, av);
@ -106,17 +136,33 @@ int main(int ac, char** av)
eoEvalFuncPtr< EOT, double, const std::vector< double >& > mainEval( real_value ); eoEvalFuncPtr< EOT, double, const std::vector< double >& > mainEval( real_value );
eoEvalFuncCounter< EOT > eval( mainEval ); eoEvalFuncCounter< EOT > eval( mainEval );
eoPop< EOT > pop( popSize, init ); int rank = eo::mpi::Node::comm().rank();
eo::log << "Size of population : " << popSize << std::endl;
eo::log << eo::setlevel( eo::debug );
eo::mpi::DynamicAssignmentAlgorithm assign; eo::mpi::DynamicAssignmentAlgorithm assign;
eoParallelPopLoopEval< EOT > popEval( eval, assign, eo::mpi::DEFAULT_MASTER, 3 ); if( rank == eo::mpi::DEFAULT_MASTER )
popEval( pop, pop ); {
eoPop< EOT > pop( popSize, init );
eo::log << eo::quiet << "DONE!" << std::endl; eo::log << "Size of population : " << popSize << std::endl;
eo::mpi::ParallelEvalStore< EOT > store( eval, eo::mpi::DEFAULT_MASTER );
store.wrapHandleResponse( new CatBestAnswers );
eoParallelPopLoopEval< EOT > popEval( eval, assign, &store, eo::mpi::DEFAULT_MASTER, 3 );
eo::log << eo::quiet << "Before first evaluation." << std::endl;
popEval( pop, pop );
eo::log << eo::quiet << "After first evaluation." << std::endl;
pop = eoPop< EOT >( popSize, init );
popEval( pop, pop );
eo::log << eo::quiet << "After second evaluation." << std::endl;
eo::log << eo::quiet << "DONE!" << std::endl;
} else
{
eoPop< EOT > pop( popSize, init );
eoParallelPopLoopEval< EOT > popEval( eval, assign, eo::mpi::DEFAULT_MASTER, 3 );
popEval( pop, pop );
}
return 0; return 0;
} }