peoAsyncIslandMig.h

// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-

// "peoAsyncIslandMig.h"

// (c) OPAC Team, LIFL, August 2005

/* This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA

   Contact: paradiseo-help@lists.gforge.inria.fr
*/

#ifndef __peoAsyncIslandMig_h
#define __peoAsyncIslandMig_h


#include <queue>

#include <utils/eoUpdater.h>

#include <eoContinue.h>
#include <eoSelect.h>
#include <eoReplacement.h>
#include <eoPop.h>

#include "core/topology.h"
#include "core/cooperative.h"
#include "core/eoPop_comm.h"
#include "core/peo_debug.h"



template< class EOT > class peoAsyncIslandMig : public Cooperative, public eoUpdater {

public:

        peoAsyncIslandMig( 
                                eoContinue< EOT >& __cont,
                                eoSelect< EOT >& __select,
                                eoReplacement< EOT >& __replace,
                                Topology& __topology,
                                eoPop< EOT >& __source,
                                eoPop< EOT >& __destination 
        );

        void operator()();
        
        void pack();
        void unpack();


private:

        void emigrate();
        void immigrate();


private:

        eoContinue< EOT >& cont;        // continuator
        eoSelect< EOT >& select;        // the selection strategy
        eoReplacement< EOT >& replace;  // the replacement strategy
        Topology& topology;             // the neighboring topology
        
        // source and destination populations
        eoPop< EOT >& source;
        eoPop< EOT >& destination;
        
        // immigrants & emigrants in the queue
        std :: queue< eoPop< EOT > > imm;
        std :: queue< eoPop< EOT > > em;
        
        std :: queue< Cooperative* > coop_em;
};


template< class EOT > peoAsyncIslandMig< EOT > :: peoAsyncIslandMig(

                eoContinue< EOT >& __cont,
                eoSelect< EOT >& __select,
                eoReplacement< EOT >& __replace,
                Topology& __topology,
                eoPop< EOT >& __source,
                eoPop< EOT >& __destination

        ) : cont( __cont ), select( __select ), replace( __replace ), topology( __topology ), source( __source ), destination( __destination )
{

        __topology.add( *this );
}


template< class EOT > void peoAsyncIslandMig< EOT > :: pack()
{

        lock(); {

		 :: pack( coop_em.front()->getKey() );
		 :: pack( em.front() );
                coop_em.pop();
                em.pop();
        }
        unlock();
}


template< class EOT > void peoAsyncIslandMig< EOT > :: unpack()
{

        lock(); {

                eoPop< EOT > mig;
		 :: unpack( mig );
                imm.push( mig );
        }
        unlock();
}


template< class EOT > void peoAsyncIslandMig< EOT > :: emigrate()
{

        std :: vector< Cooperative* >in, out;
        topology.setNeighbors( this, in, out );

        for ( unsigned i = 0; i < out.size(); i++ ) {
        
                eoPop< EOT > mig;
                select( source, mig );
                em.push( mig );
                coop_em.push( out[i] );
                send( out[i] );
                printDebugMessage( "sending some emigrants." );
        }
}


template< class EOT > void peoAsyncIslandMig< EOT > :: immigrate()
{

        lock(); {

                while ( !imm.empty() ) {

                        replace( destination, imm.front() );
                        imm.pop();
                        printDebugMessage( "receiving some immigrants." );
                }
        }
        unlock();
}


template< class EOT > void peoAsyncIslandMig< EOT > :: operator()() {

        if ( !cont( source ) ) {

                emigrate();     // sending emigrants
                immigrate();    // receiving immigrants
        }
}


#endif

---