git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@794 331e1502-861f-0410-8da2-ba01fb791d7f

This commit is contained in:
atantar 2007-11-20 13:40:15 +00:00
commit aecc5ba8fc
35 changed files with 498 additions and 262 deletions

View file

@ -43,192 +43,227 @@
template < typename EntityType > class peoSynchronousMultiStart : public Service
{
public:
template < typename AlgorithmType > peoSynchronousMultiStart( AlgorithmType& externalAlgorithm )
{
public:
singularAlgorithm = new Algorithm< AlgorithmType >( externalAlgorithm );
algorithms.push_back( singularAlgorithm );
template < typename AlgorithmType > peoSynchronousMultiStart( AlgorithmType& externalAlgorithm )
{
aggregationFunction = new NoAggregationFunction();
}
singularAlgorithm = new Algorithm< AlgorithmType >( externalAlgorithm );
algorithms.push_back( singularAlgorithm );
template < typename AlgorithmReturnType, typename AlgorithmDataType > peoSynchronousMultiStart( AlgorithmReturnType (*externalAlgorithm)( AlgorithmDataType& ) )
{
aggregationFunction = new NoAggregationFunction();
}
singularAlgorithm = new FunctionAlgorithm< AlgorithmReturnType, AlgorithmDataType >( externalAlgorithm );
algorithms.push_back( singularAlgorithm );
template < typename AlgorithmType, typename AggregationFunctionType > peoSynchronousMultiStart( std::vector< AlgorithmType* >& externalAlgorithms, AggregationFunctionType& externalAggregationFunction )
{
aggregationFunction = new NoAggregationFunction();
}
for ( unsigned int index = 0; index < externalAlgorithms; index++ )
{
template < typename AlgorithmType, typename AggregationFunctionType > peoSynchronousMultiStart( std::vector< AlgorithmType* >& externalAlgorithms, AggregationFunctionType& externalAggregationFunction )
{
algorithms.push_back( new Algorithm< AlgorithmType >( *externalAlgorithms[ index ] ) );
}
aggregationFunction = new Algorithm< AggregationFunctionType >( externalAggregationFunction );
}
~peoSynchronousMultiStart()
{
for ( unsigned int index = 0; index < data.size(); index++ ) delete data[ index ];
for ( unsigned int index = 0; index < algorithms.size(); index++ ) delete algorithms[ index ];
delete aggregationFunction;
}
template < typename Type > void operator()( Type& externalData )
{
for ( typename Type::iterator externalDataIterator = externalData.begin(); externalDataIterator != externalData.end(); externalDataIterator++ )
{
data.push_back( new DataType< EntityType >( *externalDataIterator ) );
}
functionIndex = dataIndex = idx = num_term = 0;
requestResourceRequest( data.size() * algorithms.size() );
stop();
}
template < typename Type > void operator()( const Type& externalDataBegin, const Type& externalDataEnd )
{
for ( Type externalDataIterator = externalDataBegin; externalDataIterator != externalDataEnd; externalDataIterator++ )
{
data.push_back( new DataType< EntityType >( *externalDataIterator ) );
}
functionIndex = dataIndex = idx = num_term = 0;
requestResourceRequest( data.size() * algorithms.size() );
stop();
}
void packData();
void unpackData();
void execute();
void packResult();
void unpackResult();
void notifySendingData();
void notifySendingAllResourceRequests();
private:
template < typename Type > struct DataType;
struct AbstractDataType
for ( unsigned int index = 0; index < externalAlgorithms.size(); index++ )
{
virtual ~AbstractDataType()
{ }
algorithms.push_back( new Algorithm< AlgorithmType >( *externalAlgorithms[ index ] ) );
}
template < typename Type > operator Type& ()
{
aggregationFunction = new AggregationAlgorithm< AggregationFunctionType >( externalAggregationFunction );
}
return ( dynamic_cast< DataType< Type >& >( *this ) ).data;
}
};
template < typename AlgorithmReturnType, typename AlgorithmDataType, typename AggregationFunctionType >
peoSynchronousMultiStart( std::vector< AlgorithmReturnType (*)( AlgorithmDataType& ) >& externalAlgorithms,
AggregationFunctionType& externalAggregationFunction )
{
for ( unsigned int index = 0; index < externalAlgorithms.size(); index++ )
{
algorithms.push_back( new FunctionAlgorithm< AlgorithmReturnType, AlgorithmDataType >( externalAlgorithms[ index ] ) );
}
aggregationFunction = new AggregationAlgorithm< AggregationFunctionType >( externalAggregationFunction );
}
~peoSynchronousMultiStart()
{
for ( unsigned int index = 0; index < data.size(); index++ ) delete data[ index ];
for ( unsigned int index = 0; index < algorithms.size(); index++ ) delete algorithms[ index ];
delete aggregationFunction;
}
template < typename Type > void operator()( Type& externalData )
{
for ( typename Type::iterator externalDataIterator = externalData.begin(); externalDataIterator != externalData.end(); externalDataIterator++ )
{
data.push_back( new DataType< EntityType >( *externalDataIterator ) );
}
functionIndex = dataIndex = idx = num_term = 0;
requestResourceRequest( data.size() * algorithms.size() );
stop();
}
template < typename Type > void operator()( const Type& externalDataBegin, const Type& externalDataEnd )
{
for ( Type externalDataIterator = externalDataBegin; externalDataIterator != externalDataEnd; externalDataIterator++ )
{
data.push_back( new DataType< EntityType >( *externalDataIterator ) );
}
functionIndex = dataIndex = idx = num_term = 0;
requestResourceRequest( data.size() * algorithms.size() );
stop();
}
void packData();
void unpackData();
void execute();
void packResult();
void unpackResult();
void notifySendingData();
void notifySendingAllResourceRequests();
private:
template < typename Type > struct DataType;
struct AbstractDataType
{
virtual ~AbstractDataType()
{ }
template < typename Type > operator Type& ()
{
return ( dynamic_cast< DataType< Type >& >( *this ) ).data;
}
};
template < typename Type > struct DataType : public AbstractDataType
{
{
DataType( Type& externalData ) : data( externalData )
{ }
DataType( Type& externalData ) : data( externalData )
{ }
Type& data;
};
Type& data;
};
struct AbstractAlgorithm
{
struct AbstractAlgorithm
{
virtual ~AbstractAlgorithm()
{ }
virtual ~AbstractAlgorithm()
{ }
virtual void operator()( AbstractDataType& dataTypeInstance )
{}
};
virtual void operator()( AbstractDataType& dataTypeInstance )
{}
};
template < typename AlgorithmType > struct Algorithm : public AbstractAlgorithm
{
{
Algorithm( AlgorithmType& externalAlgorithm ) : algorithm( externalAlgorithm )
{ }
Algorithm( AlgorithmType& externalAlgorithm ) : algorithm( externalAlgorithm )
{ }
void operator()( AbstractDataType& dataTypeInstance )
{
algorithm( dataTypeInstance );
}
void operator()( AbstractDataType& dataTypeInstance )
{
algorithm( dataTypeInstance );
}
AlgorithmType& algorithm;
};
AlgorithmType& algorithm;
};
template < typename AlgorithmReturnType, typename AlgorithmDataType > struct FunctionAlgorithm : public AbstractAlgorithm
{
struct AbstractAggregationAlgorithm
{
FunctionAlgorithm( AlgorithmReturnType (*externalAlgorithm)( AlgorithmDataType& ) ) : algorithm( externalAlgorithm )
{ }
virtual ~AbstractAggregationAlgorithm()
{ }
void operator()( AbstractDataType& dataTypeInstance )
{
algorithm( dataTypeInstance );
}
virtual void operator()( AbstractDataType& dataTypeInstanceA, AbstractDataType& dataTypeInstanceB )
{};
};
AlgorithmReturnType (*algorithm)( AlgorithmDataType& );
};
struct AbstractAggregationAlgorithm
{
virtual ~AbstractAggregationAlgorithm()
{ }
virtual void operator()( AbstractDataType& dataTypeInstanceA, AbstractDataType& dataTypeInstanceB )
{};
};
template < typename AggregationAlgorithmType > struct AggregationAlgorithm : public AbstractAggregationAlgorithm
{
{
AggregationAlgorithm( AggregationAlgorithmType& externalAggregationAlgorithm ) : aggregationAlgorithm( externalAggregationAlgorithm )
{ }
AggregationAlgorithm( AggregationAlgorithmType& externalAggregationAlgorithm ) : aggregationAlgorithm( externalAggregationAlgorithm )
{ }
void operator()( AbstractDataType& dataTypeInstanceA, AbstractDataType& dataTypeInstanceB )
{
void operator()( AbstractDataType& dataTypeInstanceA, AbstractDataType& dataTypeInstanceB )
{
aggregationAlgorithm( dataTypeInstanceA, dataTypeInstanceB );
}
aggregationAlgorithm( dataTypeInstanceA, dataTypeInstanceB );
}
AggregationAlgorithmType& aggregationAlgorithm;
};
AggregationAlgorithmType& aggregationAlgorithm;
};
struct NoAggregationFunction : public AbstractAggregationAlgorithm
{
{
void operator()( AbstractDataType& dataTypeInstanceA, AbstractDataType& dataTypeInstanceB )
{
void operator()( AbstractDataType& dataTypeInstanceA, AbstractDataType& dataTypeInstanceB )
{
static_cast< EntityType& >( dataTypeInstanceA ) = static_cast< EntityType& >( dataTypeInstanceB );
}
};
AbstractAlgorithm* singularAlgorithm;
std::vector< AbstractAlgorithm* > algorithms;
AbstractAggregationAlgorithm* aggregationFunction;
EntityType entityTypeInstance;
std::vector< AbstractDataType* > data;
unsigned idx;
unsigned num_term;
unsigned dataIndex;
unsigned functionIndex;
static_cast< EntityType& >( dataTypeInstanceA ) = static_cast< EntityType& >( dataTypeInstanceB );
}
};
AbstractAlgorithm* singularAlgorithm;
std::vector< AbstractAlgorithm* > algorithms;
AbstractAggregationAlgorithm* aggregationFunction;
EntityType entityTypeInstance;
std::vector< AbstractDataType* > data;
unsigned idx;
unsigned num_term;
unsigned dataIndex;
unsigned functionIndex;
};
template < typename EntityType > void peoSynchronousMultiStart< EntityType >::packData()
{
@ -239,11 +274,11 @@ template < typename EntityType > void peoSynchronousMultiStart< EntityType >::pa
// done with functionIndex for the entire data set - moving to another
// function/algorithm starting all over with the entire data set ( idx is set to 0 )
if ( idx == data.size() )
{
{
++functionIndex;
idx = 0;
}
++functionIndex;
idx = 0;
}
}
template < typename EntityType > void peoSynchronousMultiStart< EntityType >::unpackData()
@ -287,11 +322,11 @@ template < typename EntityType > void peoSynchronousMultiStart< EntityType >::un
num_term++;
if ( num_term == data.size() * algorithms.size() )
{
{
getOwner()->setActive();
resume();
}
getOwner()->setActive();
resume();
}
}
template < typename EntityType > void peoSynchronousMultiStart< EntityType >::notifySendingData()