void partialOscillation(LifeList *cells, LifeList *working,
int testUpTo, int testPhases,
int nmatches, PartialOscillatorDesc *posc) {
int i,j;
History hist;
Transformation normT;
Transformation oscT;
normT= normalize(cells);
hist= makeHistory(cells, testUpTo+testPhases);
initMatchList(posc, nmatches);
for (i=1; i<=testUpTo; i++) {
int matchSize;
int tx, ty;
for (j=0; j<testPhases; j++) {
getGeneration(cells, hist, j);
getGeneration(working, hist, i+j);
bestMatches(cells, working, i, nmatches, posc);
}
}
getGeneration(cells, hist, 0);
freeHistory(hist);
transformBack(cells->cellList, normT, cells->ncells);
}
//---------------------------------------------------------------------------//
// Test templates
//---------------------------------------------------------------------------//
TEUCHOS_UNIT_TEST( DomainCommunicator, Communicate )
{
typedef Tpetra::Vector<double,int,long> VectorType;
typedef Tpetra::CrsMatrix<double,int,long> MatrixType;
typedef MCLS::MatrixTraits<VectorType,MatrixType> MT;
typedef MCLS::AdjointHistory<long> HistoryType;
typedef std::mt19937 rng_type;
typedef MCLS::AdjointTally<VectorType> TallyType;
typedef MCLS::AlmostOptimalDomain<VectorType,MatrixType,rng_type,TallyType>
DomainType;
Teuchos::RCP<const Teuchos::Comm<int> > comm =
Teuchos::DefaultComm<int>::getComm();
int comm_size = comm->getSize();
int comm_rank = comm->getRank();
// This test is parallel.
if ( comm_size > 1 )
{
int local_num_rows = 10;
int global_num_rows = local_num_rows*comm_size;
Teuchos::RCP<const Tpetra::Map<int,long> > map =
Tpetra::createUniformContigMap<int,long>( global_num_rows, comm );
// Build the linear operator and solution vector.
Teuchos::RCP<MatrixType> A = Tpetra::createCrsMatrix<double,int,long>( map );
Teuchos::Array<long> global_columns( 1 );
Teuchos::Array<double> values( 1 );
for ( int i = 1; i < global_num_rows; ++i )
{
global_columns[0] = i-1;
values[0] = -0.5/comm_size;
A->insertGlobalValues( i, global_columns(), values() );
}
global_columns[0] = global_num_rows-1;
values[0] = -0.5/comm_size;
A->insertGlobalValues( global_num_rows-1, global_columns(), values() );
A->fillComplete();
Teuchos::RCP<VectorType> x = MT::cloneVectorFromMatrixRows( *A );
Teuchos::RCP<MatrixType> A_T = MT::copyTranspose(*A);
// Build the adjoint domain.
Teuchos::ParameterList plist;
plist.set<int>( "Overlap Size", 0 );
Teuchos::RCP<DomainType> domain =
Teuchos::rcp( new DomainType( A_T, x, plist ) );
Teuchos::RCP<MCLS::PRNG<rng_type> > rng = Teuchos::rcp(
new MCLS::PRNG<rng_type>( comm->getRank() ) );
domain->setRNG( rng );
// History setup.
HistoryType::setByteSize();
// Build the domain communicator.
typename MCLS::DomainCommunicator<DomainType>::BankType bank;
int buffer_size = 3;
plist.set<int>( "MC Buffer Size", buffer_size );
MCLS::DomainCommunicator<DomainType> communicator( domain, comm, plist );
// Test initialization.
TEST_EQUALITY( Teuchos::as<int>(communicator.maxBufferSize()), buffer_size );
TEST_ASSERT( !communicator.sendStatus() );
TEST_ASSERT( !communicator.receiveStatus() );
// Post receives.
communicator.post();
if ( comm_rank == 0 )
{
TEST_ASSERT( !communicator.receiveStatus() );
}
else
{
TEST_ASSERT( communicator.receiveStatus() );
}
// End communication.
communicator.end();
TEST_ASSERT( !communicator.receiveStatus() );
// Post new receives.
communicator.post();
if ( comm_rank == 0 )
{
TEST_ASSERT( !communicator.receiveStatus() );
}
else
{
TEST_ASSERT( communicator.receiveStatus() );
}
TEST_EQUALITY( communicator.sendBufferSize(), 0 );
// Flush with zero histories.
TEST_EQUALITY( communicator.flush(), 0 );
if ( comm_rank == 0 )
{
TEST_ASSERT( !communicator.receiveStatus() );
}
else
{
TEST_ASSERT( communicator.receiveStatus() );
}
TEST_ASSERT( !communicator.sendStatus() );
// Receive empty flushed buffers.
int zero_histories = communicator.wait( bank );
TEST_EQUALITY( zero_histories, 0 );
TEST_ASSERT( !communicator.receiveStatus() );
TEST_ASSERT( bank.empty() );
// Repost receives.
communicator.post();
if ( comm_rank == 0 )
{
TEST_ASSERT( !communicator.receiveStatus() );
}
else
{
TEST_ASSERT( communicator.receiveStatus() );
}
// Proc 0 will send to proc 1.
if ( comm_rank == 0 )
{
TEST_ASSERT( !domain->isGlobalState(10) );
HistoryType h1 =
makeHistory( 10, 1.1, comm_rank*4 + 1 );
const typename MCLS::DomainCommunicator<DomainType>::Result
r1 = communicator.communicate( h1 );
TEST_ASSERT( !r1.sent );
TEST_EQUALITY( communicator.sendBufferSize(), 1 );
HistoryType h2 =
makeHistory( 10, 2.1, comm_rank*4 + 2 );
const typename MCLS::DomainCommunicator<DomainType>::Result
r2 = communicator.communicate( h2 );
TEST_ASSERT( !r2.sent );
TEST_EQUALITY( communicator.sendBufferSize(), 2 );
HistoryType h3 =
makeHistory( 10, 3.1, comm_rank*4 + 3 );
const typename MCLS::DomainCommunicator<DomainType>::Result
r3 = communicator.communicate( h3 );
TEST_ASSERT( r3.sent );
TEST_EQUALITY( r3.destination, 1 );
TEST_EQUALITY( communicator.sendBufferSize(), 0 );
}
// Proc comm_rank send to proc comm_rank+1 and receive from proc
// comm_rank-1.
else if ( comm_rank < comm_size - 1 )
{
// Send to proc comm_rank+1.
TEST_ASSERT( !domain->isGlobalState((comm_rank+1)*10) );
HistoryType h1 =
makeHistory( (comm_rank+1)*10, 1.1, comm_rank*4 + 1 );
const typename MCLS::DomainCommunicator<DomainType>::Result
r1 = communicator.communicate( h1 );
TEST_ASSERT( !r1.sent );
TEST_EQUALITY( communicator.sendBufferSize(), 1 );
HistoryType h2 =
makeHistory( (comm_rank+1)*10, 2.1, comm_rank*4 + 2 );
const typename MCLS::DomainCommunicator<DomainType>::Result
r2 = communicator.communicate( h2 );
TEST_ASSERT( !r2.sent );
TEST_EQUALITY( communicator.sendBufferSize(), 2 );
HistoryType h3 =
makeHistory( (comm_rank+1)*10, 3.1, comm_rank*4 + 3 );
const typename MCLS::DomainCommunicator<DomainType>::Result
r3 = communicator.communicate( h3 );
TEST_ASSERT( r3.sent );
TEST_EQUALITY( r3.destination, comm_rank+1 );
TEST_EQUALITY( communicator.sendBufferSize(), 0 );
// Receive from proc comm_rank-1.
while ( bank.empty() )
{
communicator.checkAndPost( bank );
}
TEST_EQUALITY( bank.size(), 3 );
HistoryType rp3 = bank.top();
bank.pop();
HistoryType rp2 = bank.top();
bank.pop();
HistoryType rp1 = bank.top();
bank.pop();
TEST_ASSERT( bank.empty() );
TEST_EQUALITY( rp3.globalState(), comm_rank*10 );
TEST_EQUALITY( rp3.weight(), 3.1 );
TEST_EQUALITY( rp2.globalState(), comm_rank*10 );
TEST_EQUALITY( rp2.weight(), 2.1 );
TEST_EQUALITY( rp1.globalState(), comm_rank*10 );
TEST_EQUALITY( rp1.weight(), 1.1 );
TEST_ASSERT( communicator.receiveStatus() );
}
// The last proc just receives.
else
{
// Check and post until receive from proc comm_rank-1
while ( bank.empty() )
{
communicator.checkAndPost( bank );
}
TEST_ASSERT( communicator.receiveStatus() );
TEST_EQUALITY( bank.size(), 3 );
HistoryType rp3 = bank.top();
bank.pop();
HistoryType rp2 = bank.top();
bank.pop();
HistoryType rp1 = bank.top();
bank.pop();
TEST_ASSERT( bank.empty() );
TEST_EQUALITY( rp3.globalState(), comm_rank*10 );
TEST_EQUALITY( rp3.weight(), 3.1 );
TEST_EQUALITY( rp2.globalState(), comm_rank*10 );
TEST_EQUALITY( rp2.weight(), 2.1 );
TEST_EQUALITY( rp1.globalState(), comm_rank*10 );
TEST_EQUALITY( rp1.weight(), 1.1 );
}
// End communication.
communicator.end();
TEST_ASSERT( !communicator.receiveStatus() );
}
// Barrier before exiting to make sure memory deallocation happened
// correctly.
comm->barrier();
}
