From ceeaa4b5335b2cfd8737e09db9ad67ae58837f86 Mon Sep 17 00:00:00 2001 From: canape Date: Wed, 12 Mar 2008 11:21:25 +0000 Subject: [PATCH] peo style git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@1120 331e1502-861f-0410-8da2-ba01fb791d7f --- .../paradiseo-peo/src/core/peoAbstractDefs.h | 378 ++++++++++-------- .../paradiseo-peo/src/peoAsyncDataTransfer.h | 244 +++++------ trunk/paradiseo-peo/src/peoSyncDataTransfer.h | 346 ++++++++-------- trunk/paradiseo-peo/tutorial/Lesson5/main.cpp | 193 +++++---- trunk/paradiseo-peo/tutorial/Lesson6/main.cpp | 123 +++--- 5 files changed, 693 insertions(+), 591 deletions(-) diff --git a/trunk/paradiseo-peo/src/core/peoAbstractDefs.h b/trunk/paradiseo-peo/src/core/peoAbstractDefs.h index 2918c62c2..734144dd7 100755 --- a/trunk/paradiseo-peo/src/core/peoAbstractDefs.h +++ b/trunk/paradiseo-peo/src/core/peoAbstractDefs.h @@ -10,201 +10,243 @@ template < typename Type > struct Entity; -struct AbstractEntity { - - virtual ~AbstractEntity() {} - - template < typename EntityType > operator EntityType& () { - - return ( dynamic_cast< Entity< EntityType >& >( *this ) ).entity; - } -}; +struct AbstractEntity + { -struct AbstractFunctor : virtual public AbstractEntity { + virtual ~AbstractEntity() {} - virtual ~AbstractFunctor() {} - - virtual void operator()() {} -}; + template < typename EntityType > operator EntityType& () + { -struct AbstractUnaryFunctor : virtual public AbstractEntity { + return ( dynamic_cast< Entity< EntityType >& >( *this ) ).entity; + } + }; - virtual ~AbstractUnaryFunctor() {} - - virtual void operator()( AbstractEntity& dataEntity ) {} -}; +struct AbstractFunctor : virtual public AbstractEntity + { -struct AbstractBinaryFunctor : virtual public AbstractEntity { + virtual ~AbstractFunctor() {} - virtual ~AbstractBinaryFunctor() {} + virtual void operator()() {} + }; - virtual void operator()( AbstractEntity& dataEntityA, AbstractEntity& dataEntityB ) {}; -}; +struct AbstractUnaryFunctor : virtual public AbstractEntity + { + + virtual ~AbstractUnaryFunctor() {} + + virtual void operator()( AbstractEntity& dataEntity ) {} + }; + +struct AbstractBinaryFunctor : virtual public AbstractEntity + { + + virtual ~AbstractBinaryFunctor() {} + + virtual void operator()( AbstractEntity& dataEntityA, AbstractEntity& dataEntityB ) {}; + }; -template < typename EntityType > struct Entity : virtual public AbstractEntity { - - Entity( EntityType& externalEntityRef ) : entity( externalEntityRef ) {} - - EntityType& entity; -}; +template < typename EntityType > struct Entity : virtual public AbstractEntity + { -template < typename FunctorType, typename DataType > struct FunctorEx : public Entity< DataType >, public AbstractFunctor { - - FunctorEx( FunctorType& externalFunctorRef, DataType& externalDataRef ) - : externalFunctor( externalFunctorRef ), Entity< DataType >( externalDataRef ) {} - - void operator()() { - - externalFunctor( Entity< DataType > :: entity ); - } - - FunctorType& externalFunctor; -}; + Entity( EntityType& externalEntityRef ) : entity( externalEntityRef ) {} -template < typename FunctorType > struct FunctorEx< FunctorType, void > : public Entity< AbstractEntity >, public AbstractFunctor { - - FunctorEx( FunctorType& externalFunctorRef ) - : externalFunctor( externalFunctorRef ), Entity< AbstractEntity >( *this ) {} - - void operator()() { - - externalFunctor(); - } + EntityType& entity; + }; - FunctorType& externalFunctor; -}; +template < typename FunctorType, typename DataType > struct FunctorEx : public Entity< DataType >, public AbstractFunctor + { -template < typename ReturnType, typename DataType > struct FnFunctorEx - : public Entity< DataType >, public AbstractFunctor { + FunctorEx( FunctorType& externalFunctorRef, DataType& externalDataRef ) + : externalFunctor( externalFunctorRef ), Entity< DataType >( externalDataRef ) {} - FnFunctorEx( ReturnType (*externalFunctorRef)( DataType& ), DataType& externalDataRef ) - : externalFunctor( externalFunctorRef ), Entity< DataType >( externalDataRef ) {} - - void operator()() { - - externalFunctor( Entity< DataType > :: entity ); - } - - ReturnType (*externalFunctor)( DataType& ); -}; + void operator()() + { + + externalFunctor( Entity< DataType > :: entity ); + } + + FunctorType& externalFunctor; + }; + +template < typename FunctorType > struct FunctorEx< FunctorType, void > : public Entity< AbstractEntity >, public AbstractFunctor + { + + FunctorEx( FunctorType& externalFunctorRef ) + : externalFunctor( externalFunctorRef ), Entity< AbstractEntity >( *this ) {} + + void operator()() + { + + externalFunctor(); + } + + FunctorType& externalFunctor; + }; + +template < typename ReturnType, typename DataType > struct FnFunctorEx + : public Entity< DataType >, public AbstractFunctor + { + + FnFunctorEx( ReturnType (*externalFunctorRef)( DataType& ), DataType& externalDataRef ) + : externalFunctor( externalFunctorRef ), Entity< DataType >( externalDataRef ) {} + + void operator()() + { + + externalFunctor( Entity< DataType > :: entity ); + } + + ReturnType (*externalFunctor)( DataType& ); + }; template < typename ReturnType > struct FnFunctorEx< ReturnType, void > - : public Entity< AbstractEntity >, public AbstractFunctor { + : public Entity< AbstractEntity >, public AbstractFunctor + { - FnFunctorEx( ReturnType (*externalFunctorRef)() ) - : externalFunctor( externalFunctorRef ), Entity< AbstractEntity >( *this ) {} - - void operator()() { - - externalFunctor(); - } - - ReturnType (*externalFunctor)(); -}; + FnFunctorEx( ReturnType (*externalFunctorRef)() ) + : externalFunctor( externalFunctorRef ), Entity< AbstractEntity >( *this ) {} + + void operator()() + { + + externalFunctor(); + } + + ReturnType (*externalFunctor)(); + }; -template < typename FunctorType > struct UnaryFunctor : public Entity< FunctorType >, public AbstractUnaryFunctor { - - UnaryFunctor( FunctorType& externalFunctorRef ) : Entity< FunctorType >( externalFunctorRef ) {} - - void operator()( AbstractEntity& dataEntity ) { - - Entity< FunctorType > :: entity( dataEntity ); - } -}; +template < typename FunctorType > struct UnaryFunctor : public Entity< FunctorType >, public AbstractUnaryFunctor + { -template < typename ReturnType, typename DataType > struct UnaryFnFunctor - : public Entity< AbstractEntity >, public AbstractUnaryFunctor { - - UnaryFnFunctor( ReturnType (*externalFnRef)( DataType& ) ) : Entity< AbstractEntity >( *this ), externalFn( externalFnRef ) { - } - - void operator()( AbstractEntity& dataEntity ) { - - externalFn( dataEntity ); - } + UnaryFunctor( FunctorType& externalFunctorRef ) : Entity< FunctorType >( externalFunctorRef ) {} - ReturnType (*externalFn)( DataType& ); -}; + void operator()( AbstractEntity& dataEntity ) + { -template < typename FunctorType > struct BinaryFunctor : public Entity< FunctorType >, public AbstractBinaryFunctor { - - BinaryFunctor( FunctorType& externalFunctorRef ) : Entity< FunctorType >( externalFunctorRef ) {} - - void operator()( AbstractEntity& dataEntityA, AbstractEntity& dataEntityB ) { + Entity< FunctorType > :: entity( dataEntity ); + } + }; - Entity< FunctorType > :: entity( dataEntityA, dataEntityB ); - } -}; +template < typename ReturnType, typename DataType > struct UnaryFnFunctor + : public Entity< AbstractEntity >, public AbstractUnaryFunctor + { -struct AbstractMsgTransferQueue : virtual public AbstractEntity { - - virtual ~AbstractMsgTransferQueue() {} - - virtual void pushMessage() {} - virtual void popMessage() {} - - virtual bool empty() { return true; } - - virtual void packMessage() {} - virtual void unpackMessage() {} -}; + UnaryFnFunctor( ReturnType (*externalFnRef)( DataType& ) ) : Entity< AbstractEntity >( *this ), externalFn( externalFnRef ) + { + } -template < typename EntityType > struct MsgTransferQueue : public Entity< EntityType >, public AbstractMsgTransferQueue { - - MsgTransferQueue( EntityType& externalDataRef ) - : Entity< EntityType >( externalDataRef ) { - - aggregationFunctor = new BinaryFunctor< AssignmentFunctor >( assignmentFunctor ); - } - - template < typename FunctorType > - MsgTransferQueue( EntityType& externalDataRef, FunctorType& externalFunctorRef ) - : Entity< EntityType >( externalDataRef ) { - - aggregationFunctor = new BinaryFunctor< FunctorType >( externalFunctorRef ); - } - - ~MsgTransferQueue() { delete aggregationFunctor; } - - void pushMessage() { - - transferQueue.push( Entity< EntityType > :: entity ); - } - - void popMessage() { - - Entity< EntityType > message( transferQueue.front() ); - aggregationFunctor->operator()( *this, message ); - - transferQueue.pop(); - } - - bool empty() { return transferQueue.empty(); } - - void packMessage() { - - pack( transferQueue.front() ); - transferQueue.pop(); - } - - void unpackMessage() { - - EntityType transferredData; - unpack( transferredData ); - transferQueue.push( transferredData ); - } - - struct AssignmentFunctor { - void operator()( EntityType& A, EntityType& B ) { A = B; } - } assignmentFunctor; - - std::queue< EntityType > transferQueue; - AbstractBinaryFunctor* aggregationFunctor; -}; + void operator()( AbstractEntity& dataEntity ) + { + + externalFn( dataEntity ); + } + + ReturnType (*externalFn)( DataType& ); + }; + +template < typename FunctorType > struct BinaryFunctor : public Entity< FunctorType >, public AbstractBinaryFunctor + { + + BinaryFunctor( FunctorType& externalFunctorRef ) : Entity< FunctorType >( externalFunctorRef ) {} + + void operator()( AbstractEntity& dataEntityA, AbstractEntity& dataEntityB ) + { + + Entity< FunctorType > :: entity( dataEntityA, dataEntityB ); + } + }; + +struct AbstractMsgTransferQueue : virtual public AbstractEntity + { + + virtual ~AbstractMsgTransferQueue() {} + + virtual void pushMessage() {} + virtual void popMessage() {} + + virtual bool empty() + { + return true; + } + + virtual void packMessage() {} + virtual void unpackMessage() {} + }; + +template < typename EntityType > struct MsgTransferQueue : public Entity< EntityType >, public AbstractMsgTransferQueue + { + + MsgTransferQueue( EntityType& externalDataRef ) + : Entity< EntityType >( externalDataRef ) + { + + aggregationFunctor = new BinaryFunctor< AssignmentFunctor >( assignmentFunctor ); + } + + template < typename FunctorType > + MsgTransferQueue( EntityType& externalDataRef, FunctorType& externalFunctorRef ) + : Entity< EntityType >( externalDataRef ) + { + + aggregationFunctor = new BinaryFunctor< FunctorType >( externalFunctorRef ); + } + + ~MsgTransferQueue() + { + delete aggregationFunctor; + } + + void pushMessage() + { + + transferQueue.push( Entity< EntityType > :: entity ); + } + + void popMessage() + { + + Entity< EntityType > message( transferQueue.front() ); + aggregationFunctor->operator()( *this, message ); + + transferQueue.pop(); + } + + bool empty() + { + return transferQueue.empty(); + } + + void packMessage() + { + + pack( transferQueue.front() ); + transferQueue.pop(); + } + + void unpackMessage() + { + + EntityType transferredData; + unpack( transferredData ); + transferQueue.push( transferredData ); + } + + struct AssignmentFunctor + { + void operator()( EntityType& A, EntityType& B ) + { + A = B; + } + } assignmentFunctor; + + std::queue< EntityType > transferQueue; + AbstractBinaryFunctor* aggregationFunctor; + }; diff --git a/trunk/paradiseo-peo/src/peoAsyncDataTransfer.h b/trunk/paradiseo-peo/src/peoAsyncDataTransfer.h index 39dd8ae1c..bb0939875 100755 --- a/trunk/paradiseo-peo/src/peoAsyncDataTransfer.h +++ b/trunk/paradiseo-peo/src/peoAsyncDataTransfer.h @@ -16,157 +16,167 @@ #include "core/peo_debug.h" -class peoAsyncDataTransfer : public Cooperative, public eoUpdater { - - public: - - template< typename EndPointType > - peoAsyncDataTransfer( - - EndPointType& __endPoint, - Topology& __topology - - ) : topology( __topology ) +class peoAsyncDataTransfer : public Cooperative, public eoUpdater { - - source = new MsgTransferQueue< EndPointType >( __endPoint ); - destination = new MsgTransferQueue< EndPointType >( __endPoint ); - __topology.add( *this ); - } - template< typename EndPointType, typename FunctorType > + public: + + template< typename EndPointType > peoAsyncDataTransfer( - - EndPointType& __endPoint, - Topology& __topology, - FunctorType& externalFunctorRef - - ) : topology( __topology ) - { - - source = new MsgTransferQueue< EndPointType >( __endPoint, externalFunctorRef ); - destination = new MsgTransferQueue< EndPointType >( __endPoint, externalFunctorRef ); - __topology.add( *this ); - } - - template< typename SourceEndPointType, typename DestinationEndPointType > + + EndPointType& __endPoint, + Topology& __topology + + ) : topology( __topology ) + { + + source = new MsgTransferQueue< EndPointType >( __endPoint ); + destination = new MsgTransferQueue< EndPointType >( __endPoint ); + __topology.add( *this ); + } + + template< typename EndPointType, typename FunctorType > peoAsyncDataTransfer( - - SourceEndPointType& __source, - DestinationEndPointType& __destination, - Topology& __topology - - ) : topology( __topology ) - { - - source = new MsgTransferQueue< SourceEndPointType >( __source ); - destination = new MsgTransferQueue< DestinationEndPointType >( __destination ); - __topology.add( *this ); - } - template< typename SourceEndPointType, typename DestinationEndPointType, typename FunctorType > + EndPointType& __endPoint, + Topology& __topology, + FunctorType& externalFunctorRef + + ) : topology( __topology ) + { + + source = new MsgTransferQueue< EndPointType >( __endPoint, externalFunctorRef ); + destination = new MsgTransferQueue< EndPointType >( __endPoint, externalFunctorRef ); + __topology.add( *this ); + } + + template< typename SourceEndPointType, typename DestinationEndPointType > peoAsyncDataTransfer( - - 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 pack(); - void unpack(); - - void packSynchronizeReq(); - - - private: - - void sendData(); - void receiveData(); - - - private: + SourceEndPointType& __source, + DestinationEndPointType& __destination, + Topology& __topology - // the neighboring topology - Topology& topology; - - // source and destination end-points - AbstractMsgTransferQueue* source; - AbstractMsgTransferQueue* destination; - - std :: queue< Cooperative* > coop_em; -}; + ) : topology( __topology ) + { + + source = new MsgTransferQueue< SourceEndPointType >( __source ); + destination = new MsgTransferQueue< DestinationEndPointType >( __destination ); + __topology.add( *this ); + } + + template< typename SourceEndPointType, typename DestinationEndPointType, typename FunctorType > + peoAsyncDataTransfer( + + 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 peoAsyncDataTransfer :: pack() { - + void operator()(); + + void pack(); + void unpack(); + + void packSynchronizeReq(); + + + private: + + void sendData(); + void receiveData(); + + + private: + + // the neighboring topology + Topology& topology; + + // source and destination end-points + AbstractMsgTransferQueue* source; + AbstractMsgTransferQueue* destination; + + std :: queue< Cooperative* > coop_em; + }; + + +void peoAsyncDataTransfer :: pack() +{ + lock (); - + ::pack( coop_em.front()->getKey() ); source->packMessage(); coop_em.pop(); - + unlock(); } -void peoAsyncDataTransfer :: unpack() { - +void peoAsyncDataTransfer :: unpack() +{ + lock (); destination->unpackMessage(); unlock(); } -void peoAsyncDataTransfer :: packSynchronizeReq() { +void peoAsyncDataTransfer :: packSynchronizeReq() +{ } -void peoAsyncDataTransfer :: sendData() { - +void peoAsyncDataTransfer :: sendData() +{ + std :: vector< Cooperative* > in, out; topology.setNeighbors( this, in, out ); - - for ( unsigned i = 0; i < out.size(); i++ ) { - - source->pushMessage(); - - coop_em.push( out[i] ); - send( out[i] ); - - printDebugMessage( "peoAsyncDataTransfer: sending data." ); - } + + for ( unsigned i = 0; i < out.size(); i++ ) + { + + source->pushMessage(); + + coop_em.push( out[i] ); + send( out[i] ); + + printDebugMessage( "peoAsyncDataTransfer: sending data." ); + } } -void peoAsyncDataTransfer :: receiveData() { - +void peoAsyncDataTransfer :: receiveData() +{ + lock (); { - - while ( !( destination->empty() ) ) { - - printDebugMessage( "peoAsyncDataTransfer: received data." ); - destination->popMessage(); - printDebugMessage( "peoAsyncDataTransfer: done reading data." ); - } + + while ( !( destination->empty() ) ) + { + + printDebugMessage( "peoAsyncDataTransfer: received data." ); + destination->popMessage(); + printDebugMessage( "peoAsyncDataTransfer: done reading data." ); + } } unlock(); } -void peoAsyncDataTransfer :: operator()() { - +void peoAsyncDataTransfer :: operator()() +{ + sendData(); // sending data receiveData(); // receiving data } diff --git a/trunk/paradiseo-peo/src/peoSyncDataTransfer.h b/trunk/paradiseo-peo/src/peoSyncDataTransfer.h index 0d8450b5a..e3eb63cc0 100755 --- a/trunk/paradiseo-peo/src/peoSyncDataTransfer.h +++ b/trunk/paradiseo-peo/src/peoSyncDataTransfer.h @@ -22,131 +22,134 @@ 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() ); source->packMessage(); coop_em.pop(); } -void peoSyncDataTransfer :: unpack() { +void peoSyncDataTransfer :: unpack() +{ destination->unpackMessage(); } -void peoSyncDataTransfer :: packSynchronizeReq() { +void peoSyncDataTransfer :: packSynchronizeReq() +{ packSynchronRequest( all ); } @@ -154,92 +157,107 @@ void peoSyncDataTransfer :: packSynchronizeReq() { extern void wakeUpCommunicator(); 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(); + + coop_em.push( out[ i ] ); + send( out[ i ]); + + printDebugMessage( "peoSyncDataTransfer: sending data." ); + } - source->pushMessage(); - - coop_em.push( out[ i ] ); - send( out[ i ]); - - printDebugMessage( "peoSyncDataTransfer: sending data." ); - } - wakeUpCommunicator(); } -void peoSyncDataTransfer :: receiveData() { - +void peoSyncDataTransfer :: receiveData() +{ + assert( !( destination->empty() ) ); - while ( !( destination->empty() ) ) { - - printDebugMessage( "peoSyncDataTransfer: received data." ); - destination->popMessage(); - printDebugMessage( "peoSyncDataTransfer: done extracting received data." ); - } + while ( !( destination->empty() ) ) + { + + printDebugMessage( "peoSyncDataTransfer: received data." ); + destination->popMessage(); + printDebugMessage( "peoSyncDataTransfer: done extracting received data." ); + } } -void peoSyncDataTransfer :: operator()() { +void peoSyncDataTransfer :: operator()() +{ standbyTransfer = false; nbTransfersIn = nbTransfersOut = 0; - - topology.setNeighbors( this, in, out ); all = topology; - - synchronizeCoopEx(); stop(); - + + topology.setNeighbors( this, in, out ); + all = topology; + + synchronizeCoopEx(); + stop(); + // sending data out sendData(); // synchronizing sem_wait( &sync ); // receiving data in receiveData(); - - synchronizeCoopEx(); stop(); + + synchronizeCoopEx(); + stop(); } -void peoSyncDataTransfer :: notifySending() { +void peoSyncDataTransfer :: notifySending() +{ nbTransfersOut++; - + printDebugMessage( "peoSyncDataTransfer: notified of the completion of a transfer round." ); - + getOwner()->setActive(); - if ( nbTransfersOut == out.size() && nbTransfersIn < in.size() ) { - getOwner()->setPassive(); - } + if ( nbTransfersOut == out.size() && nbTransfersIn < in.size() ) + { + getOwner()->setPassive(); + } } -void peoSyncDataTransfer :: notifyReceiving() { +void peoSyncDataTransfer :: notifyReceiving() +{ nbTransfersIn++; printDebugMessage( "peoSyncIslandMig: notified of incoming data." ); - - if ( standbyTransfer ) { - getOwner()->setActive(); - if ( nbTransfersOut == out.size() && nbTransfersIn < in.size() ) - getOwner()->setPassive(); - } - - if ( nbTransfersIn == in.size() ) { - - printDebugMessage( "peoSyncIslandMig: finished collecting incoming data." ); - sem_post( &sync ); - } + + if ( standbyTransfer ) + { + getOwner()->setActive(); + if ( nbTransfersOut == out.size() && nbTransfersIn < in.size() ) + getOwner()->setPassive(); + } + + if ( nbTransfersIn == in.size() ) + { + + printDebugMessage( "peoSyncIslandMig: finished collecting incoming data." ); + sem_post( &sync ); + } } -void peoSyncDataTransfer :: notifySendingSyncReq () { - +void peoSyncDataTransfer :: notifySendingSyncReq () +{ + getOwner()->setPassive(); printDebugMessage( "peoSyncIslandMig: synchronization request sent." ); } -void peoSyncDataTransfer :: notifySynchronized () { - +void peoSyncDataTransfer :: notifySynchronized () +{ + printDebugMessage( "peoSyncIslandMig: cooperators synchronized." ); - + standbyTransfer = true; getOwner()->setActive(); resume(); diff --git a/trunk/paradiseo-peo/tutorial/Lesson5/main.cpp b/trunk/paradiseo-peo/tutorial/Lesson5/main.cpp index e6e5e0163..ea7fec6d8 100644 --- a/trunk/paradiseo-peo/tutorial/Lesson5/main.cpp +++ b/trunk/paradiseo-peo/tutorial/Lesson5/main.cpp @@ -11,118 +11,143 @@ #define MIGRATIONS_AT_N_GENERATIONS 5 #define NUMBER_OF_MIGRANTS 10 -struct Representation : public eoVector< eoMinimizingFitness, double > { +struct Representation : public eoVector< eoMinimizingFitness, double > + { - 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; + Representation() + { + resize( SIZE ); } - } -}; + }; -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++ ) { - - fitnessValue += pow( rep[ i ], 2.0 ); + for ( int i = 0; i < SIZE; i++ ) + { + rep[ i ] = (rng.uniform() - 0.5) * DEF_DOMAIN; + } } + }; - 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 ); - rep[ pos ] = (rng.uniform() - 0.5) * DEF_DOMAIN; + fitnessValue += pow( rep[ i ], 2.0 ); + } - 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 ]; + rep.fitness( fitnessValue ); } - - repA = offA; repB = offB; + }; - repA.invalidate(); - repB.invalidate(); - - return true; - } -}; +struct MutationOp : public eoMonOp< Representation > + { + + bool operator()( Representation& rep ) + { + + 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 ); - else { - ::pack( (unsigned int)1 ); - ::pack( (double)(rep.fitness()) ); - } + else + { + ::pack( (unsigned int)1 ); + ::pack( (double)(rep.fitness()) ); + } - for ( unsigned int index = 0; index < SIZE; index++ ) { - ::pack( (double)rep[ index ] ); - } + for ( unsigned int index = 0; index < SIZE; index++ ) + { + ::pack( (double)rep[ index ] ); + } } -void unpack( Representation& rep ) { +void unpack( Representation& rep ) +{ eoScalarFitness > fitness; unsigned int validFitness; unpack( validFitness ); - if ( validFitness ) { + if ( validFitness ) + { - double fitnessValue; ::unpack( fitnessValue ); - rep.fitness( fitnessValue ); - } - else { - rep.invalidate(); - } + double fitnessValue; + ::unpack( fitnessValue ); + rep.fitness( fitnessValue ); + } + else + { + rep.invalidate(); + } double value; - for ( unsigned int index = 0; index < SIZE; index++ ) { - ::unpack( value ); - rep[ index ] = value; - } + for ( unsigned int index = 0; index < SIZE; index++ ) + { + ::unpack( value ); + rep[ index ] = value; + } } -int main( int __argc, char** __argv ) { +int main( int __argc, char** __argv ) +{ rng.reseed( time( NULL ) ); srand( time( NULL ) ); - + peo::init( __argc, __argv ); - - + + eoParser parser ( __argc, __argv ); - + eoValueParam < unsigned int > nbGenerations( NB_GEN, "maxGen"); parser.processParam ( nbGenerations ); @@ -131,7 +156,7 @@ int main( int __argc, char** __argv ) { RingTopology ring,topo; - unsigned int dataA, dataB, dataC; + unsigned int dataA, dataB, dataC; dataA = 1; dataB = 5; @@ -156,12 +181,12 @@ int main( int __argc, char** __argv ) { eoCheckPoint< Representation > checkpoint( cont ); eoEasyEA< Representation > algo( checkpoint, eval, selectN, transform, elitReplace ); - + //------------------------------------------------------------------------------------------------------------- // MIGRATION CONTEXT DEFINITION - - eoPeriodicContinue< Representation > mig_conti( MIGRATIONS_AT_N_GENERATIONS ); + + eoPeriodicContinue< Representation > mig_conti( MIGRATIONS_AT_N_GENERATIONS ); eoContinuator mig_cont(mig_conti,pop); eoRandomSelect mig_select_one; eoSelector > mig_select (mig_select_one,NUMBER_OF_MIGRANTS,pop); @@ -185,7 +210,7 @@ int main( int __argc, char** __argv ) { //------------------------------------------------------------------------------------------------------------- // MIGRATION CONTEXT DEFINITION - eoPeriodicContinue< Representation > mig_conti2( MIGRATIONS_AT_N_GENERATIONS ); + eoPeriodicContinue< Representation > mig_conti2( MIGRATIONS_AT_N_GENERATIONS ); eoContinuator mig_cont2(mig_conti2,pop2); eoRandomSelect mig_select_one2; eoSelector > mig_select2 (mig_select_one2,NUMBER_OF_MIGRANTS,pop2); @@ -208,7 +233,7 @@ int main( int __argc, char** __argv ) { //------------------------------------------------------------------------------------------------------------- // MIGRATION CONTEXT DEFINITION - + eoPeriodicContinue< Representation > mig_conti3( MIGRATIONS_AT_N_GENERATIONS ); eoContinuator mig_cont3(mig_conti3,pop3); eoRandomSelect mig_select_one3; @@ -217,7 +242,7 @@ int main( int __argc, char** __argv ) { eoReplace > mig_replace3 (replace_one3,pop3); // peoSyncIslandMig< eoPop< Representation >, eoPop< Representation > > mig3(MIGRATIONS_AT_N_GENERATIONS,mig_select3,mig_replace3,topo); peoAsyncIslandMig< eoPop< Representation >, eoPop< Representation > > mig3(mig_cont3,mig_select3,mig_replace3,topo); - + checkpoint3.add( mig3 ); //------------------------------------------------------------------------------------------------------------- @@ -237,11 +262,11 @@ int main( int __argc, char** __argv ) { mig3.setOwner( algoPar3 ); checkpoint3.add( dataTransferc ); dataTransferc.setOwner( algoPar3 ); - + peo::run(); peo::finalize(); - if ( getNodeRank() == 1 ) + if ( getNodeRank() == 1 ) std::cout << "A: " << dataA << std::endl; if ( getNodeRank() == 2 ) std::cout << "B: " << dataB << std::endl; diff --git a/trunk/paradiseo-peo/tutorial/Lesson6/main.cpp b/trunk/paradiseo-peo/tutorial/Lesson6/main.cpp index dc37855f5..391093f0f 100644 --- a/trunk/paradiseo-peo/tutorial/Lesson6/main.cpp +++ b/trunk/paradiseo-peo/tutorial/Lesson6/main.cpp @@ -18,82 +18,89 @@ #define MUT_RATE 0.01 -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 ); loadParameters( __argc, __argv ); - - RouteInit route_init; - RouteEval full_eval; + + RouteInit route_init; + RouteEval full_eval; OrderXover crossover; - CitySwap mutation; - eoPop< Route > population( POP_SIZE, route_init ); - eoGenContinue< Route > eaCont( NUM_GEN ); + CitySwap mutation; + eoPop< Route > population( POP_SIZE, route_init ); + eoGenContinue< Route > eaCont( NUM_GEN ); eoCheckPoint< Route > eaCheckpointContinue( eaCont ); - eoRankingSelect< Route > selectionStrategy; + eoRankingSelect< Route > selectionStrategy; eoSelectNumber< Route > eaSelect( selectionStrategy, POP_SIZE ); eoSGATransform< Route > transformA( crossover, CROSS_RATE, mutation, MUT_RATE ); - eoPlusReplacement< Route > eaReplace; + eoPlusReplacement< Route > eaReplace; RingTopology ring; - eoPlusReplacement< Route > transferReplace; + eoPlusReplacement< Route > transferReplace; peoAsyncDataTransfer asyncEAEndPoint( population, population, ring, transferReplace ); eaCheckpointContinue.add( asyncEAEndPoint ); eoEasyEA< Route > eaAlg( eaCheckpointContinue, full_eval, eaSelect, transformA, eaReplace ); peoWrapper paraEAAlg( eaAlg, population ); asyncEAEndPoint.setOwner( paraEAAlg ); - eoPop< Route > populationB( POP_SIZE, route_init ); - eoGenContinue< Route > eaContB( NUM_GEN ); - eoCheckPoint< Route > eaCheckpointContinueB( eaContB ); + eoPop< Route > populationB( POP_SIZE, route_init ); + eoGenContinue< Route > eaContB( NUM_GEN ); + eoCheckPoint< Route > eaCheckpointContinueB( eaContB ); eoRankingSelect< Route > selectionStrategyB; eoSelectNumber< Route > eaSelectB( selectionStrategyB, POP_SIZE ); RingTopology ringB; - eoPlusReplacement< Route > transferReplaceB; + eoPlusReplacement< Route > transferReplaceB; peoAsyncDataTransfer asyncEAEndPointB( populationB, populationB, ringB, transferReplaceB ); eaCheckpointContinueB.add( asyncEAEndPointB ); eoSGATransform< Route > transformB ( crossover, CROSS_RATE, mutation, MUT_RATE ); @@ -107,7 +114,7 @@ int main( int __argc, char** __argv ) { peoAsyncDataTransfer coSearchEndPointA( A, A, ring, pushBackA ); peoAsyncDataTransfer coSearchEndPointB( B, B, ringB, pushBackB ); - + CoSearch coSearch( A, B, coSearchEndPointA, coSearchEndPointB ); peoWrapper paraCoSearch( coSearch ); coSearchEndPointA.setOwner( paraCoSearch );