static void *Worker( void *arg ) {
TYPE id = (size_t)arg;
uint64_t entry;
#ifdef FAST
unsigned int cnt = 0, oid = id;
#endif // FAST
for ( int r = 0; r < RUNS; r += 1 ) {
entry = 0;
while ( stop == 0 ) {
// step 1, select a ticket
choosing[id] = 1; // entry protocol
Fence(); // force store before more loads
TYPE max = 0; // O(N) search for largest ticket
for ( int j = 0; j < N; j += 1 ) {
TYPE v = ticket[j]; // could change so must copy
if ( max < v ) max = v;
} // for
#if 1
max += 1; // advance ticket
ticket[id] = max;
choosing[id] = 0;
Fence(); // force store before more loads
// step 2, wait for ticket to be selected
for ( int j = 0; j < N; j += 1 ) { // check other tickets
while ( choosing[j] == 1 ) Pause(); // busy wait if thread selecting ticket
while ( ticket[j] != 0 && // busy wait if choosing or
( ticket[j] < max || // greater ticket value or lower priority
( ticket[j] == max && j < id ) ) ) Pause();
} // for
#else
ticket[id] = max + 1; // advance ticket
choosing[id] = 0;
Fence(); // force store before more loads
// step 2, wait for ticket to be selected
for ( int j = 0; j < N; j += 1 ) { // check other tickets
while ( choosing[j] == 1 ) Pause(); // busy wait if thread selecting ticket
while ( ticket[j] != 0 && // busy wait if choosing or
( ticket[j] < ticket[id] || // greater ticket value or lower priority
( ticket[j] == ticket[id] && j < id ) ) ) Pause();
} // for
#endif
CriticalSection( id );
ticket[id] = 0; // exit protocol
#ifdef FAST
id = startpoint( cnt ); // different starting point each experiment
cnt = cycleUp( cnt, NoStartPoints );
#endif // FAST
entry += 1;
} // while
#ifdef FAST
id = oid;
#endif // FAST
entries[r][id] = entry;
__sync_fetch_and_add( &Arrived, 1 );
while ( stop != 0 ) Pause();
__sync_fetch_and_add( &Arrived, -1 );
} // for
return NULL;
} // Worker
//startbit
int Drone_IR::startbit(int arraylen, int* array, int sp) {
int rgArray[] = {1000, 2000}, i;
if (arraylen - DATALEN < sp)return -1;
for (int c = sp; c < arraylen - DATALEN; c++) {
sp = startpoint(arraylen, array, c);
if (sp == -1)return -1;
for (i = 0; i < 4; i++) {
if (!range(1500, rgArray[i % 2], array[sp - 1 + i * 2]))break;
}
if (i >= 4) return sp;
}
}
static void *Worker( void *arg ) {
TYPE id = (size_t)arg;
uint64_t entry;
#ifdef FAST
unsigned int cnt = 0, oid = id;
#endif // FAST
int j;
for ( int r = 0; r < RUNS; r += 1 ) {
entry = 0;
while ( stop == 0 ) {
flag[id] = 1;
Fence(); // force store before more loads
for ( j = 0; j < N; j += 1 ) // wait until doors open
await( flag[j] < 3 );
flag[id] = 3; // close door 1
Fence(); // force store before more loads
for ( j = 0; j < N; j += 1 ) // check for
if ( flag[j] == 1 ) { // others in group ?
flag[id] = 2; // enter waiting room
Fence(); // force store before more loads
L: for ( int k = 0; k < N; k += 1 ) // wait for
if ( flag[k] == 4 ) goto fini; // door 2 to open
goto L;
fini: ;
} // if
flag[id] = 4; // open door 2
Fence(); // force store before more loads
// for ( j = 0; j < N; j += 1 ) // wait for all threads in waiting room
// await( flag[j] < 2 || flag[j] > 3 ); // to pass through door 2
for ( j = 0; j < id; j += 1 ) // service threads in priority order
await( flag[j] < 2 );
CriticalSection( id );
for ( j = id + 1; j < N; j += 1 ) // wait for all threads in waiting room
await( flag[j] < 2 || flag[j] > 3 ); // to pass through door 2
flag[id] = 0;
#ifdef FAST
id = startpoint( cnt ); // different starting point each experiment
cnt = cycleUp( cnt, NoStartPoints );
#endif // FAST
entry += 1;
} // while
#ifdef FAST
id = oid;
#endif // FAST
entries[r][id] = entry;
__sync_fetch_and_add( &Arrived, 1 );
while ( stop != 0 ) Pause();
__sync_fetch_and_add( &Arrived, -1 );
} // for
return NULL;
} // Worker
static void *Worker( void *arg ) {
TYPE id = (size_t)arg;
uint64_t entry;
#ifdef FAST
unsigned int cnt = 0, oid = id;
#endif // FAST
TYPE copy[N];
int j;
for ( int r = 0; r < RUNS; r += 1 ) {
entry = 0;
while ( stop == 0 ) {
c[id] = 1; // stage 1, establish FCFS
Fence(); // force store before more loads
for ( j = 0; j < N; j += 1 ) // copy turn values
copy[j] = turn[j];
// turn[id] = cycleUp( turn[id], 4 ); // advance my turn
turn[id] = cycleUp( turn[id], 3 ); // advance my turn
v[id] = 1;
c[id] = 0;
Fence(); // force store before more loads
for ( j = 0; j < N; j += 1 )
while ( c[j] != 0 || (v[j] != 0 && copy[j] == turn[j]) ) Pause();
L: intents[id] = 1; // B-L
Fence(); // force store before more loads
for ( j = 0; j < id; j += 1 ) // stage 2, high priority search
if ( intents[j] != 0 ) {
intents[id] = 0;
Fence(); // force store before more loads
while ( intents[j] != 0 ) Pause();
goto L;
} // if
for ( j = id + 1; j < N; j += 1 ) // stage 3, low priority search
while ( intents[j] != 0 ) Pause();
CriticalSection( id );
v[id] = intents[id] = 0; // exit protocol
#ifdef FAST
id = startpoint( cnt ); // different starting point each experiment
cnt = cycleUp( cnt, NoStartPoints );
#endif // FAST
entry += 1;
} // while
#ifdef FAST
id = oid;
#endif // FAST
entries[r][id] = entry;
__sync_fetch_and_add( &Arrived, 1 );
while ( stop != 0 ) Pause();
__sync_fetch_and_add( &Arrived, -1 );
} // for
return NULL;
} // Worker
void SpiralShape::updatePath(const QSizeF &size)
{
createPath(size);
normalize();
#if 0
Q_UNUSED(size);
QPointF startpoint(m_handles[0]);
QPointF curvePoints[12];
int pointCnt = arcToCurve(m_radii.x(), m_radii.y(), m_startAngle, sweepAngle() , startpoint, curvePoints);
int cp = 0;
m_points[cp]->setPoint(startpoint);
m_points[cp]->unsetProperty(KoPathPoint::HasControlPoint1);
for (int i = 0; i < pointCnt; i += 3)
{
m_points[cp]->setControlPoint2(curvePoints[i]);
m_points[++cp]->setControlPoint1(curvePoints[i+1]);
m_points[cp]->setPoint(curvePoints[i+2]);
m_points[cp]->unsetProperty(KoPathPoint::HasControlPoint2);
}
if (m_type == Curve)
{
m_points[++cp]->setPoint(m_center);
m_points[cp]->unsetProperty(KoPathPoint::HasControlPoint1);
m_points[cp]->unsetProperty(KoPathPoint::HasControlPoint2);
}
else if (m_type == Line && m_startAngle == m_endAngle)
{
m_points[0]->setControlPoint1(m_points[cp]->controlPoint1());
m_points[0]->setPoint(m_points[cp]->point());
--cp;
}
m_subpaths[0]->clear();
for (int i = 0; i <= cp; ++i)
{
if (i < cp || (m_type == Line && m_startAngle != m_endAngle))
{
m_points[i]->unsetProperty(KoPathPoint::CloseSubpath);
}
else
{
m_points[i]->setProperty(KoPathPoint::CloseSubpath);
}
m_subpaths[0]->push_back(m_points[i]);
}
#endif
}
static void *Worker( void *arg ) {
TYPE id = (size_t)arg;
uint64_t entry;
#ifdef FAST
unsigned int cnt = 0, oid = id;
#endif // FAST
for ( int r = 0; r < RUNS; r += 1 ) {
entry = 0;
while ( atomic_load(&stop) == 0 ) {
atomic_store(&states[id*PADRATIO], LOCKED);
while (1) {
int lturn = atomic_load(&turn);
if (!validate_left(id, lturn)) {
atomic_store(&states[id*PADRATIO], WAITING);
while (1) {
if (validate_left(id, lturn) && lturn == atomic_load_explicit(&turn, memory_order_acquire)) break;
Pause();
lturn = atomic_load_explicit(&turn, memory_order_acquire);
}
atomic_store(&states[id*PADRATIO], LOCKED);
continue;
}
while (lturn == atomic_load_explicit(&turn, memory_order_acquire)) {
if (validate_right(id, lturn)) break;
Pause();
}
if (lturn == atomic_load_explicit(&turn, memory_order_acquire)) break;
}
CriticalSection( id ); // critical section
int lturn = (atomic_load_explicit(&turn, memory_order_relaxed)+1) % N;
atomic_store_explicit(&turn, lturn, memory_order_relaxed);
atomic_store_explicit(&states[id*PADRATIO], UNLOCKED, memory_order_release); // exit protocol
#ifdef FAST
id = startpoint( cnt ); // different starting point each experiment
cnt = cycleUp( cnt, NoStartPoints );
#endif // FAST
entry += 1;
} // while
#ifdef FAST
id = oid;
#endif // FAST
entries[r][id] = entry;
atomic_fetch_add( &Arrived, 1 );
while ( atomic_load(&stop) != 0 ) Pause();
atomic_fetch_add( &Arrived, -1 );
} // for
return NULL;
} // Worker
static void *Worker( void *arg ) {
TYPE id = (size_t)arg;
uint64_t entry;
#ifdef FAST
unsigned int cnt = 0, oid = id;
#endif // FAST
TYPE temp;
for ( int r = 0; r < RUNS; r += 1 ) {
entry = 0;
while ( stop == 0 ) {
if ( id == 0 ) {
temp = Q[1];
Q[0] = temp == Z ? T : (temp == T ? T : F);
Fence();
temp = Q[1];
Q[0] = temp == Z ? Q[0] : (temp == T ? T : F);
Fence();
await( Q[1] != Q[0] );
} else {
temp = Q[0];
Q[1] = temp == Z ? T : (temp == T ? F : T);
Fence();
temp = Q[0];
Q[1] = temp == Z ? Q[1] : (temp == T ? F : T);
Fence();
await( Q[0] == Z || Q[0] == Q[1] );
} // for
CriticalSection( id );
Q[id] = Z;
#ifdef FAST
id = startpoint( cnt ); // different starting point each experiment
cnt = cycleUp( cnt, NoStartPoints );
#endif // FAST
entry += 1;
} // while
#ifdef FAST
id = oid;
#endif // FAST
entries[r][id] = entry;
__sync_fetch_and_add( &Arrived, 1 );
while ( stop != 0 ) Pause();
__sync_fetch_and_add( &Arrived, -1 );
} // for
return NULL;
} // Worker
static void *Worker( void *arg ) {
TYPE id = (size_t)arg;
uint64_t entry;
#ifdef FAST
unsigned int cnt = 0, oid = id;
#endif // FAST
for ( int r = 0; r < RUNS; r += 1 ) {
entry = 0;
while ( stop == 0 ) {
L0: control[id] = WantIn; // entry protocol
Fence(); // force store before more loads
// step 1, wait for threads with higher priority
L1: for ( int j = HIGH; j != id; j = cycleUp( j, N ) )
if ( control[j] != DontWantIn ) { Pause(); goto L1; } // restart search
control[id] = EnterCS;
Fence(); // force store before more loads
// step 2, check for any other thread finished step 1
for ( int j = 0; j < N; j += 1 )
if ( j != id && control[j] == EnterCS ) goto L0;
if ( control[HIGH] != DontWantIn && HIGH != id ) goto L0;
HIGH = id; // its now ok to enter
CriticalSection( id );
// look for any thread that wants in other than this thread
// for ( int j = cycleUp( id + 1, N );; j = cycleUp( j, N ) ) // exit protocol
for ( int j = cycleUp( HIGH + 1, N );; j = cycleUp( j, N ) ) // exit protocol
if ( control[j] != DontWantIn ) { HIGH = j; break; }
control[id] = DontWantIn;
#ifdef FAST
id = startpoint( cnt ); // different starting point each experiment
cnt = cycleUp( cnt, NoStartPoints );
#endif // FAST
entry += 1;
} // while
#ifdef FAST
id = oid;
#endif // FAST
entries[r][id] = entry;
__sync_fetch_and_add( &Arrived, 1 );
while ( stop != 0 ) Pause();
__sync_fetch_and_add( &Arrived, -1 );
} // for
return NULL;
} // Worker
static void *Worker( void *arg ) {
TYPE id = (size_t)arg;
uint64_t entry;
int other = inv( id );
#ifdef FAST
unsigned int cnt = 0, oid = id;
#endif // FAST
for ( int r = 0; r < RUNS; r += 1 ) {
entry = 0;
while ( atomic_load(&stop) == 0 ) {
if ( id == 0 ) {
atomic_store(intents[id], WantIn); // declare intent
if ( atomic_load(intents[other]) == WantIn ) { // other thread want in ?
if ( atomic_load_explicit(last, memory_order_acquire) == id ) { // low priority task ?
atomic_store(intents[id], DontWantIn); // retract intent
await( atomic_load(last) != id ); // low priority busy wait
atomic_store(intents[id], WantIn); // re-declare intent
} // if
await( atomic_load(intents[other]) == DontWantIn ); // high priority busy wait
} // if
CriticalSection( id ); // critical section
atomic_store_explicit(last, id, memory_order_release); // exit protocol
atomic_store_explicit(intents[id], DontWantIn, memory_order_release);
}
#ifdef FAST
id = startpoint( cnt ); // different starting point each experiment
cnt = cycleUp( cnt, NoStartPoints );
#endif // FAST
entry += 1;
} // while
#ifdef FAST
id = oid;
#endif // FAST
entries[r][id] = entry;
atomic_fetch_add( &Arrived, 1 );
while ( atomic_load(&stop) != 0 ) Pause();
atomic_fetch_add( &Arrived, -1 );
} // for
return NULL;
} // Worker
static void *Worker( void *arg ) {
TYPE id = (size_t)arg;
uint64_t entry;
#ifdef FAST
unsigned int cnt = 0, oid = id;
#endif // FAST
for ( int r = 0; r < RUNS; r += 1 ) {
entry = 0;
while ( stop == 0 ) {
L: intents[id] = WantIn;
Fence(); // force store before more loads
for ( int j = 0; j < id; j += 1 ) { // check if thread with higher id wants in
// for ( int j = id - 1; j >= 0; j -= 1 ) {
if ( intents[j] == WantIn ) {
intents[id] = DontWantIn;
Fence(); // force store before more loads
while ( intents[j] == WantIn ) Pause();
goto L;
} // if
} // for
for ( int j = id + 1; j < N; j += 1 )
while ( intents[j] == WantIn ) Pause();
CriticalSection( id ); // critical section
intents[id] = DontWantIn; // exit protocol
#ifdef FAST
id = startpoint( cnt ); // different starting point each experiment
cnt = cycleUp( cnt, NoStartPoints );
#endif // FAST
entry += 1;
} // while
#ifdef FAST
id = oid;
#endif // FAST
entries[r][id] = entry;
__sync_fetch_and_add( &Arrived, 1 );
while ( stop != 0 ) Pause();
__sync_fetch_and_add( &Arrived, -1 );
} // for
return NULL;
} // Worker
static void *Worker( void *arg ) {
TYPE id = (size_t)arg;
uint64_t entry;
#ifdef FAST
unsigned int cnt = 0, oid = id;
#endif // FAST
unsigned int lid; // local id at each tree level
for ( int r = 0; r < RUNS; r += 1 ) {
entry = 0;
while ( stop == 0 ) {
lid = id; // entry protocol
for ( int lv = 0; lv < depth; lv += 1 ) {
binary_prologue( lid & 1, &t[lv][lid >> 1] );
lid >>= 1; // advance local id for next tree level
} // for
CriticalSection( id );
for ( int lv = depth - 1; lv >= 0; lv -= 1 ) { // exit protocol, retract reverse order
lid = id >> lv;
binary_epilogue( lid & 1, &t[lv][lid >> 1] );
} // for
#ifdef FAST
id = startpoint( cnt ); // different starting point each experiment
cnt = cycleUp( cnt, NoStartPoints );
#endif // FAST
entry += 1;
} // while
#ifdef FAST
id = oid;
#endif // FAST
entries[r][id] = entry;
__sync_fetch_and_add( &Arrived, 1 );
while ( stop != 0 ) Pause();
__sync_fetch_and_add( &Arrived, -1 );
} // for
return NULL;
} // Worker
static void *Worker( void *arg ) {
TYPE id = (size_t)arg;
uint64_t entry;
int other = inv( id ); // int is better than TYPE
#ifdef FAST
unsigned int cnt = 0, oid = id;
#endif // FAST
for ( int r = 0; r < RUNS; r += 1 ) {
entry = 0;
while ( stop == 0 ) {
intents[id] = WantIn; // entry protocol
last = id; // RACE
Fence(); // force store before more loads
if ( FASTPATH( intents[other] != DontWantIn ) ) // local spin
while ( last == id ) Pause(); // busy wait
CriticalSection( id );
intents[id] = DontWantIn; // exit protocol
last = id;
#ifdef FAST
id = startpoint( cnt ); // different starting point each experiment
other = inv( id );
cnt = cycleUp( cnt, NoStartPoints );
#endif // FAST
entry += 1;
} // while
#ifdef FAST
id = oid;
other = inv( id );
#endif // FAST
entries[r][id] = entry;
__sync_fetch_and_add( &Arrived, 1 );
while ( stop != 0 ) Pause();
__sync_fetch_and_add( &Arrived, -1 );
} // for
return NULL;
} // Worker
static void *Worker( void *arg ) {
TYPE id = (size_t)arg;
#ifdef FAST
unsigned int cnt = 0, oid = id;
#endif // FAST
uint64_t entry;
for ( int r = 0; r < RUNS; r += 1 ) {
entry = 0;
while ( stop == 0 ) {
L0: control[id] = WantIn; // entry protocol
Fence(); // force store before more loads
L1: for ( int j = turn; j != id; j = cycleDown( j, N ) )
if ( control[j] != DontWantIn ) { Pause(); goto L1; } // restart search
control[id] = EnterCS;
Fence(); // force store before more loads
for ( int j = N - 1; j >= 0; j -= 1 )
if ( j != id && control[j] == EnterCS ) goto L0;
CriticalSection( id );
// cycle through threads
if ( control[turn] == DontWantIn || turn == id ) // exit protocol
turn = cycleDown( turn, N );
control[id] = DontWantIn;
#ifdef FAST
id = startpoint( cnt ); // different starting point each experiment
cnt = cycleUp( cnt, NoStartPoints );
#endif // FAST
entry += 1;
} // while
#ifdef FAST
id = oid;
#endif // FAST
entries[r][id] = entry;
__sync_fetch_and_add( &Arrived, 1 );
while ( stop != 0 ) Pause();
__sync_fetch_and_add( &Arrived, -1 );
} // for
return NULL;
} // Worker
void PointSet::AddControlVolume ( std::vector<glm::vec3> *allvertices )
{
Vector3DF pos;
Point* p;
int dimx=5;
int dimy=5;
float dimz=10;
int ccnt=0;
//vec3 a = myvertices. ;
glm::vec3 startpoint(0,0.0,-5.0);
glm::vec3 direction(0,0,1.0);
glm::vec3 vertex1(0,1.0,2.0);
glm::vec3 vertex2(-1.0,-1.0,0);
glm::vec3 vertex3(1.0,-1.0,0);
glm::vec3 v1,v2,v3;
int a = allvertices->size();
double value=0;
value=PointSet::Test_RayPolyIntersect(startpoint,direction,vertex1,vertex2,vertex3);
int count=0;
float var=1.0;
//glm::vec3 *a = myvertices;
for (float x = -5; x < 18; x += 1.0)
{
for (float y = -5; y <= 14; y += 1.0)
{
for (float z = -5; z <= 25; z += var )
{
/*if(z>=-5.0 && z <2.0)
var =1.0;
else if(z>=2.0 && z < 8.0)
var =0.70;
else if(z>=8.0 && z < 15.0)
var =0.6;
else if(z >= 15.0 && z <=25.0)
var =0.3;*/
count = 0 ;
startpoint=glm::vec3((float)x,(float)y,(float)z);
direction=glm::vec3(1.0,0.1,0);
for(int v=0 ;v < a ; v+=3)
{
//checking each vertex in the grid with all the 192 triangles of mesh
v1=(*allvertices)[v];
v2=(*allvertices)[v+1];
v3=(*allvertices)[v+2];
vertex1= vec3(v1[0],v1[1],v1[2]);
vertex2= vec3(v2[0],v2[1],v2[2]);
vertex3= vec3(v3[0],v3[1],v3[2]);
value=PointSet::Test_RayPolyIntersect(startpoint,direction,vertex1,vertex2,vertex3);
if(value != -1.0)
{
count++;
}
}
//odd
if( count % 2 == 1)
{
//inside the mesh
p = GetPoint ( AddPointReuse () );
pos.Set ( x,y,z+10.0f);
p->pos = pos;
p->type = 1;
p->clr = COLORA( 1.0,0.3,0.3, 0); /// 0.1,0.3,1.0,1.0
ccnt++;
}
//var=var-0.1;
}
// var = 1.0;
}
}
}
static void *Worker( void *arg ) {
TYPE id = (size_t)arg;
uint64_t entry;
int other = inv( id ); // int is better than TYPE
#ifdef FAST
unsigned int cnt = 0, oid = id;
#endif // FAST
for ( int r = 0; r < RUNS; r += 1 ) {
entry = 0;
while ( stop == 0 ) {
#ifdef FLICKER
for ( int i = 0; i < 100; i += 1 ) cc[id] = i % 2; // flicker
#endif // FLICKER
cc[id] = WantIn; // declare intent
Fence(); // force store before more loads
while ( cc[other] == WantIn ) {
if ( FASTPATH( last == id ) ) {
#ifdef FLICKER
for ( int i = 0; i < 100; i += 1 ) cc[id] = i % 2; // flicker
#endif // FLICKER
cc[id] = DontWantIn;
while( cc[other] == WantIn && last == id ) Pause(); // low priority busy wait
#ifdef FLICKER
for ( int i = 0; i < 100; i += 1 ) cc[id] = i % 2; // flicker
#endif // FLICKER
cc[id] = WantIn; // declare intent
Fence(); // force store before more loads
} // if
} // while
CriticalSection( id );
if ( last != id ) {
#ifdef FLICKER
for ( int i = id; i < 100; i += 1 ) last = i % 2; // flicker
#endif // FLICKER
last = id;
} // if
#ifdef FLICKER
for ( int i = 0; i < 100; i += 1 ) cc[id] = i % 2; // flicker
#endif // FLICKER
cc[id] = DontWantIn;
#ifdef FAST
id = startpoint( cnt ); // different starting point each experiment
other = inv( id );
cnt = cycleUp( cnt, NoStartPoints );
#endif // FAST
entry += 1;
} // while
#ifdef FAST
id = oid;
other = inv( id );
#endif // FAST
entries[r][id] = entry;
__sync_fetch_and_add( &Arrived, 1 );
while ( stop != 0 ) Pause();
__sync_fetch_and_add( &Arrived, -1 );
} // for
return NULL;
} // Worker
static void *Worker( void *arg ) {
TYPE id = (size_t)arg;
uint64_t entry;
int other = inv( id ); // int is better than TYPE
#ifdef FAST
unsigned int cnt = 0, oid = id;
#endif // FAST
for ( int r = 0; r < RUNS; r += 1 ) {
entry = 0;
while ( stop == 0 ) {
for ( ;; ) {
#ifdef FLICKER
for ( int i = 0; i < 100; i += 1 ) intents[id] = i % 2; // flicker
#endif // FLICKER
intents[id] = WantIn; // declare intent
// Necessary to prevent the read of intents[other] from floating above the assignment
// intents[id] = WantIn, when the hardware determines the two subscripts are different.
Fence(); // force store before more loads
if ( FASTPATH( intents[other] == DontWantIn ) ) break;
if ( last == id ) {
#ifdef FLICKER
for ( int i = 0; i < 100; i += 1 ) intents[id] = i % 2; // flicker
#endif // FLICKER
intents[id] = DontWantIn;
// Optional fence to prevent LD of "last" from being lifted above store of
// intends[id]=DontWantIn. Because a thread only writes its own id into "last",
// and because of eventual consistency (writes eventually become visible),
// the fence is conservative.
//Fence(); // force store before more loads
await( last != id ); // low priority busy wait
} // if
} // for
CriticalSection( id );
#ifdef FLICKER
for ( int i = id; i < 100; i += 1 ) last = i % 2; // flicker
#endif // FLICKER
last = id; // exit protocol
#ifdef FLICKER
for ( int i = 0; i < 100; i += 1 ) intents[id] = i % 2; // flicker
#endif // FLICKER
intents[id] = DontWantIn;
#ifdef FAST
id = startpoint( cnt ); // different starting point each experiment
other = inv( id );
cnt = cycleUp( cnt, NoStartPoints );
#endif // FAST
entry += 1;
} // while
#ifdef FAST
id = oid;
other = inv( id );
#endif // FAST
entries[r][id] = entry;
__sync_fetch_and_add( &Arrived, 1 );
while ( stop != 0 ) Pause();
__sync_fetch_and_add( &Arrived, -1 );
} // for
return NULL;
} // Worker