bool field_data_valid( const FieldBase & f ,
const Bucket & k ,
unsigned ord ,
const char * required_by )
{
const MetaData * const k_mesh_meta_data = & MetaData::get(k);
const MetaData * const f_mesh_meta_data = & MetaData::get(f);
const bool ok_mesh_meta_data = k_mesh_meta_data == f_mesh_meta_data ;
const bool ok_ord = ord < k.size() ;
const bool exists = ok_mesh_meta_data && ok_ord &&
NULL != field_data( f , k.begin() );
if ( required_by && ! exists ) {
std::ostringstream msg_begin ;
msg_begin << "For args: " ;
msg_begin << f << " , " ;
msg_begin << k << " , " ;
msg_begin << ord << " , " ;
msg_begin << required_by ;
msg_begin << "; operation FAILED with " ;
ThrowErrorMsgIf( ! ok_mesh_meta_data,
msg_begin.str() << " different MetaData");
ThrowErrorMsgIf( ! ok_ord, msg_begin.str() <<
" Ordinal " << ord << " >= " << " size " << k.size());
ThrowErrorMsg( msg_begin.str() << " no data");
}
return exists ;
}
/// Cross-off the multiples of the sieving primes within the current
/// bucket. This is an implementation of the segmented sieve of
/// Eratosthenes with wheel factorization optimized for medium sieving
/// primes that have a few multiples per segment. This algorithm uses
/// a modulo 210 wheel that skips multiples of 2, 3, 5 and 7.
///
void EratMedium::crossOff(byte_t* sieve, uint_t sieveSize, Bucket& bucket)
{
SievingPrime* sPrime = bucket.begin();
SievingPrime* sEnd = bucket.end();
// process 3 sieving primes per loop iteration to
// increase instruction level parallelism
for (; sPrime + 3 <= sEnd; sPrime += 3)
{
uint_t multipleIndex0 = sPrime[0].getMultipleIndex();
uint_t wheelIndex0 = sPrime[0].getWheelIndex();
uint_t sievingPrime0 = sPrime[0].getSievingPrime();
uint_t multipleIndex1 = sPrime[1].getMultipleIndex();
uint_t wheelIndex1 = sPrime[1].getWheelIndex();
uint_t sievingPrime1 = sPrime[1].getSievingPrime();
uint_t multipleIndex2 = sPrime[2].getMultipleIndex();
uint_t wheelIndex2 = sPrime[2].getWheelIndex();
uint_t sievingPrime2 = sPrime[2].getSievingPrime();
// cross-off the multiples (unset bits) of sievingPrime
// @see unsetBit() in WheelFactorization.hpp
while (multipleIndex0 < sieveSize)
{
unsetBit(sieve, sievingPrime0, &multipleIndex0, &wheelIndex0);
if (multipleIndex1 >= sieveSize) break;
unsetBit(sieve, sievingPrime1, &multipleIndex1, &wheelIndex1);
if (multipleIndex2 >= sieveSize) break;
unsetBit(sieve, sievingPrime2, &multipleIndex2, &wheelIndex2);
}
while (multipleIndex0 < sieveSize) unsetBit(sieve, sievingPrime0, &multipleIndex0, &wheelIndex0);
while (multipleIndex1 < sieveSize) unsetBit(sieve, sievingPrime1, &multipleIndex1, &wheelIndex1);
while (multipleIndex2 < sieveSize) unsetBit(sieve, sievingPrime2, &multipleIndex2, &wheelIndex2);
multipleIndex0 -= sieveSize;
multipleIndex1 -= sieveSize;
multipleIndex2 -= sieveSize;
sPrime[0].set(multipleIndex0, wheelIndex0);
sPrime[1].set(multipleIndex1, wheelIndex1);
sPrime[2].set(multipleIndex2, wheelIndex2);
}
// process remaining sieving primes
for (; sPrime != sEnd; sPrime++)
{
uint_t multipleIndex = sPrime->getMultipleIndex();
uint_t wheelIndex = sPrime->getWheelIndex();
uint_t sievingPrime = sPrime->getSievingPrime();
while (multipleIndex < sieveSize)
unsetBit(sieve, sievingPrime, &multipleIndex, &wheelIndex);
multipleIndex -= sieveSize;
sPrime->set(multipleIndex, wheelIndex);
}
}
bool field_data_valid( const FieldBase & f ,
const Bucket & k ,
unsigned ord ,
const char * required_by )
{
const MetaData * const k_mesh_meta_data = & k.mesh().mesh_meta_data();
const MetaData * const f_mesh_meta_data = & f.mesh_meta_data();
const bool ok_mesh_meta_data = k_mesh_meta_data == f_mesh_meta_data ;
const bool ok_ord = ord < k.size() ;
const bool exists = ok_mesh_meta_data && ok_ord &&
NULL != field_data( f , k.begin() );
if ( required_by && ! exists ) {
std::ostringstream msg ;
msg << "stk::mesh::field_data_valid( " ;
msg << f ;
msg << " , " ;
msg << k ;
msg << " , " ;
msg << ord ;
msg << " , " ;
msg << required_by ;
msg << " ) FAILED with " ;
if ( ! ok_mesh_meta_data ) {
msg << " different MetaData" ;
}
else if ( ! ok_ord ) {
msg << " Ordinal " ;
msg << ord ;
msg << " >= " ;
msg << " size " ;
msg << k.size();
}
else {
msg << " no data" ;
}
throw std::runtime_error( msg.str() );
}
return exists ;
}
/// Cross-off the multiples of big sieving primes
/// from the sieve array.
///
void EratBig::crossOff(byte_t* sieve)
{
// process the buckets in lists_[0] which hold the sieving primes
// that have multiple(s) in the current segment
while (lists_[0]->hasNext() || !lists_[0]->empty())
{
Bucket* bucket = lists_[0];
lists_[0] = NULL;
pushBucket(0);
do {
crossOff(sieve, bucket->begin(), bucket->end());
Bucket* processed = bucket;
bucket = bucket->next();
processed->reset();
moveBucket(*processed, stock_);
} while (bucket);
}
// move the list corresponding to the next segment
// i.e. lists_[1] to lists_[0] ...
std::rotate(lists_.begin(), lists_.begin() + 1, lists_.end());
}
/// Cross-off the multiples of the sieving primes within the current
/// bucket. This is an implementation of the segmented sieve of
/// Eratosthenes with wheel factorization optimized for small sieving
/// primes that have many multiples per segment. This algorithm uses a
/// hardcoded modulo 30 wheel that skips multiples of 2, 3 and 5.
///
void EratSmall::crossOff(byte_t* sieve, byte_t* sieveLimit, Bucket& bucket)
{
SievingPrime* sPrime = bucket.begin();
SievingPrime* sEnd = bucket.end();
for (; sPrime != sEnd; sPrime++)
{
uint_t sievingPrime = sPrime->getSievingPrime();
uint_t multipleIndex = sPrime->getMultipleIndex();
uint_t wheelIndex = sPrime->getWheelIndex();
// pointer to the byte containing the first multiple
// of sievingPrime within the current segment
byte_t* p = &sieve[multipleIndex];
byte_t* loopLimit = sieveLimit - (sievingPrime * 28 + 27);
if (loopLimit > sieveLimit)
loopLimit = p;
switch (wheelIndex)
{
for (;;) // i*30 + 7
{
case 0: // each iteration removes the next 8 multiples
// of the current sievingPrime
for (; p < loopLimit; p += sievingPrime * 30 + 7)
{
p[sievingPrime * 0 + 0] &= BIT0;
p[sievingPrime * 6 + 1] &= BIT4;
p[sievingPrime * 10 + 2] &= BIT3;
p[sievingPrime * 12 + 2] &= BIT7;
p[sievingPrime * 16 + 3] &= BIT6;
p[sievingPrime * 18 + 4] &= BIT2;
p[sievingPrime * 22 + 5] &= BIT1;
p[sievingPrime * 28 + 6] &= BIT5;
}
if (p >= sieveLimit) { sPrime->setWheelIndex(0); break; }
*p &= BIT0; p += sievingPrime * 6 + 1;
case 1: if (p >= sieveLimit) { sPrime->setWheelIndex(1); break; }
*p &= BIT4; p += sievingPrime * 4 + 1;
case 2: if (p >= sieveLimit) { sPrime->setWheelIndex(2); break; }
*p &= BIT3; p += sievingPrime * 2 + 0;
case 3: if (p >= sieveLimit) { sPrime->setWheelIndex(3); break; }
*p &= BIT7; p += sievingPrime * 4 + 1;
case 4: if (p >= sieveLimit) { sPrime->setWheelIndex(4); break; }
*p &= BIT6; p += sievingPrime * 2 + 1;
case 5: if (p >= sieveLimit) { sPrime->setWheelIndex(5); break; }
*p &= BIT2; p += sievingPrime * 4 + 1;
case 6: if (p >= sieveLimit) { sPrime->setWheelIndex(6); break; }
*p &= BIT1; p += sievingPrime * 6 + 1;
case 7: if (p >= sieveLimit) { sPrime->setWheelIndex(7); break; }
*p &= BIT5; p += sievingPrime * 2 + 1;
}
break;
for (;;) // i*30 + 11
{
case 8: for (; p < loopLimit; p += sievingPrime * 30 + 11)
{
p[sievingPrime * 0 + 0] &= BIT1;
p[sievingPrime * 6 + 2] &= BIT3;
p[sievingPrime * 10 + 3] &= BIT7;
p[sievingPrime * 12 + 4] &= BIT5;
p[sievingPrime * 16 + 6] &= BIT0;
p[sievingPrime * 18 + 6] &= BIT6;
p[sievingPrime * 22 + 8] &= BIT2;
p[sievingPrime * 28 + 10] &= BIT4;
}
if (p >= sieveLimit) { sPrime->setWheelIndex(8); break; }
*p &= BIT1; p += sievingPrime * 6 + 2;
case 9: if (p >= sieveLimit) { sPrime->setWheelIndex(9); break; }
*p &= BIT3; p += sievingPrime * 4 + 1;
case 10: if (p >= sieveLimit) { sPrime->setWheelIndex(10); break; }
*p &= BIT7; p += sievingPrime * 2 + 1;
case 11: if (p >= sieveLimit) { sPrime->setWheelIndex(11); break; }
*p &= BIT5; p += sievingPrime * 4 + 2;
case 12: if (p >= sieveLimit) { sPrime->setWheelIndex(12); break; }
*p &= BIT0; p += sievingPrime * 2 + 0;
case 13: if (p >= sieveLimit) { sPrime->setWheelIndex(13); break; }
*p &= BIT6; p += sievingPrime * 4 + 2;
case 14: if (p >= sieveLimit) { sPrime->setWheelIndex(14); break; }
*p &= BIT2; p += sievingPrime * 6 + 2;
case 15: if (p >= sieveLimit) { sPrime->setWheelIndex(15); break; }
*p &= BIT4; p += sievingPrime * 2 + 1;
}
break;
for (;;) // i*30 + 13
{
case 16: for (; p < loopLimit; p += sievingPrime * 30 + 13)
{
p[sievingPrime * 0 + 0] &= BIT2;
p[sievingPrime * 6 + 2] &= BIT7;
p[sievingPrime * 10 + 4] &= BIT5;
p[sievingPrime * 12 + 5] &= BIT4;
p[sievingPrime * 16 + 7] &= BIT1;
p[sievingPrime * 18 + 8] &= BIT0;
p[sievingPrime * 22 + 9] &= BIT6;
p[sievingPrime * 28 + 12] &= BIT3;
}
if (p >= sieveLimit) { sPrime->setWheelIndex(16); break; }
*p &= BIT2; p += sievingPrime * 6 + 2;
case 17: if (p >= sieveLimit) { sPrime->setWheelIndex(17); break; }
*p &= BIT7; p += sievingPrime * 4 + 2;
case 18: if (p >= sieveLimit) { sPrime->setWheelIndex(18); break; }
*p &= BIT5; p += sievingPrime * 2 + 1;
case 19: if (p >= sieveLimit) { sPrime->setWheelIndex(19); break; }
*p &= BIT4; p += sievingPrime * 4 + 2;
case 20: if (p >= sieveLimit) { sPrime->setWheelIndex(20); break; }
*p &= BIT1; p += sievingPrime * 2 + 1;
case 21: if (p >= sieveLimit) { sPrime->setWheelIndex(21); break; }
*p &= BIT0; p += sievingPrime * 4 + 1;
case 22: if (p >= sieveLimit) { sPrime->setWheelIndex(22); break; }
*p &= BIT6; p += sievingPrime * 6 + 3;
case 23: if (p >= sieveLimit) { sPrime->setWheelIndex(23); break; }
*p &= BIT3; p += sievingPrime * 2 + 1;
}
break;
for (;;) // i*30 + 17
{
case 24: for (; p < loopLimit; p += sievingPrime * 30 + 17)
{
p[sievingPrime * 0 + 0] &= BIT3;
p[sievingPrime * 6 + 3] &= BIT6;
p[sievingPrime * 10 + 6] &= BIT0;
p[sievingPrime * 12 + 7] &= BIT1;
p[sievingPrime * 16 + 9] &= BIT4;
p[sievingPrime * 18 + 10] &= BIT5;
p[sievingPrime * 22 + 12] &= BIT7;
p[sievingPrime * 28 + 16] &= BIT2;
}
if (p >= sieveLimit) { sPrime->setWheelIndex(24); break; }
*p &= BIT3; p += sievingPrime * 6 + 3;
case 25: if (p >= sieveLimit) { sPrime->setWheelIndex(25); break; }
*p &= BIT6; p += sievingPrime * 4 + 3;
case 26: if (p >= sieveLimit) { sPrime->setWheelIndex(26); break; }
*p &= BIT0; p += sievingPrime * 2 + 1;
case 27: if (p >= sieveLimit) { sPrime->setWheelIndex(27); break; }
*p &= BIT1; p += sievingPrime * 4 + 2;
case 28: if (p >= sieveLimit) { sPrime->setWheelIndex(28); break; }
*p &= BIT4; p += sievingPrime * 2 + 1;
case 29: if (p >= sieveLimit) { sPrime->setWheelIndex(29); break; }
*p &= BIT5; p += sievingPrime * 4 + 2;
case 30: if (p >= sieveLimit) { sPrime->setWheelIndex(30); break; }
*p &= BIT7; p += sievingPrime * 6 + 4;
case 31: if (p >= sieveLimit) { sPrime->setWheelIndex(31); break; }
*p &= BIT2; p += sievingPrime * 2 + 1;
}
break;
for (;;) // i*30 + 19
{
case 32: for (; p < loopLimit; p += sievingPrime * 30 + 19)
{
p[sievingPrime * 0 + 0] &= BIT4;
p[sievingPrime * 6 + 4] &= BIT2;
p[sievingPrime * 10 + 6] &= BIT6;
p[sievingPrime * 12 + 8] &= BIT0;
p[sievingPrime * 16 + 10] &= BIT5;
p[sievingPrime * 18 + 11] &= BIT7;
p[sievingPrime * 22 + 14] &= BIT3;
p[sievingPrime * 28 + 18] &= BIT1;
}
if (p >= sieveLimit) { sPrime->setWheelIndex(32); break; }
*p &= BIT4; p += sievingPrime * 6 + 4;
case 33: if (p >= sieveLimit) { sPrime->setWheelIndex(33); break; }
*p &= BIT2; p += sievingPrime * 4 + 2;
case 34: if (p >= sieveLimit) { sPrime->setWheelIndex(34); break; }
*p &= BIT6; p += sievingPrime * 2 + 2;
case 35: if (p >= sieveLimit) { sPrime->setWheelIndex(35); break; }
*p &= BIT0; p += sievingPrime * 4 + 2;
case 36: if (p >= sieveLimit) { sPrime->setWheelIndex(36); break; }
*p &= BIT5; p += sievingPrime * 2 + 1;
case 37: if (p >= sieveLimit) { sPrime->setWheelIndex(37); break; }
*p &= BIT7; p += sievingPrime * 4 + 3;
case 38: if (p >= sieveLimit) { sPrime->setWheelIndex(38); break; }
*p &= BIT3; p += sievingPrime * 6 + 4;
case 39: if (p >= sieveLimit) { sPrime->setWheelIndex(39); break; }
*p &= BIT1; p += sievingPrime * 2 + 1;
}
break;
for (;;) // i*30 + 23
{
case 40: for (; p < loopLimit; p += sievingPrime * 30 + 23)
{
p[sievingPrime * 0 + 0] &= BIT5;
p[sievingPrime * 6 + 5] &= BIT1;
p[sievingPrime * 10 + 8] &= BIT2;
p[sievingPrime * 12 + 9] &= BIT6;
p[sievingPrime * 16 + 12] &= BIT7;
p[sievingPrime * 18 + 14] &= BIT3;
p[sievingPrime * 22 + 17] &= BIT4;
p[sievingPrime * 28 + 22] &= BIT0;
}
if (p >= sieveLimit) { sPrime->setWheelIndex(40); break; }
*p &= BIT5; p += sievingPrime * 6 + 5;
case 41: if (p >= sieveLimit) { sPrime->setWheelIndex(41); break; }
*p &= BIT1; p += sievingPrime * 4 + 3;
case 42: if (p >= sieveLimit) { sPrime->setWheelIndex(42); break; }
*p &= BIT2; p += sievingPrime * 2 + 1;
case 43: if (p >= sieveLimit) { sPrime->setWheelIndex(43); break; }
*p &= BIT6; p += sievingPrime * 4 + 3;
case 44: if (p >= sieveLimit) { sPrime->setWheelIndex(44); break; }
*p &= BIT7; p += sievingPrime * 2 + 2;
case 45: if (p >= sieveLimit) { sPrime->setWheelIndex(45); break; }
*p &= BIT3; p += sievingPrime * 4 + 3;
case 46: if (p >= sieveLimit) { sPrime->setWheelIndex(46); break; }
*p &= BIT4; p += sievingPrime * 6 + 5;
case 47: if (p >= sieveLimit) { sPrime->setWheelIndex(47); break; }
*p &= BIT0; p += sievingPrime * 2 + 1;
}
break;
for (;;) // i*30 + 29
{
case 48: for (; p < loopLimit; p += sievingPrime * 30 + 29)
{
p[sievingPrime * 0 + 0] &= BIT6;
p[sievingPrime * 6 + 6] &= BIT5;
p[sievingPrime * 10 + 10] &= BIT4;
p[sievingPrime * 12 + 12] &= BIT3;
p[sievingPrime * 16 + 16] &= BIT2;
p[sievingPrime * 18 + 18] &= BIT1;
p[sievingPrime * 22 + 22] &= BIT0;
p[sievingPrime * 28 + 27] &= BIT7;
}
if (p >= sieveLimit) { sPrime->setWheelIndex(48); break; }
*p &= BIT6; p += sievingPrime * 6 + 6;
case 49: if (p >= sieveLimit) { sPrime->setWheelIndex(49); break; }
*p &= BIT5; p += sievingPrime * 4 + 4;
case 50: if (p >= sieveLimit) { sPrime->setWheelIndex(50); break; }
*p &= BIT4; p += sievingPrime * 2 + 2;
case 51: if (p >= sieveLimit) { sPrime->setWheelIndex(51); break; }
*p &= BIT3; p += sievingPrime * 4 + 4;
case 52: if (p >= sieveLimit) { sPrime->setWheelIndex(52); break; }
*p &= BIT2; p += sievingPrime * 2 + 2;
case 53: if (p >= sieveLimit) { sPrime->setWheelIndex(53); break; }
*p &= BIT1; p += sievingPrime * 4 + 4;
case 54: if (p >= sieveLimit) { sPrime->setWheelIndex(54); break; }
*p &= BIT0; p += sievingPrime * 6 + 5;
case 55: if (p >= sieveLimit) { sPrime->setWheelIndex(55); break; }
*p &= BIT7; p += sievingPrime * 2 + 2;
}
break;
for (;;) // i*30 + 31
{
case 56: for (; p < loopLimit; p += sievingPrime * 30 + 1)
{
p[sievingPrime * 0 + 0] &= BIT7;
p[sievingPrime * 6 + 1] &= BIT0;
p[sievingPrime * 10 + 1] &= BIT1;
p[sievingPrime * 12 + 1] &= BIT2;
p[sievingPrime * 16 + 1] &= BIT3;
p[sievingPrime * 18 + 1] &= BIT4;
p[sievingPrime * 22 + 1] &= BIT5;
p[sievingPrime * 28 + 1] &= BIT6;
}
if (p >= sieveLimit) { sPrime->setWheelIndex(56); break; }
*p &= BIT7; p += sievingPrime * 6 + 1;
case 57: if (p >= sieveLimit) { sPrime->setWheelIndex(57); break; }
*p &= BIT0; p += sievingPrime * 4 + 0;
case 58: if (p >= sieveLimit) { sPrime->setWheelIndex(58); break; }
*p &= BIT1; p += sievingPrime * 2 + 0;
case 59: if (p >= sieveLimit) { sPrime->setWheelIndex(59); break; }
*p &= BIT2; p += sievingPrime * 4 + 0;
case 60: if (p >= sieveLimit) { sPrime->setWheelIndex(60); break; }
*p &= BIT3; p += sievingPrime * 2 + 0;
case 61: if (p >= sieveLimit) { sPrime->setWheelIndex(61); break; }
*p &= BIT4; p += sievingPrime * 4 + 0;
case 62: if (p >= sieveLimit) { sPrime->setWheelIndex(62); break; }
*p &= BIT5; p += sievingPrime * 6 + 0;
case 63: if (p >= sieveLimit) { sPrime->setWheelIndex(63); break; }
*p &= BIT6; p += sievingPrime * 2 + 0;
}
break;
}
// set multipleIndex for the next segment
sPrime->setMultipleIndex(static_cast<uint_t>(p - sieveLimit));
}
}