eoPopEvalFunc.h

//-----------------------------------------------------------------------------

#ifndef eoPopEvalFunc_H
#define eoPopEvalFunc_H

#include <eoEvalFunc.h>
#include <apply.h>

# ifdef WITH_MPI
#include <mpi/eoMpi.h>
#include <mpi/eoTerminateJob.h>
#include <mpi/eoMpiAssignmentAlgorithm.h>
#include <mpi/eoParallelApply.h>
#include <utils/eoParallel.h>

#include <cmath> // ceil
# endif // WITH_MPI

template<class EOT>
class eoPopEvalFunc : public eoBF<eoPop<EOT> & , eoPop<EOT> &, void>
{};

//           eoPopLoopEval

template<class EOT>
class eoPopLoopEval : public eoPopEvalFunc<EOT> {
public:
  eoPopLoopEval(eoEvalFunc<EOT> & _eval) : eval(_eval) {}

  void operator()(eoPop<EOT> & _parents, eoPop<EOT> & _offspring)
  {
      (void)_parents;
      apply<EOT>(eval, _offspring);
  }

private:
  eoEvalFunc<EOT> & eval;
};

#ifdef WITH_MPI

template<class EOT>
class eoParallelPopLoopEval : public eoPopEvalFunc<EOT>
{
    public:
        eoParallelPopLoopEval(
                // Job parameters
                eo::mpi::AssignmentAlgorithm& _assignAlgo,
                int _masterRank,
                // Default parameters for store
                eoEvalFunc<EOT> & _eval,
                int _packetSize = 1
                ) :
            assignAlgo( _assignAlgo ),
            masterRank( _masterRank ),
            needToDeleteStore( true ) // we used new, we'll have to use delete (RAII)
        {
            store = new eo::mpi::ParallelApplyStore<EOT>( _eval, _masterRank, _packetSize );
        }

        eoParallelPopLoopEval(
                // Job parameters
                eo::mpi::AssignmentAlgorithm& _assignAlgo,
                int _masterRank,
                eo::mpi::ParallelApplyStore<EOT>* _store
                ) :
            assignAlgo( _assignAlgo ),
            masterRank( _masterRank ),
            store( _store ),
            needToDeleteStore( false ) // we haven't used new for creating store, we don't care if we have to delete it (RAII).
        {
            // empty
        }

        ~eoParallelPopLoopEval()
        {
            // Only the master has to send the termination message
            if( eo::mpi::Node::comm().rank() == masterRank )
            {
                eo::mpi::EmptyJob job( assignAlgo, masterRank );
                job.run();
            }

            // RAII
            if( needToDeleteStore )
            {
                delete store;
            }
        }

        void operator()( eoPop<EOT> & _parents, eoPop<EOT> & _offspring )
        {
            (void)_parents;
            // Reinits the store and the scheduling algorithm
            store->data( _offspring );
            // For static scheduling, it's mandatory to reinit attributions
            int nbWorkers = assignAlgo.availableWorkers();
            assignAlgo.reinit( nbWorkers );
            if( ! eo::parallel.isDynamic() ) {
                store->data()->packetSize = ceil( static_cast<double>( _offspring.size() ) / nbWorkers );
            }
            // Effectively launches the job.
            eo::mpi::ParallelApply<EOT> job( assignAlgo, masterRank, *store );
            job.run();
        }

    private:
        // Scheduling algorithm
        eo::mpi::AssignmentAlgorithm & assignAlgo;
        // Master MPI rank
        int masterRank;

        // Store
        eo::mpi::ParallelApplyStore<EOT>* store;
        // Do we have to delete the store by ourselves ?
        bool needToDeleteStore;
};

#endif

//           eoTimeVaryingLoopEval

template<class EOT>
class eoTimeVaryingLoopEval : public eoPopEvalFunc<EOT> {
public:
  eoTimeVaryingLoopEval(eoEvalFunc<EOT> & _eval) : eval(_eval) {}

  void operator()(eoPop<EOT> & _parents, eoPop<EOT> & _offspring)
  {
    apply<EOT>(eval, _parents);
    apply<EOT>(eval, _offspring);
  }

private:
  eoEvalFunc<EOT> & eval;
};

#endif