Added store management to eoPopEvalFunc.

eo/src/apply.h

@@ -88,15 +88,13 @@ void apply(eoUF<EOT&, void>& _proc, std::vector<EOT>& _pop)
 #ifdef WITH_MPI
 template<class EOT>
 void parallelApply(
-        eoUF<EOT&, void>& _proc,
         std::vector<EOT>& _pop,
         eo::mpi::AssignmentAlgorithm& _algo,
         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();
 }
 #endif

eo/src/eoPopEvalFunc.h

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

eo/src/mpi/eoMultiParallelApply.h

@@ -24,6 +24,11 @@ namespace eo
                     d->comm.recv( d->masterRank, Channel::Commands, order );
                 }
             }
+
+            ~ProcessTaskParallelEval()
+            {
+                delete _wrapped;
+            }
         };
 
         template< class EOT >
@@ -33,15 +38,20 @@ namespace eo
 
             ParallelEvalStore(
                     eoUF<EOT&, void> & _proc,
-                    std::vector<EOT>& _pop,
                     int _masterRank,
                     // long _maxTime = 0,
                     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> );
             }
+
+            void data( std::vector<EOT>& _pop )
+            {
+                ParallelApplyStore<EOT>::_data.init( _pop );
+            }
         };
     }
 }

eo/src/mpi/eoParallelApply.h

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

eo/test/mpi/eval.cpp

@@ -82,10 +82,40 @@ class eoRealSerializable : public eoReal< eoMinimizingFitness >, public eoserial
 
 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)
 {
     eo::mpi::Node::init( ac, av );
-    eo::log << eo::setlevel( eo::debug );
+    eo::log << eo::setlevel( eo::quiet );
 
     eoParser parser(ac, av);
 
@@ -106,17 +136,33 @@ int main(int ac, char** av)
     eoEvalFuncPtr< EOT, double, const std::vector< double >& > mainEval( real_value );
     eoEvalFuncCounter< EOT > eval( mainEval );
 
+    int rank = eo::mpi::Node::comm().rank();
+    eo::mpi::DynamicAssignmentAlgorithm assign;
+    if( rank == eo::mpi::DEFAULT_MASTER )
+    {
         eoPop< EOT > pop( popSize, init );
 
         eo::log << "Size of population : " << popSize << std::endl;
 
-    eo::log << eo::setlevel( eo::debug );
+        eo::mpi::ParallelEvalStore< EOT > store( eval, eo::mpi::DEFAULT_MASTER );
+        store.wrapHandleResponse( new CatBestAnswers );
 
-    eo::mpi::DynamicAssignmentAlgorithm assign;
+        eoParallelPopLoopEval< EOT > popEval( eval, assign, &store, eo::mpi::DEFAULT_MASTER, 3 );
-    eoParallelPopLoopEval< EOT > popEval( eval, assign, 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;
 }