278 lines
7.1 KiB
C
278 lines
7.1 KiB
C
/*
|
|
* stress1.c
|
|
*
|
|
*
|
|
* --------------------------------------------------------------------------
|
|
*
|
|
* Pthreads-win32 - POSIX Threads Library for Win32
|
|
* Copyright(C) 1998 John E. Bossom
|
|
* Copyright(C) 1999,2005 Pthreads-win32 contributors
|
|
*
|
|
* Contact Email: rpj@callisto.canberra.edu.au
|
|
*
|
|
* The current list of contributors is contained
|
|
* in the file CONTRIBUTORS included with the source
|
|
* code distribution. The list can also be seen at the
|
|
* following World Wide Web location:
|
|
* http://sources.redhat.com/pthreads-win32/contributors.html
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library in the file COPYING.LIB;
|
|
* if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*
|
|
* --------------------------------------------------------------------------
|
|
*
|
|
* Test Synopsis:
|
|
* - Stress test condition variables, mutexes, semaphores.
|
|
*
|
|
* Test Method (Validation or Falsification):
|
|
* - Validation
|
|
*
|
|
* Requirements Tested:
|
|
* - Correct accounting of semaphore and condition variable waiters.
|
|
*
|
|
* Features Tested:
|
|
* -
|
|
*
|
|
* Cases Tested:
|
|
* -
|
|
*
|
|
* Description:
|
|
* Attempting to expose race conditions in cond vars, semaphores etc.
|
|
* - Master attempts to signal slave close to when timeout is due.
|
|
* - Master and slave do battle continuously until main tells them to stop.
|
|
* - Afterwards, the CV must be successfully destroyed (will return an
|
|
* error if there are waiters (including any internal semaphore waiters,
|
|
* which, if there are, cannot be real waiters).
|
|
*
|
|
* Environment:
|
|
* -
|
|
*
|
|
* Input:
|
|
* - None.
|
|
*
|
|
* Output:
|
|
* - File name, Line number, and failed expression on failure.
|
|
* - No output on success.
|
|
*
|
|
* Assumptions:
|
|
* -
|
|
*
|
|
* Pass Criteria:
|
|
* - CV is successfully destroyed.
|
|
*
|
|
* Fail Criteria:
|
|
* - CV destroy fails.
|
|
*/
|
|
|
|
#include "test.h"
|
|
#include <string.h>
|
|
#include <sys/timeb.h>
|
|
|
|
|
|
const unsigned int ITERATIONS = 1000;
|
|
|
|
static pthread_t master, slave;
|
|
typedef struct {
|
|
int value;
|
|
pthread_cond_t cv;
|
|
pthread_mutex_t mx;
|
|
} mysig_t;
|
|
|
|
static int allExit;
|
|
static mysig_t control = {0, PTHREAD_COND_INITIALIZER, PTHREAD_MUTEX_INITIALIZER};
|
|
static pthread_barrier_t startBarrier, readyBarrier, holdBarrier;
|
|
static int timeoutCount = 0;
|
|
static int signalsTakenCount = 0;
|
|
static int signalsSent = 0;
|
|
static int bias = 0;
|
|
static int timeout = 10; // Must be > 0
|
|
|
|
enum {
|
|
CTL_STOP = -1
|
|
};
|
|
|
|
/*
|
|
* Returns abstime 'milliseconds' from 'now'.
|
|
*
|
|
* Works for: -INT_MAX <= millisecs <= INT_MAX
|
|
*/
|
|
struct timespec *
|
|
millisecondsFromNow (struct timespec * time, int millisecs)
|
|
{
|
|
PTW32_STRUCT_TIMEB currSysTime;
|
|
int64_t nanosecs, secs;
|
|
const int64_t NANOSEC_PER_MILLISEC = 1000000;
|
|
const int64_t NANOSEC_PER_SEC = 1000000000;
|
|
|
|
/* get current system time and add millisecs */
|
|
PTW32_FTIME(&currSysTime);
|
|
|
|
secs = (int64_t)(currSysTime.time) + (millisecs / 1000);
|
|
nanosecs = ((int64_t) (millisecs%1000 + currSysTime.millitm)) * NANOSEC_PER_MILLISEC;
|
|
if (nanosecs >= NANOSEC_PER_SEC)
|
|
{
|
|
secs++;
|
|
nanosecs -= NANOSEC_PER_SEC;
|
|
}
|
|
else if (nanosecs < 0)
|
|
{
|
|
secs--;
|
|
nanosecs += NANOSEC_PER_SEC;
|
|
}
|
|
|
|
time->tv_nsec = (long)nanosecs;
|
|
time->tv_sec = (long)secs;
|
|
|
|
return time;
|
|
}
|
|
|
|
void *
|
|
masterThread (void * arg)
|
|
{
|
|
int dither = (int)(size_t)arg;
|
|
|
|
timeout = (int)(size_t)arg;
|
|
|
|
pthread_barrier_wait(&startBarrier);
|
|
|
|
do
|
|
{
|
|
int sleepTime;
|
|
|
|
assert(pthread_mutex_lock(&control.mx) == 0);
|
|
control.value = timeout;
|
|
assert(pthread_mutex_unlock(&control.mx) == 0);
|
|
|
|
/*
|
|
* We are attempting to send the signal close to when the slave
|
|
* is due to timeout. We feel around by adding some [non-random] dither.
|
|
*
|
|
* dither is in the range 2*timeout peak-to-peak
|
|
* sleep time is the average of timeout plus dither.
|
|
* e.g.
|
|
* if timeout = 10 then dither = 20 and
|
|
* sleep millisecs is: 5 <= ms <= 15
|
|
*
|
|
* The bias value attempts to apply some negative feedback to keep
|
|
* the ratio of timeouts to signals taken close to 1:1.
|
|
* bias changes more slowly than dither so as to average more.
|
|
*
|
|
* Finally, if abs(bias) exceeds timeout then timeout is incremented.
|
|
*/
|
|
if (signalsSent % timeout == 0)
|
|
{
|
|
if (timeoutCount > signalsTakenCount)
|
|
{
|
|
bias++;
|
|
}
|
|
else if (timeoutCount < signalsTakenCount)
|
|
{
|
|
bias--;
|
|
}
|
|
if (bias < -timeout || bias > timeout)
|
|
{
|
|
timeout++;
|
|
}
|
|
}
|
|
dither = (dither + 1 ) % (timeout * 2);
|
|
sleepTime = (timeout - bias + dither) / 2;
|
|
Sleep(sleepTime);
|
|
assert(pthread_cond_signal(&control.cv) == 0);
|
|
signalsSent++;
|
|
|
|
pthread_barrier_wait(&holdBarrier);
|
|
pthread_barrier_wait(&readyBarrier);
|
|
}
|
|
while (!allExit);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void *
|
|
slaveThread (void * arg)
|
|
{
|
|
struct timespec time;
|
|
|
|
pthread_barrier_wait(&startBarrier);
|
|
|
|
do
|
|
{
|
|
assert(pthread_mutex_lock(&control.mx) == 0);
|
|
if (pthread_cond_timedwait(&control.cv,
|
|
&control.mx,
|
|
millisecondsFromNow(&time, control.value)) == ETIMEDOUT)
|
|
{
|
|
timeoutCount++;
|
|
}
|
|
else
|
|
{
|
|
signalsTakenCount++;
|
|
}
|
|
assert(pthread_mutex_unlock(&control.mx) == 0);
|
|
|
|
pthread_barrier_wait(&holdBarrier);
|
|
pthread_barrier_wait(&readyBarrier);
|
|
}
|
|
while (!allExit);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int
|
|
main ()
|
|
{
|
|
unsigned int i;
|
|
|
|
assert(pthread_barrier_init(&startBarrier, NULL, 3) == 0);
|
|
assert(pthread_barrier_init(&readyBarrier, NULL, 3) == 0);
|
|
assert(pthread_barrier_init(&holdBarrier, NULL, 3) == 0);
|
|
|
|
assert(pthread_create(&master, NULL, masterThread, (void *)(size_t)timeout) == 0);
|
|
assert(pthread_create(&slave, NULL, slaveThread, NULL) == 0);
|
|
|
|
allExit = FALSE;
|
|
|
|
pthread_barrier_wait(&startBarrier);
|
|
|
|
for (i = 1; !allExit; i++)
|
|
{
|
|
pthread_barrier_wait(&holdBarrier);
|
|
if (i >= ITERATIONS)
|
|
{
|
|
allExit = TRUE;
|
|
}
|
|
pthread_barrier_wait(&readyBarrier);
|
|
}
|
|
|
|
assert(pthread_join(slave, NULL) == 0);
|
|
assert(pthread_join(master, NULL) == 0);
|
|
|
|
printf("Signals sent = %d\nWait timeouts = %d\nSignals taken = %d\nBias = %d\nTimeout = %d\n",
|
|
signalsSent,
|
|
timeoutCount,
|
|
signalsTakenCount,
|
|
(int) bias,
|
|
timeout);
|
|
|
|
/* Cleanup */
|
|
assert(pthread_barrier_destroy(&holdBarrier) == 0);
|
|
assert(pthread_barrier_destroy(&readyBarrier) == 0);
|
|
assert(pthread_barrier_destroy(&startBarrier) == 0);
|
|
assert(pthread_cond_destroy(&control.cv) == 0);
|
|
assert(pthread_mutex_destroy(&control.mx) == 0);
|
|
|
|
/* Success. */
|
|
return 0;
|
|
}
|