From 3c0fbfafe563b7b312d60c42c0d58a3a1f4d5930 Mon Sep 17 00:00:00 2001 From: rpj Date: Wed, 7 Feb 2001 13:08:54 +0000 Subject: Change the purpose of rwlock6 test and add new rwlock7 test. --- tests/ChangeLog | 7 +++ tests/GNUmakefile | 3 +- tests/Makefile | 3 +- tests/rwlock6.c | 110 +++++++++++++++++----------------- tests/rwlock7.c | 173 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 239 insertions(+), 57 deletions(-) create mode 100644 tests/rwlock7.c diff --git a/tests/ChangeLog b/tests/ChangeLog index 92fca1b..66ccff1 100644 --- a/tests/ChangeLog +++ b/tests/ChangeLog @@ -1,3 +1,10 @@ +2001-02-08 Ross Johnson + + * Makefile (rwlock7): Add new test. + * GNUmakefile (rwlock7): Add new test. + * rwlock7.c: New test. + * rwlock6.c: Changed to test that writer has priority. + 2000-12-29 Ross Johnson * GNUmakefile: Add mutex4 test; ensure libpthreadw32.a is diff --git a/tests/GNUmakefile b/tests/GNUmakefile index 33de3ac..007cd7f 100644 --- a/tests/GNUmakefile +++ b/tests/GNUmakefile @@ -36,7 +36,7 @@ TESTS = loadfree \ count1 once1 tsd1 self1 self2 cancel1 cancel2 eyal1 \ condvar3 condvar4 condvar5 condvar6 condvar7 condvar8 condvar9 \ errno1 \ - rwlock1 rwlock2 rwlock3 rwlock4 rwlock5 rwlock6 \ + rwlock1 rwlock2 rwlock3 rwlock4 rwlock5 rwlock6 rwlock7 \ context1 cancel3 cancel4 cancel5 \ cleanup0 cleanup1 cleanup2 cleanup3 \ exception1 exception2 exception3 @@ -83,6 +83,7 @@ rwlock3.pass: rwlock2.pass rwlock4.pass: rwlock3.pass rwlock5.pass: rwlock4.pass rwlock6.pass: rwlock5.pass +rwlock7.pass: rwlock6.pass context1.pass: cancel2.pass cancel3.pass: context1.pass cancel4.pass: cancel3.pass diff --git a/tests/Makefile b/tests/Makefile index 281cd50..f8b846f 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -45,7 +45,7 @@ PASSES= loadfree.pass \ condvar3.pass condvar4.pass condvar5.pass condvar6.pass \ condvar7.pass condvar8.pass condvar9.pass \ errno1.pass \ - rwlock1.pass rwlock2.pass rwlock3.pass rwlock4.pass rwlock5.pass rwlock6.pass \ + rwlock1.pass rwlock2.pass rwlock3.pass rwlock4.pass rwlock5.pass rwlock6.pass rwlock7.pass \ context1.pass \ cancel3.pass cancel4.pass cancel5.pass \ cleanup0.pass cleanup1.pass cleanup2.pass cleanup3.pass \ @@ -138,6 +138,7 @@ rwlock3.pass: rwlock2.pass rwlock4.pass: rwlock3.pass rwlock5.pass: rwlock4.pass rwlock6.pass: rwlock5.pass +rwlock7.pass: rwlock6.pass context1.pass: cancel2.pass cancel3.pass: context1.pass cancel4.pass: cancel3.pass diff --git a/tests/rwlock6.c b/tests/rwlock6.c index 8a75b83..97742b1 100644 --- a/tests/rwlock6.c +++ b/tests/rwlock6.c @@ -1,65 +1,65 @@ -/* - * rwlock6.c - * - * Check that writer locks have priority. - * - * Depends on API functions: - * pthread_rwlock_rdlock() - * pthread_rwlock_wrlock() - * pthread_rwlock_unlock() - */ +/* + * rwlock6.c + * + * Check that writer locks have priority. + * + * Depends on API functions: + * pthread_rwlock_rdlock() + * pthread_rwlock_wrlock() + * pthread_rwlock_unlock() + */ -#include "test.h" - -static pthread_rwlock_t rwlock1 = PTHREAD_RWLOCK_INITIALIZER; +#include "test.h" -static int bankAccount; +static pthread_rwlock_t rwlock1 = PTHREAD_RWLOCK_INITIALIZER; -void * wrfunc(void * arg) -{ - assert(pthread_rwlock_wrlock(&rwlock1) == 0); - Sleep(1000); - bankAccount += 10; - assert(pthread_rwlock_unlock(&rwlock1) == 0); +static int bankAccount; - return((void *) bankAccount); -} - -void * rdfunc(void * arg) -{ - int ba = 0; +void * wrfunc(void * arg) +{ + assert(pthread_rwlock_wrlock(&rwlock1) == 0); + Sleep(1000); + bankAccount += 10; + assert(pthread_rwlock_unlock(&rwlock1) == 0); - assert(pthread_rwlock_rdlock(&rwlock1) == 0); - ba = bankAccount; - assert(pthread_rwlock_unlock(&rwlock1) == 0); + return ((void *) bankAccount); +} - ba += 10; - return((void *) ba); -} - -int -main() -{ - pthread_t wrt1; - pthread_t wrt2; - pthread_t rdt; - int wr1Result = 0; - int wr2Result = 0; - int rdResult = 0; +void * rdfunc(void * arg) +{ + int ba = 0; - assert(pthread_create(&wrt1, NULL, wrfunc, NULL) == 0); - Sleep(200); - assert(pthread_create(&rdt, NULL, rdfunc, NULL) == 0); - Sleep(200); - assert(pthread_create(&wrt2, NULL, wrfunc, NULL) == 0); + assert(pthread_rwlock_rdlock(&rwlock1) == 0); + ba = bankAccount; + assert(pthread_rwlock_unlock(&rwlock1) == 0); - assert(pthread_join(wrt1, (void **) &wr1Result) == 0); - assert(pthread_join(wrt2, (void **) &wr2Result) == 0); - assert(pthread_join(rdt, (void **) &rdResult) == 0); + ba += 10; + return ((void *) ba); +} - assert(wr1Result == 10); - assert(wr2Result == 20); - assert(rdResult == 20); +int +main() +{ + pthread_t wrt1; + pthread_t wrt2; + pthread_t rdt; + int wr1Result = 0; + int wr2Result = 0; + int rdResult = 0; - return 0; -} + assert(pthread_create(&wrt1, NULL, wrfunc, NULL) == 0); + Sleep(200); + assert(pthread_create(&rdt, NULL, rdfunc, NULL) == 0); + Sleep(200); + assert(pthread_create(&wrt2, NULL, wrfunc, NULL) == 0); + + assert(pthread_join(wrt1, (void **) &wr1Result) == 0); + assert(pthread_join(wrt2, (void **) &wr2Result) == 0); + assert(pthread_join(rdt, (void **) &rdResult) == 0); + + assert(wr1Result == 10); + assert(wr2Result == 20); + assert(rdResult == 20); + + return 0; +} diff --git a/tests/rwlock7.c b/tests/rwlock7.c new file mode 100644 index 0000000..88abcfe --- /dev/null +++ b/tests/rwlock7.c @@ -0,0 +1,173 @@ +/* + * rwlock7.c + * + * Hammer on a bunch of rwlocks to test robustness and fairness. + * Printed stats should be roughly even for each thread. + */ + +#include "test.h" +#include + +#define THREADS 5 +#define DATASIZE 15 +#define ITERATIONS 10000 + +/* + * Keep statistics for each thread. + */ +typedef struct thread_tag { + int thread_num; + pthread_t thread_id; + int updates; + int reads; + int interval; +} thread_t; + +/* + * Read-write lock and shared data + */ +typedef struct data_tag { + rwlock_t lock; + int data; + int updates; +} data_t; + +static thread_t threads[THREADS]; +static data_t data[DATASIZE]; + +/* + * Thread start routine that uses read-write locks + */ +void *thread_routine (void *arg) +{ + thread_t *self = (thread_t*)arg; + int repeats = 0; + int iteration; + int element = 0; + + for (iteration = 0; iteration < ITERATIONS; iteration++) + { + /* + * Each "self->interval" iterations, perform an + * update operation (write lock instead of read + * lock). + */ + if ((iteration % self->interval) == 0) + { + assert(pthread_rwlock_wrlock (&data[element].lock) == 0); + data[element].data = self->thread_num; + data[element].updates++; + self->updates++; + assert(pthread_rwlock_unlock (&data[element].lock) == 0); + } else { + /* + * Look at the current data element to see whether + * the current thread last updated it. Count the + * times, to report later. + */ + assert(pthread_rwlock_rdlock (&data[element].lock) == 0); + + self->reads++; + + if (data[element].data == self->thread_num) + { + repeats++; + } + + assert(pthread_rwlock_unlock (&data[element].lock) == 0); + } + + element++; + + if (element >= DATASIZE) + { + element = 0; + } + } + + if (repeats > 0) + { + printf ("Thread %d found unchanged elements %d times\n", + self->thread_num, repeats); + } + + return NULL; +} + +int +main (int argc, char *argv[]) +{ + int count; + int data_count; + int status; + unsigned int seed = 1; + int thread_updates = 0; + int data_updates = 0; + + struct _timeb currSysTime1; + struct _timeb currSysTime2; + + /* + * Initialize the shared data. + */ + for (data_count = 0; data_count < DATASIZE; data_count++) + { + data[data_count].data = 0; + data[data_count].updates = 0; + + assert(pthread_rwlock_init (&data[data_count].lock) == 0); + } + + _ftime(&currSysTime1); + + /* + * Create THREADS threads to access shared data. + */ + for (count = 0; count < THREADS; count++) + { + threads[count].thread_num = count; + threads[count].updates = 0; + threads[count].reads = 0; + threads[count].interval = rand_r (&seed) % 71; + + assert(pthread_create (&threads[count].thread_id, + NULL, thread_routine, (void*)&threads[count]) == 0); + } + + /* + * Wait for all threads to complete, and collect + * statistics. + */ + for (count = 0; count < THREADS; count++) + { + assert(pthread_join (threads[count].thread_id, NULL) == 0); + thread_updates += threads[count].updates; + printf ("%02d: interval %d, updates %d, reads %d\n", + count, threads[count].interval, + threads[count].updates, threads[count].reads); + } + + /* + * Collect statistics for the data. + */ + for (data_count = 0; data_count < DATASIZE; data_count++) + { + data_updates += data[data_count].updates; + printf ("data %02d: value %d, %d updates\n", + data_count, data[data_count].data, data[data_count].updates); + assert(pthread_rwlock_destroy (&data[data_count].lock) == 0); + } + + printf ("%d thread updates, %d data updates\n", + thread_updates, data_updates); + + _ftime(&currSysTime2); + + printf( "\nstart: %d/%d, stop: %d/%d, duration:%d\n", + currSysTime1.time,currSysTime1.millitm, + currSysTime2.time,currSysTime2.millitm, + (currSysTime2.time*1000+currSysTime2.millitm) - + (currSysTime1.time*1000+currSysTime1.millitm)); + + return 0; +} -- cgit v1.2.3