From 19299847fdd32094b28377db1aea61b0f605dc8b Mon Sep 17 00:00:00 2001 From: rpj Date: Sun, 1 Jul 2001 13:49:38 +0000 Subject: 2001-07-01 Ross Johnson Contributed by - Alexander Terekhov. * condvar.c: Fixed lost signal bug reported by Timur Aydin (taydin@snet.net). [RPJ (me) didn't translate the original algorithm correctly.] * semaphore.c: Added sem_post_multiple; this is a useful routine, but it doesn't appear to be standard. For now it's not an exported function. tests/ChangeLog: 2001-07-01 Ross Johnson * benchtest3.c: New; timing mutexes. * benchtest4.c: New; time mutexes. * condvar3_1.c: Fixed bug - Alexander Terekhov * condvar3_3.c: New test. 2001-06-25 Ross Johnson * priority1.c: New test. * priority2.c: New test. * inherit1.c: New test. * benchtest1.c: New; timing mutexes. * benchtest2.c: New; timing mutexes. * mutex4.c: Modified to test all mutex types. --- tests/benchtest2.c | 198 +++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 147 insertions(+), 51 deletions(-) (limited to 'tests/benchtest2.c') diff --git a/tests/benchtest2.c b/tests/benchtest2.c index f2932b9..a049961 100644 --- a/tests/benchtest2.c +++ b/tests/benchtest2.c @@ -17,9 +17,14 @@ #include #endif +#include "benchtest.h" + +#define PTW32_MUTEX_TYPES #define ITERATIONS 100000L pthread_mutex_t gate1, gate2; +old_mutex_t ox1, ox2; +CRITICAL_SECTION cs1, cs2; pthread_mutexattr_t ma; long durationMilliSecs; long overHeadMilliSecs = 0; @@ -55,6 +60,22 @@ overheadThread(void * arg) } +void * +oldThread(void * arg) +{ + do + { + (void) old_mutex_lock(&ox1); + (void) old_mutex_lock(&ox2); + (void) old_mutex_unlock(&ox1); + sched_yield(); + (void) old_mutex_unlock(&ox2); + } + while (running); + + return NULL; +} + void * workerThread(void * arg) { @@ -71,22 +92,34 @@ workerThread(void * arg) return NULL; } +void * +CSThread(void * arg) +{ + do + { + EnterCriticalSection(&cs1); + EnterCriticalSection(&cs2); + LeaveCriticalSection(&cs1); + sched_yield(); + LeaveCriticalSection(&cs2); + } + while (running); + + return NULL; +} + void runTest (char * testNameString, int mType) { -#ifdef PTHREAD_MUTEX_DEFAULT - pthread_mutexattr_settype(&ma, mType); +#ifdef PTW32_MUTEX_TYPES + assert(pthread_mutexattr_settype(&ma, mType) == 0); #endif - pthread_mutex_init(&gate1, &ma); - pthread_mutex_init(&gate2, &ma); - - (void) pthread_mutex_lock(&gate1); - (void) pthread_mutex_lock(&gate2); - + assert(pthread_mutex_init(&gate1, &ma) == 0); + assert(pthread_mutex_init(&gate2, &ma) == 0); + assert(pthread_mutex_lock(&gate1) == 0); + assert(pthread_mutex_lock(&gate2) == 0); running = 1; - - (void) pthread_create(&worker, NULL, workerThread, NULL); - + assert(pthread_create(&worker, NULL, workerThread, NULL) == 0); TESTSTART (void) pthread_mutex_unlock(&gate1); sched_yield(); @@ -94,23 +127,15 @@ runTest (char * testNameString, int mType) (void) pthread_mutex_lock(&gate1); (void) pthread_mutex_lock(&gate2); TESTSTOP - running = 0; - - (void) pthread_mutex_unlock(&gate2); - (void) pthread_mutex_unlock(&gate1); - - (void) pthread_join(worker, NULL); - - pthread_mutex_destroy(&gate2); - pthread_mutex_destroy(&gate1); - - durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - - overHeadMilliSecs; - - printf( "%-25s %15ld %15ld %15.3f\n", - testNameString, - ITERATIONS, + assert(pthread_mutex_unlock(&gate2) == 0); + assert(pthread_mutex_unlock(&gate1) == 0); + assert(pthread_join(worker, NULL) == 0); + assert(pthread_mutex_destroy(&gate2) == 0); + assert(pthread_mutex_destroy(&gate1) == 0); + durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; + printf( "%-40s %15ld %15.3f\n", + testNameString, durationMilliSecs, (float) durationMilliSecs * 1E3 / ITERATIONS / 4 /* Four locks/unlocks per iteration */); } @@ -119,60 +144,131 @@ runTest (char * testNameString, int mType) int main (int argc, char *argv[]) { - pthread_mutexattr_init(&ma); + assert(pthread_mutexattr_init(&ma) == 0); - printf( "Two threads, blocking mutex locks/unlocks.\n\n"); + printf( "========================================================================\n"); + printf( "\nBlocking mutex lock plus unlock.\n"); + printf("%ld iterations, four locks/unlocks per iteration.\n\n", ITERATIONS); - printf( "%-25s %15s %15s %15s\n", - "Test", - "Iterations", - "Total(msec)", - "lock/unlock(usec)"); + printf( "%-40s %15s %15s\n", + "Test", + "Total(msec)", + "average(usec)"); + printf( "------------------------------------------------------------------------\n"); /* * Time the loop overhead so we can subtract it from the actual test times. */ running = 1; + assert(pthread_create(&worker, NULL, overheadThread, NULL) == 0); + TESTSTART + sched_yield(); + sched_yield(); + TESTSTOP + running = 0; + assert(pthread_join(worker, NULL) == 0); + durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; + overHeadMilliSecs = durationMilliSecs; - (void) pthread_create(&worker, NULL, overheadThread, NULL); + InitializeCriticalSection(&cs1); + InitializeCriticalSection(&cs2); + EnterCriticalSection(&cs1); + EnterCriticalSection(&cs2); + running = 1; + assert(pthread_create(&worker, NULL, CSThread, NULL) == 0); TESTSTART + LeaveCriticalSection(&cs1); sched_yield(); + LeaveCriticalSection(&cs2); + EnterCriticalSection(&cs1); + EnterCriticalSection(&cs2); TESTSTOP - running = 0; + LeaveCriticalSection(&cs2); + LeaveCriticalSection(&cs1); + assert(pthread_join(worker, NULL) == 0); + DeleteCriticalSection(&cs2); + DeleteCriticalSection(&cs1); + durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; + printf( "%-40s %15ld %15.3f\n", + "Simple Critical Section", + durationMilliSecs, + (float) durationMilliSecs * 1E3 / ITERATIONS / 4 ); - (void) pthread_join(worker, NULL); - pthread_mutex_destroy(&gate2); - pthread_mutex_destroy(&gate1); + old_mutex_use = OLD_WIN32CS; + assert(old_mutex_init(&ox1, NULL) == 0); + assert(old_mutex_init(&ox2, NULL) == 0); + assert(old_mutex_lock(&ox1) == 0); + assert(old_mutex_lock(&ox2) == 0); + running = 1; + assert(pthread_create(&worker, NULL, oldThread, NULL) == 0); + TESTSTART + (void) old_mutex_unlock(&ox1); + sched_yield(); + (void) old_mutex_unlock(&ox2); + (void) old_mutex_lock(&ox1); + (void) old_mutex_lock(&ox2); + TESTSTOP + running = 0; + assert(old_mutex_unlock(&ox1) == 0); + assert(old_mutex_unlock(&ox2) == 0); + assert(pthread_join(worker, NULL) == 0); + assert(old_mutex_destroy(&ox2) == 0); + assert(old_mutex_destroy(&ox1) == 0); + durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; + printf( "%-40s %15ld %15.3f\n", + "PT Mutex using a Critical Section (WNT)", + durationMilliSecs, + (float) durationMilliSecs * 1E3 / ITERATIONS / 4); - durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - - overHeadMilliSecs; - printf( "%-25s %15ld %15ld\n", - "Overhead", - ITERATIONS, - durationMilliSecs); + old_mutex_use = OLD_WIN32MUTEX; + assert(old_mutex_init(&ox1, NULL) == 0); + assert(old_mutex_init(&ox2, NULL) == 0); + assert(old_mutex_lock(&ox1) == 0); + assert(old_mutex_lock(&ox2) == 0); + running = 1; + assert(pthread_create(&worker, NULL, oldThread, NULL) == 0); + TESTSTART + (void) old_mutex_unlock(&ox1); + sched_yield(); + (void) old_mutex_unlock(&ox2); + (void) old_mutex_lock(&ox1); + (void) old_mutex_lock(&ox2); + TESTSTOP + running = 0; + assert(old_mutex_unlock(&ox1) == 0); + assert(old_mutex_unlock(&ox2) == 0); + assert(pthread_join(worker, NULL) == 0); + assert(old_mutex_destroy(&ox2) == 0); + assert(old_mutex_destroy(&ox1) == 0); + durationMilliSecs = GetDurationMilliSecs(currSysTimeStart, currSysTimeStop) - overHeadMilliSecs; + printf( "%-40s %15ld %15.3f\n", + "PT Mutex using a Win32 Mutex (W9x)", + durationMilliSecs, + (float) durationMilliSecs * 1E3 / ITERATIONS / 4); - overHeadMilliSecs = durationMilliSecs; + printf( "........................................................................\n"); /* * Now we can start the actual tests */ -#ifdef PTHREAD_MUTEX_DEFAULT - runTest("PTHREAD_MUTEX_DEFAULT", PTHREAD_MUTEX_DEFAULT); +#ifdef PTW32_MUTEX_TYPES + runTest("PTHREAD_MUTEX_DEFAULT (W9x,WNT)", PTHREAD_MUTEX_DEFAULT); - runTest("PTHREAD_MUTEX_NORMAL", PTHREAD_MUTEX_NORMAL); + runTest("PTHREAD_MUTEX_NORMAL (W9x,WNT)", PTHREAD_MUTEX_NORMAL); - runTest("PTHREAD_MUTEX_ERRORCHECK", PTHREAD_MUTEX_ERRORCHECK); + runTest("PTHREAD_MUTEX_ERRORCHECK (W9x,WNT)", PTHREAD_MUTEX_ERRORCHECK); - runTest("PTHREAD_MUTEX_RECURSIVE", PTHREAD_MUTEX_RECURSIVE); + runTest("PTHREAD_MUTEX_RECURSIVE (W9x,WNT)", PTHREAD_MUTEX_RECURSIVE); #else runTest("Blocking locks", 0); #endif + printf( "========================================================================\n"); /* * End of tests. */ -- cgit v1.2.3