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

peo style

Browse source 
git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@1120 331e1502-861f-0410-8da2-ba01fb791d7f
This commit is contained in:
canape 2008-03-12 11:21:25 +00:00
commit ceeaa4b533
5 changed files with 677 additions and 575 deletions
Download patch file Download diff file Expand all files Collapse all files

274
trunk/paradiseo-peo/src/core/peoAbstractDefs.h
View file

@ -10,201 +10,243 @@
template < typename Type > struct Entity; template < typename Type > struct Entity;
struct AbstractEntity { struct AbstractEntity
{
virtual ~AbstractEntity() {} virtual ~AbstractEntity() {}
template < typename EntityType > operator EntityType& () { template < typename EntityType > operator EntityType& ()
{
return ( dynamic_cast< Entity< EntityType >& >( *this ) ).entity; return ( dynamic_cast< Entity< EntityType >& >( *this ) ).entity;
} }
}; };
struct AbstractFunctor : virtual public AbstractEntity { struct AbstractFunctor : virtual public AbstractEntity
{
virtual ~AbstractFunctor() {} virtual ~AbstractFunctor() {}
virtual void operator()() {} virtual void operator()() {}
}; };
struct AbstractUnaryFunctor : virtual public AbstractEntity { struct AbstractUnaryFunctor : virtual public AbstractEntity
{
virtual ~AbstractUnaryFunctor() {} virtual ~AbstractUnaryFunctor() {}
virtual void operator()( AbstractEntity& dataEntity ) {} virtual void operator()( AbstractEntity& dataEntity ) {}
}; };
struct AbstractBinaryFunctor : virtual public AbstractEntity { struct AbstractBinaryFunctor : virtual public AbstractEntity
{
virtual ~AbstractBinaryFunctor() {} virtual ~AbstractBinaryFunctor() {}
virtual void operator()( AbstractEntity& dataEntityA, AbstractEntity& dataEntityB ) {}; virtual void operator()( AbstractEntity& dataEntityA, AbstractEntity& dataEntityB ) {};
}; };
template < typename EntityType > struct Entity : virtual public AbstractEntity { template < typename EntityType > struct Entity : virtual public AbstractEntity
{
Entity( EntityType& externalEntityRef ) : entity( externalEntityRef ) {} Entity( EntityType& externalEntityRef ) : entity( externalEntityRef ) {}
EntityType& entity; EntityType& entity;
}; };
template < typename FunctorType, typename DataType > struct FunctorEx : public Entity< DataType >, public AbstractFunctor { template < typename FunctorType, typename DataType > struct FunctorEx : public Entity< DataType >, public AbstractFunctor
{
FunctorEx( FunctorType& externalFunctorRef, DataType& externalDataRef ) FunctorEx( FunctorType& externalFunctorRef, DataType& externalDataRef )
: externalFunctor( externalFunctorRef ), Entity< DataType >( externalDataRef ) {} : externalFunctor( externalFunctorRef ), Entity< DataType >( externalDataRef ) {}
void operator()() { void operator()()
{
externalFunctor( Entity< DataType > :: entity ); externalFunctor( Entity< DataType > :: entity );
} }
FunctorType& externalFunctor; FunctorType& externalFunctor;
}; };
template < typename FunctorType > struct FunctorEx< FunctorType, void > : public Entity< AbstractEntity >, public AbstractFunctor { template < typename FunctorType > struct FunctorEx< FunctorType, void > : public Entity< AbstractEntity >, public AbstractFunctor
{
FunctorEx( FunctorType& externalFunctorRef ) FunctorEx( FunctorType& externalFunctorRef )
: externalFunctor( externalFunctorRef ), Entity< AbstractEntity >( *this ) {} : externalFunctor( externalFunctorRef ), Entity< AbstractEntity >( *this ) {}
void operator()() { void operator()()
{
externalFunctor(); externalFunctor();
} }
FunctorType& externalFunctor; FunctorType& externalFunctor;
}; };
template < typename ReturnType, typename DataType > struct FnFunctorEx template < typename ReturnType, typename DataType > struct FnFunctorEx
: public Entity< DataType >, public AbstractFunctor { : public Entity< DataType >, public AbstractFunctor
{
FnFunctorEx( ReturnType (*externalFunctorRef)( DataType& ), DataType& externalDataRef ) FnFunctorEx( ReturnType (*externalFunctorRef)( DataType& ), DataType& externalDataRef )
: externalFunctor( externalFunctorRef ), Entity< DataType >( externalDataRef ) {} : externalFunctor( externalFunctorRef ), Entity< DataType >( externalDataRef ) {}
void operator()() { void operator()()
{
externalFunctor( Entity< DataType > :: entity ); externalFunctor( Entity< DataType > :: entity );
} }
ReturnType (*externalFunctor)( DataType& ); ReturnType (*externalFunctor)( DataType& );
}; };
template < typename ReturnType > struct FnFunctorEx< ReturnType, void > template < typename ReturnType > struct FnFunctorEx< ReturnType, void >
: public Entity< AbstractEntity >, public AbstractFunctor { : public Entity< AbstractEntity >, public AbstractFunctor
{
FnFunctorEx( ReturnType (*externalFunctorRef)() ) FnFunctorEx( ReturnType (*externalFunctorRef)() )
: externalFunctor( externalFunctorRef ), Entity< AbstractEntity >( *this ) {} : externalFunctor( externalFunctorRef ), Entity< AbstractEntity >( *this ) {}
void operator()() { void operator()()
{
externalFunctor(); externalFunctor();
} }
ReturnType (*externalFunctor)(); ReturnType (*externalFunctor)();
}; };
template < typename FunctorType > struct UnaryFunctor : public Entity< FunctorType >, public AbstractUnaryFunctor { template < typename FunctorType > struct UnaryFunctor : public Entity< FunctorType >, public AbstractUnaryFunctor
{
UnaryFunctor( FunctorType& externalFunctorRef ) : Entity< FunctorType >( externalFunctorRef ) {} UnaryFunctor( FunctorType& externalFunctorRef ) : Entity< FunctorType >( externalFunctorRef ) {}
void operator()( AbstractEntity& dataEntity ) { void operator()( AbstractEntity& dataEntity )
{
Entity< FunctorType > :: entity( dataEntity ); Entity< FunctorType > :: entity( dataEntity );
} }
}; };
template < typename ReturnType, typename DataType > struct UnaryFnFunctor template < typename ReturnType, typename DataType > struct UnaryFnFunctor
: public Entity< AbstractEntity >, public AbstractUnaryFunctor { : public Entity< AbstractEntity >, public AbstractUnaryFunctor
{
UnaryFnFunctor( ReturnType (*externalFnRef)( DataType& ) ) : Entity< AbstractEntity >( *this ), externalFn( externalFnRef ) { UnaryFnFunctor( ReturnType (*externalFnRef)( DataType& ) ) : Entity< AbstractEntity >( *this ), externalFn( externalFnRef )
} {
}
void operator()( AbstractEntity& dataEntity ) { void operator()( AbstractEntity& dataEntity )
{
externalFn( dataEntity ); externalFn( dataEntity );
} }
ReturnType (*externalFn)( DataType& ); ReturnType (*externalFn)( DataType& );
}; };
template < typename FunctorType > struct BinaryFunctor : public Entity< FunctorType >, public AbstractBinaryFunctor { template < typename FunctorType > struct BinaryFunctor : public Entity< FunctorType >, public AbstractBinaryFunctor
{
BinaryFunctor( FunctorType& externalFunctorRef ) : Entity< FunctorType >( externalFunctorRef ) {} BinaryFunctor( FunctorType& externalFunctorRef ) : Entity< FunctorType >( externalFunctorRef ) {}
void operator()( AbstractEntity& dataEntityA, AbstractEntity& dataEntityB ) { void operator()( AbstractEntity& dataEntityA, AbstractEntity& dataEntityB )
{
Entity< FunctorType > :: entity( dataEntityA, dataEntityB ); Entity< FunctorType > :: entity( dataEntityA, dataEntityB );
} }
}; };
struct AbstractMsgTransferQueue : virtual public AbstractEntity { struct AbstractMsgTransferQueue : virtual public AbstractEntity
{
virtual ~AbstractMsgTransferQueue() {} virtual ~AbstractMsgTransferQueue() {}
virtual void pushMessage() {} virtual void pushMessage() {}
virtual void popMessage() {} virtual void popMessage() {}
virtual bool empty() { return true; } virtual bool empty()
{
return true;
}
virtual void packMessage() {} virtual void packMessage() {}
virtual void unpackMessage() {} virtual void unpackMessage() {}
}; };
template < typename EntityType > struct MsgTransferQueue : public Entity< EntityType >, public AbstractMsgTransferQueue { template < typename EntityType > struct MsgTransferQueue : public Entity< EntityType >, public AbstractMsgTransferQueue
{
MsgTransferQueue( EntityType& externalDataRef ) MsgTransferQueue( EntityType& externalDataRef )
: Entity< EntityType >( externalDataRef ) { : Entity< EntityType >( externalDataRef )
{
aggregationFunctor = new BinaryFunctor< AssignmentFunctor >( assignmentFunctor ); aggregationFunctor = new BinaryFunctor< AssignmentFunctor >( assignmentFunctor );
} }
template < typename FunctorType > template < typename FunctorType >
MsgTransferQueue( EntityType& externalDataRef, FunctorType& externalFunctorRef ) MsgTransferQueue( EntityType& externalDataRef, FunctorType& externalFunctorRef )
: Entity< EntityType >( externalDataRef ) { : Entity< EntityType >( externalDataRef )
{
aggregationFunctor = new BinaryFunctor< FunctorType >( externalFunctorRef ); aggregationFunctor = new BinaryFunctor< FunctorType >( externalFunctorRef );
} }
~MsgTransferQueue() { delete aggregationFunctor; } ~MsgTransferQueue()
{
delete aggregationFunctor;
}
void pushMessage() { void pushMessage()
{
transferQueue.push( Entity< EntityType > :: entity ); transferQueue.push( Entity< EntityType > :: entity );
} }
void popMessage() { void popMessage()
{
Entity< EntityType > message( transferQueue.front() ); Entity< EntityType > message( transferQueue.front() );
aggregationFunctor->operator()( *this, message ); aggregationFunctor->operator()( *this, message );
transferQueue.pop(); transferQueue.pop();
} }
bool empty() { return transferQueue.empty(); } bool empty()
{
return transferQueue.empty();
}
void packMessage() { void packMessage()
{
pack( transferQueue.front() ); pack( transferQueue.front() );
transferQueue.pop(); transferQueue.pop();
} }
void unpackMessage() { void unpackMessage()
{
EntityType transferredData; EntityType transferredData;
unpack( transferredData ); unpack( transferredData );
transferQueue.push( transferredData ); transferQueue.push( transferredData );
} }
struct AssignmentFunctor { struct AssignmentFunctor
void operator()( EntityType& A, EntityType& B ) { A = B; } {
} assignmentFunctor; void operator()( EntityType& A, EntityType& B )
{
A = B;
}
} assignmentFunctor;
std::queue< EntityType > transferQueue; std::queue< EntityType > transferQueue;
AbstractBinaryFunctor* aggregationFunctor; AbstractBinaryFunctor* aggregationFunctor;
}; };

