/*
LockCorrectness:
Tests correct implementation of the lock
Parameters:
parameters:
A structure of type ThreadParameters_t with parameters
Return Value:
*/
void * LockCorrectness( void *parameters )
{
// ----------------------- Local Variables ------------------
int i;
int localN; // On the stack for performance.
int tmp;
int j;
int expectedresult;
int delaysteps;
ThreadParameters_t *par;
// ---------------------- Initialization -------------------------
par = ( ThreadParameters_t * ) parameters;
localN = gN*30;
gTestVariable = 0;
gCounter = 0;
my_barrier_wait( &gBarrier );
// ---------------------- Run Tests -------------------------
for ( i = 0; i < localN; i++ )
{
my_mutex_lock( &gMutex );
tmp = gTestVariable;
delaysteps = rand() % DELAYNUM;
for ( j = 0; j < delaysteps; j++ )
{
tmp += gZero;
}
tmp++;
gTestVariable = tmp;
my_mutex_unlock( &gMutex );
}
// ---------------------- Barrier wait -------------------------
my_barrier_wait( &gBarrier );
// ----------------------- Check for sucess ---------------------
expectedresult = localN * gP;
if ( gTestVariable != expectedresult )
{
return( NULL );
}
return( ( void * ) 1 );
}
/*
LockPerformance:
Tests the performance of a single lock, with no writings or readings.
Parameters:
parameters:
A structure of type ThreadParameters_t with parameters
Return Value:
This test always succeeds. It always returns 1.
*/
void * LockPerformance( void *parameters )
{
// ----------------------- Local Variables ------------------
int i;
int localN; // On the stack for performance.
int j;
ThreadParameters_t *par;
// ---------------------- Initialization -------------------------
par = ( ThreadParameters_t * ) parameters;
localN = gN*15;
my_barrier_wait( &gBarrier );
// ---------------------- Run Tests -------------------------
for ( j = 0; j < 10; j++ )
{
my_barrier_wait( &gBarrier );
for ( i = 0; i < localN; i++ )
{
my_mutex_lock( &gMutex );
my_mutex_unlock( &gMutex );
}
}
// ---------------------- Barrier wait -------------------------
my_barrier_wait( &gBarrier );
// ----------------------- Always return success ---------------------
return( ( void * ) 1 );
}
/*
BarrierPerformance:
Tests the performance of a single barrier, with no writings or readings.
Parameters:
parameters:
A structure of type ThreadParameters_t with parameters
Return Value:
This test always succeeds. It always returns 1.
*/
void * BarrierPerformance( void *parameters )
{
// ----------------------- Local Variables ------------------
int localN; // On the stack for performance.
int i;
ThreadParameters_t *par;
// ---------------------- Initialization -------------------------
par = ( ThreadParameters_t * ) parameters;
localN = gN*10;
my_barrier_wait( &gBarrier );
// ---------------------- Run Tests -------------------------
for ( i = 0; i < localN; i++ )
{
my_barrier_wait( &gBarrier );
}
// ---------------------- Barrier wait -------------------------
my_barrier_wait( &gBarrier );
// ----------------------- Always return success ---------------------
return( ( void * ) 1 );
}
static void * doTest(void *arg) {
int warmups = MIN(100, iters/100);
int64_t start,total;
int result;
int i = 0;
if (arg) {
/* I am a polling thread */
GASNET_BLOCKUNTIL(done);
return NULL;
}
/* Warmup Named */
for (i=0; i < warmups; i++) {
my_barrier_notify(i, 0);
GASNET_Safe(my_barrier_wait(i, 0));
assert_always(!gasnet_barrier_result(&result));
}
BARRIER();
start = TIME();
for (i=0; i < iters; i++) {
my_barrier_notify(i, 0);
GASNET_Safe(my_barrier_wait(i, 0));
}
total = TIME() - start;
BARRIER();
if (mynode == 0) {
printf("Total time: %8.3f sec Avg Named Barrier latency: %8.3f us\n",
((float)total)/1000000, ((float)total)/iters);
fflush(stdout);
}
BARRIER();
/* Warmup Anonymous */
for (i=0; i < warmups; i++) {
my_barrier_notify(0, GASNET_BARRIERFLAG_ANONYMOUS);
GASNET_Safe(my_barrier_wait(0, GASNET_BARRIERFLAG_ANONYMOUS));
assert_always(gasnet_barrier_result(&result));
}
BARRIER();
start = TIME();
for (i=0; i < iters; i++) {
my_barrier_notify(0, GASNET_BARRIERFLAG_ANONYMOUS);
GASNET_Safe(my_barrier_wait(0, GASNET_BARRIERFLAG_ANONYMOUS));
}
total = TIME() - start;
BARRIER();
if (mynode == 0) {
printf("Total time: %8.3f sec Avg Anon. Barrier latency: %8.3f us\n",
((float)total)/1000000, ((float)total)/iters);
fflush(stdout);
}
BARRIER();
if (!PERFORM_MIXED_NAMED_ANON_TESTS) {
if (mynode == 0) {
MSG("WARNING: skipping tests which mix named and anonymous barriers, "
"which are known to fail in this configuration");
}
} else {
int parity = (mynode & 1);
/* Warmup Mixed */
for (i=0; i < warmups; i++, parity ^= 1) {
int value = parity ? iters : 0;
int flags = parity ? 0 : GASNET_BARRIERFLAG_ANONYMOUS;
my_barrier_notify(value, flags);
GASNET_Safe(my_barrier_wait(value, flags));
assert_always(!gasnet_barrier_result(&result) || (nodes == 1));
}
BARRIER();
start = TIME();
for (i=0; i < iters; i++, parity ^= 1) {
int value = parity ? iters : 0;
int flags = parity ? 0 : GASNET_BARRIERFLAG_ANONYMOUS;
my_barrier_notify(value, flags);
GASNET_Safe(my_barrier_wait(value, flags));
}
total = TIME() - start;
BARRIER();
if (mynode == 0) {
printf("Total time: %8.3f sec Avg Mixed Barrier latency: %8.3f us\n",
((float)total)/1000000, ((float)total)/iters);
fflush(stdout);
}
}
BARRIER();
#if TEST_UNNAMED_BARRIER
/* Warmup Unnamed */
for (i=0; i < warmups; i++) {
my_barrier_notify(0, GASNET_BARRIERFLAG_UNNAMED);
GASNET_Safe(my_barrier_wait(0, GASNET_BARRIERFLAG_UNNAMED));
assert_always(gasnet_barrier_result(&result));
}
BARRIER();
start = TIME();
for (i=0; i < iters; i++) {
my_barrier_notify(0, GASNET_BARRIERFLAG_UNNAMED);
GASNET_Safe(my_barrier_wait(0, GASNET_BARRIERFLAG_UNNAMED));
}
total = TIME() - start;
BARRIER();
if (mynode == 0) {
printf("Total time: %8.3f sec Avg Uname Barrier latency: %8.3f us\n",
((float)total)/1000000, ((float)total)/iters);
fflush(stdout);
}
BARRIER();
#endif
GASNET_Safe(gasnet_AMRequestShort0(mynode, hidx_done_shorthandler));
return NULL;
}
/*
BarrierCorrectness:
Tests correct implementation of barrier
Parameters:
parameters:
A structure of type ThreadParameters_t with parameters
Return Value:
*/
void * BarrierCorrectness( void *parameters )
{
// ----------------------- Local Variables ------------------
int i;
int localN; // On the stack for performance.
int tmp;
int j;
int delaysteps;
int goodbarrier;
ThreadParameters_t *par;
// ---------------------- Initialization -------------------------
par = ( ThreadParameters_t * ) parameters;
localN = gN*6;
gTestVariable = 0;
gCounter = 0;
goodbarrier = 1;
my_barrier_wait( &gBarrier );
// ---------------------- Run Tests -------------------------
for ( i = 0; i < localN; i++ )
{
// Read a shared variable
tmp = 0;
delaysteps = rand() % DELAYNUM;
for ( j = 0; j < delaysteps; j++ )
{
tmp += gZero;
}
tmp++;
// Synchronize: Everybody reads the same variable
my_barrier_wait( &gBarrier );
// Atomically increment the variable after a random delay...
delaysteps = rand() % DELAYNUM;
for ( j = 0; j < delaysteps; j++ )
{
tmp += gZero;
}
// Atomically add the value to the test variable
__sync_fetch_and_add( &gTestVariable, tmp );
// Check for successful add from all threads.
my_barrier_wait( &gBarrier );
if ( gTestVariable != ( ( i + 1 ) * gP ) )
{
goodbarrier = 0;
}
}
// ---------------------- Barrier wait -------------------------
my_barrier_wait( &gBarrier );
// ----------------------- Check for sucess ---------------------
if ( goodbarrier != 1 )
{
return( NULL );
}
return( ( void * ) 1 );
}
