diff --git a/eo/src/mpi/eoMpi.h b/eo/src/mpi/eoMpi.h index 9ad2bd7b..940f4129 100644 --- a/eo/src/mpi/eoMpi.h +++ b/eo/src/mpi/eoMpi.h @@ -44,6 +44,10 @@ namespace eo void data( JobData* _d ) { d = _d; + if( wrapped ) + { + wrapped->data( _d ); + } } protected: diff --git a/eo/src/mpi/eoParallelApply.h b/eo/src/mpi/eoParallelApply.h index bc85d438..94549fc3 100644 --- a/eo/src/mpi/eoParallelApply.h +++ b/eo/src/mpi/eoParallelApply.h @@ -17,14 +17,14 @@ namespace eo }; template - struct JobData + struct ParallelApplyData { - JobData( + ParallelApplyData( eoUF & _proc, std::vector& _pop, int _masterRank, // long _maxTime = 0, - int _packetSize + int _packetSize // FIXME = 1 ? ) : data( _pop ), func( _proc ), index( 0 ), size( _pop.size() ), packetSize( _packetSize ), masterRank( _masterRank ), comm( Node::comm() ) { @@ -35,7 +35,7 @@ namespace eo tempArray = new EOT[ _packetSize ]; } - ~JobData() + ~ParallelApplyData() { delete [] tempArray; } @@ -52,43 +52,16 @@ namespace eo bmpi::communicator& comm; }; - /* - template< typename EOT > - class ParallelApply : public Job< JobData > + template< class EOT > + class SendTaskParallelApply : public SendTaskFunction< ParallelApplyData > { public: + using SendTaskFunction< ParallelApplyData >::d; - ParallelApply( - // eoUF & _proc, - // std::vector& _pop, - AssignmentAlgorithm & algo, - int _masterRank, - const JobStore< JobData >& store - // long _maxTime = 0, - // int _packetSize = 1 - ) : - Job( algo, _masterRank, store ) - // Job( algo, _masterRank, _maxTime ), - func( _proc ), - data( _pop ), - packetSize( _packetSize ), - index( 0 ), - size( _pop.size() ) + SendTaskParallelApply( SendTaskParallelApply * w = 0 ) : SendTaskFunction< ParallelApplyData >( w ) { // empty } - - protected: - - // bmpi::communicator& comm; - }; - */ - - template< class EOT > - class SendTaskParallelApply : public SendTaskFunction< JobData > - { - public: - using SendTaskFunction< JobData >::d; // futureIndex, index, packetSize, size, comm, assignedTasks, data void operator()(int wrkRank) @@ -117,10 +90,15 @@ namespace eo }; template< class EOT > - class HandleResponseParallelApply : public HandleResponseFunction< JobData > + class HandleResponseParallelApply : public HandleResponseFunction< ParallelApplyData > { public: - using HandleResponseFunction< JobData >::d; + using HandleResponseFunction< ParallelApplyData >::d; + + HandleResponseParallelApply( HandleResponseParallelApply * w = 0 ) : HandleResponseFunction< ParallelApplyData >( w ) + { + // empty + } void operator()(int wrkRank) { @@ -129,10 +107,15 @@ namespace eo }; template< class EOT > - class ProcessTaskParallelApply : public ProcessTaskFunction< JobData > + class ProcessTaskParallelApply : public ProcessTaskFunction< ParallelApplyData > { public: - using ProcessTaskFunction< JobData >::d; + using ProcessTaskFunction< ParallelApplyData >::d; + + ProcessTaskParallelApply( ProcessTaskParallelApply * w = 0 ) : ProcessTaskFunction< ParallelApplyData >( w ) + { + // empty + } void operator()() { @@ -151,10 +134,15 @@ namespace eo }; template< class EOT > - class IsFinishedParallelApply : public IsFinishedFunction< JobData > + class IsFinishedParallelApply : public IsFinishedFunction< ParallelApplyData > { public: - using IsFinishedFunction< JobData >::d; + using IsFinishedFunction< ParallelApplyData >::d; + + IsFinishedParallelApply( IsFinishedParallelApply * w = 0 ) : IsFinishedFunction< ParallelApplyData >( w ) + { + // empty + } bool operator()() { @@ -163,7 +151,7 @@ namespace eo }; template< class EOT > - struct ParallelApplyStore : public JobStore< JobData > + struct ParallelApplyStore : public JobStore< ParallelApplyData > { ParallelApplyStore( eoUF & _proc, @@ -172,7 +160,7 @@ namespace eo // long _maxTime = 0, int _packetSize = 1 ) - : j( _proc, _pop, _masterRank, _packetSize ) + : _data( _proc, _pop, _masterRank, _packetSize ) { stpa = new SendTaskParallelApply; hrpa = new HandleResponseParallelApply; @@ -188,20 +176,46 @@ namespace eo delete ispa; } - SendTaskFunction< JobData >& sendTask() const { return *stpa; } - HandleResponseFunction< JobData >& handleResponse() const { return *hrpa; } - ProcessTaskFunction< JobData >& processTask() const { return *ptpa; } - IsFinishedFunction< JobData >& isFinished() const { return *ispa; } + SendTaskParallelApply< EOT >& sendTask() const { return *stpa; } + HandleResponseParallelApply< EOT >& handleResponse() const { return *hrpa; } + ProcessTaskParallelApply< EOT > & processTask() const { return *ptpa; } + IsFinishedParallelApply< EOT >& isFinished() const { return *ispa; } - JobData* data() { return &j; } + void sendTask( SendTaskParallelApply< EOT >* _stpa ) { stpa = _stpa; } + void handleResponse( HandleResponseParallelApply< EOT >* _hrpa ) { hrpa = _hrpa; } + void processTask( ProcessTaskParallelApply< EOT >* _ptpa ) { ptpa = _ptpa; } + void isFinished( IsFinishedParallelApply< EOT >* _ispa ) { ispa = _ispa; } + + ParallelApplyData* data() { return &_data; } protected: + // TODO commenter : Utiliser des pointeurs pour éviter d'écraser les fonctions wrappées SendTaskParallelApply* stpa; HandleResponseParallelApply* hrpa; ProcessTaskParallelApply* ptpa; IsFinishedParallelApply* ispa; - JobData j; + ParallelApplyData _data; + }; + + template< typename EOT > + class ParallelApply : public Job< ParallelApplyData > + { + public: + + ParallelApply( + AssignmentAlgorithm & algo, + int _masterRank, + ParallelApplyStore & store + ) : + Job< ParallelApplyData >( algo, _masterRank, store ) + { + // empty + } + + protected: + + // bmpi::communicator& comm; }; } } diff --git a/eo/test/mpi/parallelApply.cpp b/eo/test/mpi/parallelApply.cpp index 4e331334..75b515e9 100644 --- a/eo/test/mpi/parallelApply.cpp +++ b/eo/test/mpi/parallelApply.cpp @@ -112,7 +112,8 @@ int main(int argc, char** argv) { // ParallelApply job( plusOneInstance, v, *(tests[i].assign), 0, store, 3 ); ParallelApplyStore< int > store( plusOneInstance, v, 0, 3 ); - Job< JobData > job( *(tests[i].assign), 0, store ); + // Job< JobData > job( *(tests[i].assign), 0, store ); + ParallelApply< int > job( *(tests[i].assign), 0, store ); if( job.isMaster() ) { diff --git a/eo/test/mpi/wrapper.cpp b/eo/test/mpi/wrapper.cpp new file mode 100644 index 00000000..c653d5f8 --- /dev/null +++ b/eo/test/mpi/wrapper.cpp @@ -0,0 +1,89 @@ +# include +# include + +# include + +# include +using namespace std; + +using namespace eo::mpi; + +struct plusOne : public eoUF< int&, void > +{ + void operator() ( int & x ) + { + ++x; + } +}; + +template< class EOT > +struct ShowWrappedResult : public IsFinishedParallelApply +{ + using IsFinishedParallelApply::wrapped; + + ShowWrappedResult ( IsFinishedParallelApply * w ) : IsFinishedParallelApply( w ), times( 0 ) + { + // empty + } + + bool operator()() + { + bool wrappedValue = wrapped->operator()(); // (*wrapped)(); + cout << times << ") Wrapped function would say that it is " << ( wrappedValue ? "":"not ") << "finished" << std::endl; + ++times; + return wrappedValue; + } + + private: + int times; +}; + +// These tests require at least 3 processes to be launched. +int main(int argc, char** argv) +{ + // eo::log << eo::setlevel( eo::debug ); + eo::log << eo::setlevel( eo::quiet ); + + Node::init( argc, argv ); + + srand( time(0) ); + vector v; + for( int i = 0; i < 1000; ++i ) + { + v.push_back( rand() ); + } + + int offset = 0; + vector originalV = v; + + plusOne plusOneInstance; + + StaticAssignmentAlgorithm assign( v.size() ); + + ParallelApplyStore< int > store( plusOneInstance, v, 0, 1 ); + IsFinishedParallelApply< int >& wrapped = store.isFinished(); + ShowWrappedResult< int >* wrapper = new ShowWrappedResult( &wrapped ); + store.isFinished( wrapper ); + + // Job< ParallelApplyData > job( assign, 0, store ); + ParallelApply job( assign, 0, store ); + job.run(); + + if( job.isMaster() ) + { + ++offset; + for(int i = 0; i < v.size(); ++i) + { + cout << v[i] << ' '; + if( originalV[i] + offset != v[i] ) + { + cout << " <-- ERROR at this point." << endl; + exit( EXIT_FAILURE ); + } + } + cout << endl; + } + + return 0; +} +