174
trunk/paradiseo-peo/src/peoAsyncDataTransfer.h
View file

@ -16,104 +16,107 @@
#include "core/peo_debug.h" #include "core/peo_debug.h"
class peoAsyncDataTransfer : public Cooperative, public eoUpdater { class peoAsyncDataTransfer : public Cooperative, public eoUpdater
public:
template< typename EndPointType >
peoAsyncDataTransfer(
EndPointType& __endPoint,
Topology& __topology
) : topology( __topology )
{ {
source = new MsgTransferQueue< EndPointType >( __endPoint ); public:
destination = new MsgTransferQueue< EndPointType >( __endPoint );
__topology.add( *this );
}
template< typename EndPointType, typename FunctorType > template< typename EndPointType >
peoAsyncDataTransfer( peoAsyncDataTransfer(
EndPointType& __endPoint, EndPointType& __endPoint,
Topology& __topology, Topology& __topology
FunctorType& externalFunctorRef
) : topology( __topology ) ) : topology( __topology )
{ {
source = new MsgTransferQueue< EndPointType >( __endPoint, externalFunctorRef ); source = new MsgTransferQueue< EndPointType >( __endPoint );
destination = new MsgTransferQueue< EndPointType >( __endPoint, externalFunctorRef ); destination = new MsgTransferQueue< EndPointType >( __endPoint );
__topology.add( *this ); __topology.add( *this );
} }
template< typename SourceEndPointType, typename DestinationEndPointType > template< typename EndPointType, typename FunctorType >
peoAsyncDataTransfer( peoAsyncDataTransfer(
SourceEndPointType& __source, EndPointType& __endPoint,
DestinationEndPointType& __destination, Topology& __topology,
Topology& __topology FunctorType& externalFunctorRef
) : topology( __topology ) ) : topology( __topology )
{ {
source = new MsgTransferQueue< SourceEndPointType >( __source ); source = new MsgTransferQueue< EndPointType >( __endPoint, externalFunctorRef );
destination = new MsgTransferQueue< DestinationEndPointType >( __destination ); destination = new MsgTransferQueue< EndPointType >( __endPoint, externalFunctorRef );
__topology.add( *this ); __topology.add( *this );
} }
template< typename SourceEndPointType, typename DestinationEndPointType, typename FunctorType > template< typename SourceEndPointType, typename DestinationEndPointType >
peoAsyncDataTransfer( peoAsyncDataTransfer(
SourceEndPointType& __source, SourceEndPointType& __source,
DestinationEndPointType& __destination, DestinationEndPointType& __destination,
Topology& __topology, Topology& __topology
FunctorType& externalFunctorRef
) : topology( __topology ) ) : topology( __topology )
{ {
source = new MsgTransferQueue< SourceEndPointType >( __source, externalFunctorRef ); source = new MsgTransferQueue< SourceEndPointType >( __source );
destination = new MsgTransferQueue< DestinationEndPointType >( __destination, externalFunctorRef ); destination = new MsgTransferQueue< DestinationEndPointType >( __destination );
__topology.add( *this ); __topology.add( *this );
} }
~peoAsyncDataTransfer() { template< typename SourceEndPointType, typename DestinationEndPointType, typename FunctorType >
delete source; peoAsyncDataTransfer(
delete destination;
} SourceEndPointType& __source,
DestinationEndPointType& __destination,
Topology& __topology,
FunctorType& externalFunctorRef
) : topology( __topology )
{
source = new MsgTransferQueue< SourceEndPointType >( __source, externalFunctorRef );
destination = new MsgTransferQueue< DestinationEndPointType >( __destination, externalFunctorRef );
__topology.add( *this );
}
~peoAsyncDataTransfer()
{
delete source;
delete destination;
}
void operator()(); void operator()();
void pack(); void pack();
void unpack(); void unpack();
void packSynchronizeReq(); void packSynchronizeReq();
private: private:
void sendData(); void sendData();
void receiveData(); void receiveData();
private: private:
// the neighboring topology // the neighboring topology
Topology& topology; Topology& topology;
// source and destination end-points // source and destination end-points
AbstractMsgTransferQueue* source; AbstractMsgTransferQueue* source;
AbstractMsgTransferQueue* destination; AbstractMsgTransferQueue* destination;
std :: queue< Cooperative* > coop_em; std :: queue< Cooperative* > coop_em;
}; };
void peoAsyncDataTransfer :: pack() { void peoAsyncDataTransfer :: pack()
{
lock (); lock ();
@ -124,48 +127,55 @@ void peoAsyncDataTransfer :: pack() {
unlock(); unlock();
} }
void peoAsyncDataTransfer :: unpack() { void peoAsyncDataTransfer :: unpack()
{
lock (); lock ();
destination->unpackMessage(); destination->unpackMessage();
unlock(); unlock();
} }
void peoAsyncDataTransfer :: packSynchronizeReq() { void peoAsyncDataTransfer :: packSynchronizeReq()
{
} }
void peoAsyncDataTransfer :: sendData() { void peoAsyncDataTransfer :: sendData()
{
std :: vector< Cooperative* > in, out; std :: vector< Cooperative* > in, out;
topology.setNeighbors( this, in, out ); topology.setNeighbors( this, in, out );
for ( unsigned i = 0; i < out.size(); i++ ) { for ( unsigned i = 0; i < out.size(); i++ )
{
source->pushMessage(); source->pushMessage();
coop_em.push( out[i] ); coop_em.push( out[i] );
send( out[i] ); send( out[i] );
printDebugMessage( "peoAsyncDataTransfer: sending data." ); printDebugMessage( "peoAsyncDataTransfer: sending data." );
} }
} }
void peoAsyncDataTransfer :: receiveData() { void peoAsyncDataTransfer :: receiveData()
{
lock (); lock ();
{ {
while ( !( destination->empty() ) ) { while ( !( destination->empty() ) )
{
printDebugMessage( "peoAsyncDataTransfer: received data." ); printDebugMessage( "peoAsyncDataTransfer: received data." );
destination->popMessage(); destination->popMessage();
printDebugMessage( "peoAsyncDataTransfer: done reading data." ); printDebugMessage( "peoAsyncDataTransfer: done reading data." );
} }
} }
unlock(); unlock();
} }
void peoAsyncDataTransfer :: operator()() { void peoAsyncDataTransfer :: operator()()
{
sendData(); // sending data sendData(); // sending data
receiveData(); // receiving data receiveData(); // receiving data

312
trunk/paradiseo-peo/src/peoSyncDataTransfer.h
View file

@ -22,131 +22,134 @@
class peoSyncDataTransfer : public Cooperative, public eoUpdater class peoSyncDataTransfer : public Cooperative, public eoUpdater
{
public:
template< typename EndPointType >
peoSyncDataTransfer(
EndPointType& __endPoint,
Topology& __topology
) : topology( __topology )
{
source = new MsgTransferQueue< EndPointType >( __endPoint );
destination = new MsgTransferQueue< EndPointType >( __endPoint );
__topology.add( *this );
sem_init( &sync, 0, 0 );
}
template< typename EndPointType, typename FunctorType >
peoSyncDataTransfer(
EndPointType& __endPoint,
Topology& __topology,
FunctorType& externalFunctorRef
) : topology( __topology )
{
source = new MsgTransferQueue< EndPointType >( __endPoint, externalFunctorRef );
destination = new MsgTransferQueue< EndPointType >( __endPoint, externalFunctorRef );
__topology.add( *this );
sem_init( &sync, 0, 0 );
}
template< typename SourceEndPointType, typename DestinationEndPointType >
peoSyncDataTransfer(
SourceEndPointType& __source,
DestinationEndPointType& __destination,
Topology& __topology
) : topology( __topology )
{
source = new MsgTransferQueue< SourceEndPointType >( __source );
destination = new MsgTransferQueue< DestinationEndPointType >( __destination );
__topology.add( *this );
sem_init( &sync, 0, 0 );
}
template< typename SourceEndPointType, typename DestinationEndPointType, typename FunctorType >
peoSyncDataTransfer(
SourceEndPointType& __source,
DestinationEndPointType& __destination,
Topology& __topology,
FunctorType& externalFunctorRef
) : topology( __topology )
{
source = new MsgTransferQueue< SourceEndPointType >( __source, externalFunctorRef );
destination = new MsgTransferQueue< DestinationEndPointType >( __destination, externalFunctorRef );
__topology.add( *this );
sem_init( &sync, 0, 0 );
}
void operator()();
void pack();
void unpack();
void packSynchronizeReq();
void notifySending();
void notifyReceiving();
void notifySendingSyncReq();
void notifySynchronized();
private:
void sendData();
void receiveData();
Topology& topology; // neighboring topology
// source and destination end-points
AbstractMsgTransferQueue* source;
AbstractMsgTransferQueue* destination;
std :: queue< Cooperative* > coop_em;
sem_t sync;
bool standbyTransfer;
std :: vector< Cooperative* > in, out, all;
unsigned nbTransfersIn, nbTransfersOut;
};
void peoSyncDataTransfer :: pack()
{ {
public:
template< typename EndPointType >
peoSyncDataTransfer(
EndPointType& __endPoint,
Topology& __topology
) : topology( __topology )
{
source = new MsgTransferQueue< EndPointType >( __endPoint );
destination = new MsgTransferQueue< EndPointType >( __endPoint );
__topology.add( *this );
sem_init( &sync, 0, 0 );
}
template< typename EndPointType, typename FunctorType >
peoSyncDataTransfer(
EndPointType& __endPoint,
Topology& __topology,
FunctorType& externalFunctorRef
) : topology( __topology )
{
source = new MsgTransferQueue< EndPointType >( __endPoint, externalFunctorRef );
destination = new MsgTransferQueue< EndPointType >( __endPoint, externalFunctorRef );
__topology.add( *this );
sem_init( &sync, 0, 0 );
}
template< typename SourceEndPointType, typename DestinationEndPointType >
peoSyncDataTransfer(
SourceEndPointType& __source,
DestinationEndPointType& __destination,
Topology& __topology
) : topology( __topology )
{
source = new MsgTransferQueue< SourceEndPointType >( __source );
destination = new MsgTransferQueue< DestinationEndPointType >( __destination );
__topology.add( *this );
sem_init( &sync, 0, 0 );
}
template< typename SourceEndPointType, typename DestinationEndPointType, typename FunctorType >
peoSyncDataTransfer(
SourceEndPointType& __source,
DestinationEndPointType& __destination,
Topology& __topology,
FunctorType& externalFunctorRef
) : topology( __topology )
{
source = new MsgTransferQueue< SourceEndPointType >( __source, externalFunctorRef );
destination = new MsgTransferQueue< DestinationEndPointType >( __destination, externalFunctorRef );
__topology.add( *this );
sem_init( &sync, 0, 0 );
}
void operator()();
void pack();
void unpack();
void packSynchronizeReq();
void notifySending();
void notifyReceiving();
void notifySendingSyncReq();
void notifySynchronized();
private:
void sendData();
void receiveData();
Topology& topology; // neighboring topology
// source and destination end-points
AbstractMsgTransferQueue* source;
AbstractMsgTransferQueue* destination;
std :: queue< Cooperative* > coop_em;
sem_t sync;
bool standbyTransfer;
std :: vector< Cooperative* > in, out, all;
unsigned nbTransfersIn, nbTransfersOut;
};
void peoSyncDataTransfer :: pack() {
::pack( coop_em.front()->getKey() ); ::pack( coop_em.front()->getKey() );
source->packMessage(); source->packMessage();
coop_em.pop(); coop_em.pop();
} }
void peoSyncDataTransfer :: unpack() { void peoSyncDataTransfer :: unpack()
{
destination->unpackMessage(); destination->unpackMessage();
} }
void peoSyncDataTransfer :: packSynchronizeReq() { void peoSyncDataTransfer :: packSynchronizeReq()
{
packSynchronRequest( all ); packSynchronRequest( all );
} }
@ -154,41 +157,48 @@ void peoSyncDataTransfer :: packSynchronizeReq() {
extern void wakeUpCommunicator(); extern void wakeUpCommunicator();
extern int getNodeRank(); extern int getNodeRank();
void peoSyncDataTransfer :: sendData() { void peoSyncDataTransfer :: sendData()
{
for ( unsigned i = 0; i < out.size(); i ++ ) { for ( unsigned i = 0; i < out.size(); i ++ )
{
source->pushMessage(); source->pushMessage();
coop_em.push( out[ i ] ); coop_em.push( out[ i ] );
send( out[ i ]); send( out[ i ]);
printDebugMessage( "peoSyncDataTransfer: sending data." ); printDebugMessage( "peoSyncDataTransfer: sending data." );
} }
wakeUpCommunicator(); wakeUpCommunicator();
} }
void peoSyncDataTransfer :: receiveData() { void peoSyncDataTransfer :: receiveData()
{
assert( !( destination->empty() ) ); assert( !( destination->empty() ) );
while ( !( destination->empty() ) ) { while ( !( destination->empty() ) )
{
printDebugMessage( "peoSyncDataTransfer: received data." ); printDebugMessage( "peoSyncDataTransfer: received data." );
destination->popMessage(); destination->popMessage();
printDebugMessage( "peoSyncDataTransfer: done extracting received data." ); printDebugMessage( "peoSyncDataTransfer: done extracting received data." );
} }
} }
void peoSyncDataTransfer :: operator()() { void peoSyncDataTransfer :: operator()()
{
standbyTransfer = false; standbyTransfer = false;
nbTransfersIn = nbTransfersOut = 0; nbTransfersIn = nbTransfersOut = 0;
topology.setNeighbors( this, in, out ); all = topology; topology.setNeighbors( this, in, out );
all = topology;
synchronizeCoopEx(); stop(); synchronizeCoopEx();
stop();
// sending data out // sending data out
sendData(); sendData();
@ -197,46 +207,54 @@ void peoSyncDataTransfer :: operator()() {
// receiving data in // receiving data in
receiveData(); receiveData();
synchronizeCoopEx(); stop(); synchronizeCoopEx();
stop();
} }
void peoSyncDataTransfer :: notifySending() { void peoSyncDataTransfer :: notifySending()
{
nbTransfersOut++; nbTransfersOut++;
printDebugMessage( "peoSyncDataTransfer: notified of the completion of a transfer round." ); printDebugMessage( "peoSyncDataTransfer: notified of the completion of a transfer round." );
getOwner()->setActive(); getOwner()->setActive();
if ( nbTransfersOut == out.size() && nbTransfersIn < in.size() ) { if ( nbTransfersOut == out.size() && nbTransfersIn < in.size() )
getOwner()->setPassive(); {
} getOwner()->setPassive();
}
} }
void peoSyncDataTransfer :: notifyReceiving() { void peoSyncDataTransfer :: notifyReceiving()
{
nbTransfersIn++; nbTransfersIn++;
printDebugMessage( "peoSyncIslandMig: notified of incoming data." ); printDebugMessage( "peoSyncIslandMig: notified of incoming data." );
if ( standbyTransfer ) { if ( standbyTransfer )
getOwner()->setActive(); {
if ( nbTransfersOut == out.size() && nbTransfersIn < in.size() ) getOwner()->setActive();
getOwner()->setPassive(); if ( nbTransfersOut == out.size() && nbTransfersIn < in.size() )
} getOwner()->setPassive();
}
if ( nbTransfersIn == in.size() ) { if ( nbTransfersIn == in.size() )
{
printDebugMessage( "peoSyncIslandMig: finished collecting incoming data." ); printDebugMessage( "peoSyncIslandMig: finished collecting incoming data." );
sem_post( &sync ); sem_post( &sync );
} }
} }
void peoSyncDataTransfer :: notifySendingSyncReq () { void peoSyncDataTransfer :: notifySendingSyncReq ()
{
getOwner()->setPassive(); getOwner()->setPassive();
printDebugMessage( "peoSyncIslandMig: synchronization request sent." ); printDebugMessage( "peoSyncIslandMig: synchronization request sent." );
} }
void peoSyncDataTransfer :: notifySynchronized () { void peoSyncDataTransfer :: notifySynchronized ()
{
printDebugMessage( "peoSyncIslandMig: cooperators synchronized." ); printDebugMessage( "peoSyncIslandMig: cooperators synchronized." );

163
trunk/paradiseo-peo/tutorial/Lesson5/main.cpp
View file

@ -11,108 +11,133 @@
#define MIGRATIONS_AT_N_GENERATIONS 5 #define MIGRATIONS_AT_N_GENERATIONS 5
#define NUMBER_OF_MIGRANTS 10 #define NUMBER_OF_MIGRANTS 10
struct Representation : public eoVector< eoMinimizingFitness, double > { struct Representation : public eoVector< eoMinimizingFitness, double >
{
Representation() { resize( SIZE ); } Representation()
}; {
resize( SIZE );
struct Init : public eoInit< Representation > {
void operator()( Representation& rep ) {
for ( int i = 0; i < SIZE; i++ ) {
rep[ i ] = (rng.uniform() - 0.5) * DEF_DOMAIN;
} }
} };
};
struct Eval : public eoEvalFunc< Representation > { struct Init : public eoInit< Representation >
{
void operator()( Representation& rep ) { void operator()( Representation& rep )
{
double fitnessValue = 0.0; for ( int i = 0; i < SIZE; i++ )
for ( int i = 0; i < SIZE; i++ ) { {
rep[ i ] = (rng.uniform() - 0.5) * DEF_DOMAIN;
fitnessValue += pow( rep[ i ], 2.0 ); }
} }
};
rep.fitness( fitnessValue ); struct Eval : public eoEvalFunc< Representation >
} {
};
struct MutationOp : public eoMonOp< Representation > { void operator()( Representation& rep )
{
bool operator()( Representation& rep ) { double fitnessValue = 0.0;
for ( int i = 0; i < SIZE; i++ )
{
unsigned int pos = (unsigned int)( rng.uniform() * SIZE ); fitnessValue += pow( rep[ i ], 2.0 );
rep[ pos ] = (rng.uniform() - 0.5) * DEF_DOMAIN; }
rep.invalidate(); rep.fitness( fitnessValue );
return true;
}
};
struct XoverOp : public eoQuadOp< Representation > {
bool operator()( Representation& repA, Representation& repB ) {
static Representation offA, offB;
double lambda = rng.uniform();
for ( int i = 0; i < SIZE; i++ ) {
offA[ i ] = lambda * repA[ i ] + ( 1.0 - lambda ) * repB[ i ];
offB[ i ] = lambda * repB[ i ] + ( 1.0 - lambda ) * repA[ i ];
} }
};
repA = offA; repB = offB; struct MutationOp : public eoMonOp< Representation >
{
repA.invalidate(); bool operator()( Representation& rep )
repB.invalidate(); {
return true; unsigned int pos = (unsigned int)( rng.uniform() * SIZE );
} rep[ pos ] = (rng.uniform() - 0.5) * DEF_DOMAIN;
};
rep.invalidate();
return true;
}
};
struct XoverOp : public eoQuadOp< Representation >
{
bool operator()( Representation& repA, Representation& repB )
{
static Representation offA, offB;
double lambda = rng.uniform();
for ( int i = 0; i < SIZE; i++ )
{
offA[ i ] = lambda * repA[ i ] + ( 1.0 - lambda ) * repB[ i ];
offB[ i ] = lambda * repB[ i ] + ( 1.0 - lambda ) * repA[ i ];
}
repA = offA;
repB = offB;
repA.invalidate();
repB.invalidate();
return true;
}
};
void pack( const Representation& rep ) { void pack( const Representation& rep )
{
if ( rep.invalid() ) ::pack( (unsigned int)0 ); if ( rep.invalid() ) ::pack( (unsigned int)0 );
else { else
::pack( (unsigned int)1 ); {
::pack( (double)(rep.fitness()) ); ::pack( (unsigned int)1 );
} ::pack( (double)(rep.fitness()) );
}
for ( unsigned int index = 0; index < SIZE; index++ ) { for ( unsigned int index = 0; index < SIZE; index++ )
::pack( (double)rep[ index ] ); {
} ::pack( (double)rep[ index ] );
}
} }
void unpack( Representation& rep ) { void unpack( Representation& rep )
{
eoScalarFitness<double, std::greater<double> > fitness; eoScalarFitness<double, std::greater<double> > fitness;
unsigned int validFitness; unsigned int validFitness;
unpack( validFitness ); unpack( validFitness );
if ( validFitness ) { if ( validFitness )
{
double fitnessValue; ::unpack( fitnessValue ); double fitnessValue;
rep.fitness( fitnessValue ); ::unpack( fitnessValue );
} rep.fitness( fitnessValue );
else { }
rep.invalidate(); else
} {
rep.invalidate();
}
double value; double value;
for ( unsigned int index = 0; index < SIZE; index++ ) { for ( unsigned int index = 0; index < SIZE; index++ )
::unpack( value ); {
rep[ index ] = value; ::unpack( value );
} rep[ index ] = value;
}
} }
int main( int __argc, char** __argv ) { int main( int __argc, char** __argv )
{
rng.reseed( time( NULL ) ); rng.reseed( time( NULL ) );

93
trunk/paradiseo-peo/tutorial/Lesson6/main.cpp
View file

@ -19,51 +19,58 @@
struct CoSearch struct CoSearch
{
CoSearch(
eoPop< Route >& A, eoPop< Route >& B,
peoAsyncDataTransfer& asyncTransferA, peoAsyncDataTransfer& asyncTransferB
)
: transferA( A ), transferB( B ),
asyncDataTransferA( asyncTransferA ), asyncDataTransferB( asyncTransferB )
{
}
void operator()()
{
for ( unsigned int index = 0; index < 100; index++ )
{
asyncDataTransferA();
asyncDataTransferB();
eoPop< Route > intermed;
intermed = transferA;
transferA = transferB;
transferB = intermed;
}
}
eoPop< Route >& transferA;
eoPop< Route >& transferB;
peoAsyncDataTransfer& asyncDataTransferA;
peoAsyncDataTransfer& asyncDataTransferB;
};
struct PushBackAggregation
{
void operator()( eoPop< Route >& A, eoPop< Route >& B )
{
for ( unsigned int index = 0; index < B.size(); index++ )
{
A.push_back( B[ index ] );
}
}
};
int main( int __argc, char** __argv )
{ {
CoSearch(
eoPop< Route >& A, eoPop< Route >& B,
peoAsyncDataTransfer& asyncTransferA, peoAsyncDataTransfer& asyncTransferB
)
: transferA( A ), transferB( B ),
asyncDataTransferA( asyncTransferA ), asyncDataTransferB( asyncTransferB ) {
}
void operator()() {
for ( unsigned int index = 0; index < 100; index++ ) {
asyncDataTransferA();
asyncDataTransferB();
eoPop< Route > intermed;
intermed = transferA;
transferA = transferB;
transferB = intermed;
}
}
eoPop< Route >& transferA;
eoPop< Route >& transferB;
peoAsyncDataTransfer& asyncDataTransferA;
peoAsyncDataTransfer& asyncDataTransferB;
};
struct PushBackAggregation {
void operator()( eoPop< Route >& A, eoPop< Route >& B ) {
for ( unsigned int index = 0; index < B.size(); index++ ) {
A.push_back( B[ index ] );
}
}
};
int main( int __argc, char** __argv ) {
peo :: init( __argc, __argv ); peo :: init( __argc, __argv );
loadParameters( __argc, __argv ); loadParameters( __argc, __argv );