/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ /* ** File: lock.c ** Purpose: test basic locking functions ** ** Modification History: ** 14-May-97 AGarcia- Converted the test to accomodate the debug_mode flag. ** The debug mode will print all of the printfs associated with this test. ** The regress mode will be the default mode. Since the regress tool limits ** the output to a one line status:PASS or FAIL,all of the printf statements ** have been handled with an if (debug_mode) statement. ** 04-June-97 AGarcia removed the Test_Result function. Regress tool has been updated to ** recognize the return code from tha main program. ** ** 11-Aug-97 LarryH. Win16 port of NSPR. ** - Added "PASS", "FAIL" messages on completion. ** - Change stack variables to static scope variables ** because of shadow-stack use by Win16 ** - Added PR_CALLBACK attribute to functions called by NSPR ** - Added command line arguments: ** - l <num> to control the number of loops ** - c <num> to control the number of CPUs. ** (was positional argv). ** ** ***********************************************************************/ /*********************************************************************** ** Includes ***********************************************************************/ /* Used to get the command line option */ #include "plgetopt.h" #include "prio.h" #include "prcmon.h" #include "prinit.h" #include "prinrval.h" #include "prprf.h" #include "prlock.h" #include "prlog.h" #include "prmon.h" #include "prmem.h" #include "prthread.h" #include "prtypes.h" #include "plstr.h" #include <stdlib.h> #if defined(XP_UNIX) #include <string.h> #endif static PRIntn failed_already=0; static PRFileDesc *std_err = NULL; static PRBool verbosity = PR_FALSE; static PRBool debug_mode = PR_FALSE; const static PRIntervalTime contention_interval = 50; typedef struct LockContentious_s { PRLock *ml; PRInt32 loops; PRUint32 contender; PRUint32 contentious; PRIntervalTime overhead; PRIntervalTime interval; } LockContentious_t; typedef struct MonitorContentious_s { PRMonitor *ml; PRInt32 loops; PRUint32 contender; PRUint32 contentious; PRIntervalTime overhead; PRIntervalTime interval; } MonitorContentious_t; static PRIntervalTime Sleeper(PRUint32 loops) { PRIntervalTime predicted = 0; while (loops-- > 0) { predicted += contention_interval; (void)PR_Sleep(contention_interval); } return predicted; } /* Sleeper */ /* ** BASIC LOCKS */ static PRIntervalTime MakeLock(PRUint32 loops) { PRLock *ml = NULL; while (loops-- > 0) { ml = PR_NewLock(); PR_DestroyLock(ml); ml = NULL; } return 0; } /* MakeLock */ static PRIntervalTime NonContentiousLock(PRUint32 loops) { PRLock *ml = NULL; ml = PR_NewLock(); while (loops-- > 0) { PR_Lock(ml); PR_ASSERT_CURRENT_THREAD_OWNS_LOCK(ml); PR_Unlock(ml); } PR_DestroyLock(ml); return 0; } /* NonContentiousLock */ static void PR_CALLBACK LockContender(void *arg) { LockContentious_t *contention = (LockContentious_t*)arg; while (contention->loops-- > 0) { PR_Lock(contention->ml); PR_ASSERT_CURRENT_THREAD_OWNS_LOCK(contention->ml); contention->contender+= 1; contention->overhead += contention->interval; PR_Sleep(contention->interval); PR_ASSERT_CURRENT_THREAD_OWNS_LOCK(contention->ml); PR_Unlock(contention->ml); } } /* LockContender */ static PRIntervalTime ContentiousLock(PRUint32 loops) { PRStatus status; PRThread *thread = NULL; LockContentious_t * contention; PRIntervalTime rv, overhead, timein = PR_IntervalNow(); contention = PR_NEWZAP(LockContentious_t); contention->loops = loops; contention->overhead = 0; contention->ml = PR_NewLock(); contention->interval = contention_interval; thread = PR_CreateThread( PR_USER_THREAD, LockContender, contention, PR_PRIORITY_LOW, PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0); PR_ASSERT(thread != NULL); overhead = PR_IntervalNow() - timein; while (contention->loops-- > 0) { PR_Lock(contention->ml); PR_ASSERT_CURRENT_THREAD_OWNS_LOCK(contention->ml); contention->contentious+= 1; contention->overhead += contention->interval; PR_Sleep(contention->interval); PR_ASSERT_CURRENT_THREAD_OWNS_LOCK(contention->ml); PR_Unlock(contention->ml); } timein = PR_IntervalNow(); status = PR_JoinThread(thread); PR_DestroyLock(contention->ml); overhead += (PR_IntervalNow() - timein); rv = overhead + contention->overhead; if (verbosity) PR_fprintf( std_err, "Access ratio: %u to %u\n", contention->contentious, contention->contender); PR_Free(contention); return rv; } /* ContentiousLock */ /* ** MONITORS */ static PRIntervalTime MakeMonitor(PRUint32 loops) { PRMonitor *ml = NULL; while (loops-- > 0) { ml = PR_NewMonitor(); PR_DestroyMonitor(ml); ml = NULL; } return 0; } /* MakeMonitor */ static PRIntervalTime NonContentiousMonitor(PRUint32 loops) { PRMonitor *ml = NULL; ml = PR_NewMonitor(); while (loops-- > 0) { PR_EnterMonitor(ml); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(ml); PR_ExitMonitor(ml); } PR_DestroyMonitor(ml); return 0; } /* NonContentiousMonitor */ static void PR_CALLBACK TryEntry(void *arg) { PRMonitor *ml = (PRMonitor*)arg; if (debug_mode) PR_fprintf(std_err, "Reentrant thread created\n"); PR_EnterMonitor(ml); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(ml); if (debug_mode) PR_fprintf(std_err, "Reentrant thread acquired monitor\n"); PR_ExitMonitor(ml); if (debug_mode) PR_fprintf(std_err, "Reentrant thread released monitor\n"); } /* TryEntry */ static PRIntervalTime ReentrantMonitor(PRUint32 loops) { PRStatus status; PRThread *thread; PRMonitor *ml = PR_NewMonitor(); if (debug_mode) PR_fprintf(std_err, "\nMonitor created for reentrant test\n"); PR_EnterMonitor(ml); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(ml); PR_EnterMonitor(ml); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(ml); if (debug_mode) PR_fprintf(std_err, "Monitor acquired twice\n"); thread = PR_CreateThread( PR_USER_THREAD, TryEntry, ml, PR_PRIORITY_LOW, PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0); PR_ASSERT(thread != NULL); PR_Sleep(PR_SecondsToInterval(1)); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(ml); PR_ExitMonitor(ml); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(ml); if (debug_mode) PR_fprintf(std_err, "Monitor released first time\n"); PR_ExitMonitor(ml); if (debug_mode) PR_fprintf(std_err, "Monitor released second time\n"); status = PR_JoinThread(thread); if (debug_mode) PR_fprintf(std_err, "Reentrant thread joined %s\n", (status == PR_SUCCESS) ? "successfully" : "in error"); PR_DestroyMonitor(ml); return 0; } /* ReentrantMonitor */ static void PR_CALLBACK MonitorContender(void *arg) { MonitorContentious_t *contention = (MonitorContentious_t*)arg; while (contention->loops-- > 0) { PR_EnterMonitor(contention->ml); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(contention->ml); contention->contender+= 1; contention->overhead += contention->interval; PR_Sleep(contention->interval); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(contention->ml); PR_ExitMonitor(contention->ml); } } /* MonitorContender */ static PRUint32 ContentiousMonitor(PRUint32 loops) { PRStatus status; PRThread *thread = NULL; MonitorContentious_t * contention; PRIntervalTime rv, overhead, timein = PR_IntervalNow(); contention = PR_NEWZAP(MonitorContentious_t); contention->loops = loops; contention->overhead = 0; contention->ml = PR_NewMonitor(); contention->interval = contention_interval; thread = PR_CreateThread( PR_USER_THREAD, MonitorContender, contention, PR_PRIORITY_LOW, PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0); PR_ASSERT(thread != NULL); overhead = PR_IntervalNow() - timein; while (contention->loops-- > 0) { PR_EnterMonitor(contention->ml); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(contention->ml); contention->contentious+= 1; contention->overhead += contention->interval; PR_Sleep(contention->interval); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(contention->ml); PR_ExitMonitor(contention->ml); } timein = PR_IntervalNow(); status = PR_JoinThread(thread); PR_DestroyMonitor(contention->ml); overhead += (PR_IntervalNow() - timein); rv = overhead + contention->overhead; if (verbosity) PR_fprintf( std_err, "Access ratio: %u to %u\n", contention->contentious, contention->contender); PR_Free(contention); return rv; } /* ContentiousMonitor */ /* ** CACHED MONITORS */ static PRIntervalTime NonContentiousCMonitor(PRUint32 loops) { MonitorContentious_t contention; while (loops-- > 0) { PR_CEnterMonitor(&contention); PR_CExitMonitor(&contention); } return 0; } /* NonContentiousCMonitor */ static void PR_CALLBACK Contender(void *arg) { MonitorContentious_t *contention = (MonitorContentious_t*)arg; while (contention->loops-- > 0) { PR_CEnterMonitor(contention); contention->contender+= 1; contention->overhead += contention->interval; PR_Sleep(contention->interval); PR_CExitMonitor(contention); } } /* Contender */ static PRIntervalTime ContentiousCMonitor(PRUint32 loops) { PRStatus status; PRThread *thread = NULL; MonitorContentious_t * contention; PRIntervalTime overhead, timein = PR_IntervalNow(); contention = PR_NEWZAP(MonitorContentious_t); contention->ml = NULL; contention->loops = loops; contention->interval = contention_interval; thread = PR_CreateThread( PR_USER_THREAD, Contender, contention, PR_PRIORITY_LOW, PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0); PR_ASSERT(thread != NULL); overhead = PR_IntervalNow() - timein; while (contention->loops-- > 0) { PR_CEnterMonitor(contention); contention->contentious+= 1; contention->overhead += contention->interval; PR_Sleep(contention->interval); PR_CExitMonitor(contention); } timein = PR_IntervalNow(); status = PR_JoinThread(thread); overhead += (PR_IntervalNow() - timein); overhead += overhead + contention->overhead; if (verbosity) PR_fprintf( std_err, "Access ratio: %u to %u\n", contention->contentious, contention->contender); PR_Free(contention); return overhead; } /* ContentiousCMonitor */ static PRIntervalTime Test( const char* msg, PRUint32 (*test)(PRUint32 loops), PRUint32 loops, PRIntervalTime overhead) { /* * overhead - overhead not measured by the test. * duration - wall clock time it took to perform test. * predicted - extra time test says should not be counted * * Time accountable to the test is duration - overhead - predicted * All times are Intervals and accumulated for all iterations. */ PRFloat64 elapsed; PRIntervalTime accountable, duration; PRUintn spaces = PL_strlen(msg); PRIntervalTime timeout, timein = PR_IntervalNow(); PRIntervalTime predicted = test(loops); timeout = PR_IntervalNow(); duration = timeout - timein; if (debug_mode) { accountable = duration - predicted; accountable -= overhead; elapsed = (PRFloat64)PR_IntervalToMicroseconds(accountable); PR_fprintf(PR_STDOUT, "%s:", msg); while (spaces++ < 50) PR_fprintf(PR_STDOUT, " "); if ((PRInt32)accountable < 0) PR_fprintf(PR_STDOUT, "*****.** usecs/iteration\n"); else PR_fprintf(PR_STDOUT, "%8.2f usecs/iteration\n", elapsed/loops); } return duration; } /* Test */ int main(int argc, char **argv) { PRBool rv = PR_TRUE; PRIntervalTime duration; PRUint32 cpu, cpus = 2, loops = 100; PR_STDIO_INIT(); PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0); { /* The command line argument: -d is used to determine if the test is being run in debug mode. The regress tool requires only one line output:PASS or FAIL. All of the printfs associated with this test has been handled with a if (debug_mode) test. Command line argument -l <num> sets the number of loops. Command line argument -c <num> sets the number of cpus. Usage: lock [-d] [-l <num>] [-c <num>] */ PLOptStatus os; PLOptState *opt = PL_CreateOptState(argc, argv, "dvl:c:"); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 'd': /* debug mode */ debug_mode = PR_TRUE; break; case 'v': /* debug mode */ verbosity = PR_TRUE; break; case 'l': /* number of loops */ loops = atoi(opt->value); break; case 'c': /* number of cpus */ cpus = atoi(opt->value); break; default: break; } } PL_DestroyOptState(opt); } /* main test */ PR_SetConcurrency(8); if (loops == 0) loops = 100; if (debug_mode) { std_err = PR_STDERR; PR_fprintf(std_err, "Lock: Using %d loops\n", loops); } if (cpus == 0) cpus = 2; if (debug_mode) PR_fprintf(std_err, "Lock: Using %d cpu(s)\n", cpus); (void)Sleeper(10); /* try filling in the caches */ for (cpu = 1; cpu <= cpus; ++cpu) { if (debug_mode) PR_fprintf(std_err, "\nLock: Using %d CPU(s)\n", cpu); PR_SetConcurrency(cpu); duration = Test("Overhead of PR_Sleep", Sleeper, loops, 0); duration = 0; (void)Test("Lock creation/deletion", MakeLock, loops, 0); (void)Test("Lock non-contentious locking/unlocking", NonContentiousLock, loops, 0); (void)Test("Lock contentious locking/unlocking", ContentiousLock, loops, duration); (void)Test("Monitor creation/deletion", MakeMonitor, loops, 0); (void)Test("Monitor non-contentious locking/unlocking", NonContentiousMonitor, loops, 0); (void)Test("Monitor contentious locking/unlocking", ContentiousMonitor, loops, duration); (void)Test("Cached monitor non-contentious locking/unlocking", NonContentiousCMonitor, loops, 0); (void)Test("Cached monitor contentious locking/unlocking", ContentiousCMonitor, loops, duration); (void)ReentrantMonitor(loops); } if (debug_mode) PR_fprintf( std_err, "%s: test %s\n", "Lock(mutex) test", ((rv) ? "passed" : "failed")); else { if (!rv) failed_already=1; } if(failed_already) { PR_fprintf(PR_STDOUT, "FAIL\n"); return 1; } else { PR_fprintf(PR_STDOUT, "PASS\n"); return 0; } } /* main */ /* testlock.c */