peoSyncIslandMig.h

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

// "peoSyncIslandMig.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 __peoSyncIslandMig_h
#define __peoSyncIslandMig_h


#include <queue>
#include <cassert>

#include <eoPeriodicContinue.h>

#include <utils/eoUpdater.h>

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

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



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

public:

        peoSyncIslandMig(
                                unsigned __frequency,
                                eoSelect< EOT >& __select,
                                eoReplacement< EOT >& __replace,
                                Topology& __topology,
                                eoPop< EOT >& __source,
                                eoPop< EOT >& __destination
        );

        void operator()();

        void pack();
        void unpack();

        void notifySending();


private:

        void emigrate();
        void immigrate();


private:

        eoPeriodicContinue< EOT > cont;
        eoSelect< EOT >& select;        // selection strategy
        eoReplacement< EOT >& replace;  // replacement strategy
        Topology& topology;             // neighboring topology

        // source and target 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;

        sem_t sync;
};


template< class EOT > peoSyncIslandMig< EOT > :: peoSyncIslandMig(

                unsigned __frequency,
                eoSelect< EOT >& __select,
                eoReplacement< EOT >& __replace,
                Topology& __topology,
                eoPop< EOT >& __source,
                eoPop< EOT >& __destination

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

        __topology.add( *this );
        sem_init( &sync, 0, 0 );
}


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

        lock(); {

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


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

        lock(); {

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

        sem_post( &sync );
}


template< class EOT > void peoSyncIslandMig< 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 peoSyncIslandMig< EOT > :: immigrate() {

        lock(); {

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


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

        if ( !cont( source ) ) {
        
                // sending emigrants
                emigrate();
                stop();

                // synchronizing
                sem_wait( &sync );
                getOwner()->setActive();

                // receiving immigrants
                immigrate();
        }
}


template< class EOT > void peoSyncIslandMig< EOT > :: notifySending() {

        lock(); {

                if ( imm.empty() ) {

                        printDebugMessage( "entering pasive mode\n" );
                        getOwner()->setPassive();
                }
        }
        unlock();

        resume();
}


#endif

---