mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-05 00:25:27 +00:00
258 lines
7.1 KiB
C
258 lines
7.1 KiB
C
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is the Netscape Portable Runtime (NSPR).
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Netscape Communications Corporation.
|
|
* Portions created by the Initial Developer are Copyright (C) 1998-2000
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
/*
|
|
Attached is a test program that uses the nspr1 to demonstrate a bug
|
|
under NT4.0. The fix has already been mentioned (add a ResetEvent just
|
|
before leaving the critical section in _PR_CondWait in hwmon.c).
|
|
*/
|
|
|
|
#include "prthread.h"
|
|
#include "prtypes.h"
|
|
#include "prinit.h"
|
|
#include "prmon.h"
|
|
#include "prlog.h"
|
|
|
|
typedef struct Arg_s
|
|
{
|
|
PRInt32 a, b;
|
|
} Arg_t;
|
|
|
|
PRMonitor* gMonitor; // the monitor
|
|
PRInt32 gReading; // number of read locks
|
|
PRInt32 gWriteWaiting; // number of threads waiting for write lock
|
|
PRInt32 gReadWaiting; // number of threads waiting for read lock
|
|
|
|
PRInt32 gCounter; // a counter
|
|
|
|
// stats
|
|
PRInt32 gReads; // number of successful reads
|
|
PRInt32 gMaxReads; // max number of simultaneous reads
|
|
PRInt32 gMaxWriteWaits; // max number of writes that waited for read
|
|
PRInt32 gMaxReadWaits; // max number of reads that waited for write wait
|
|
|
|
|
|
void spin (PRInt32 aDelay)
|
|
{
|
|
PRInt32 index;
|
|
PRInt32 delay = aDelay * 1000;
|
|
|
|
PR_Sleep(0);
|
|
|
|
// randomize delay a bit
|
|
delay = (delay / 2) + (PRInt32)((float)delay *
|
|
((float)rand () / (float)RAND_MAX));
|
|
|
|
for (index = 0; index < delay * 10; index++)
|
|
// consume a bunch of cpu cycles
|
|
;
|
|
PR_Sleep(0);
|
|
}
|
|
|
|
void doWriteThread (void* arg)
|
|
{
|
|
PRInt32 last;
|
|
Arg_t *args = (Arg_t*)arg;
|
|
PRInt32 aWorkDelay = args->a, aWaitDelay = args->b;
|
|
PR_Sleep(0);
|
|
|
|
while (1)
|
|
{
|
|
// -- enter write lock
|
|
PR_EnterMonitor (gMonitor);
|
|
|
|
if (0 < gReading) // wait for read locks to go away
|
|
{
|
|
PRIntervalTime fiveSecs = PR_SecondsToInterval(5);
|
|
|
|
gWriteWaiting++;
|
|
if (gWriteWaiting > gMaxWriteWaits) // stats
|
|
gMaxWriteWaits = gWriteWaiting;
|
|
while (0 < gReading)
|
|
PR_Wait (gMonitor, fiveSecs);
|
|
gWriteWaiting--;
|
|
}
|
|
// -- write lock entered
|
|
|
|
last = gCounter;
|
|
gCounter++;
|
|
|
|
spin (aWorkDelay);
|
|
|
|
PR_ASSERT (gCounter == (last + 1)); // test invariance
|
|
|
|
// -- exit write lock
|
|
// if (0 < gReadWaiting) // notify waiting reads (do it anyway to show off the CondWait bug)
|
|
PR_NotifyAll (gMonitor);
|
|
|
|
PR_ExitMonitor (gMonitor);
|
|
// -- write lock exited
|
|
|
|
spin (aWaitDelay);
|
|
}
|
|
}
|
|
|
|
void doReadThread (void* arg)
|
|
{
|
|
PRInt32 last;
|
|
Arg_t *args = (Arg_t*)arg;
|
|
PRInt32 aWorkDelay = args->a, aWaitDelay = args->b;
|
|
PR_Sleep(0);
|
|
|
|
while (1)
|
|
{
|
|
// -- enter read lock
|
|
PR_EnterMonitor (gMonitor);
|
|
|
|
if (0 < gWriteWaiting) // give up the monitor to waiting writes
|
|
{
|
|
PRIntervalTime fiveSecs = PR_SecondsToInterval(5);
|
|
|
|
gReadWaiting++;
|
|
if (gReadWaiting > gMaxReadWaits) // stats
|
|
gMaxReadWaits = gReadWaiting;
|
|
while (0 < gWriteWaiting)
|
|
PR_Wait (gMonitor, fiveSecs);
|
|
gReadWaiting--;
|
|
}
|
|
|
|
gReading++;
|
|
|
|
gReads++; // stats
|
|
if (gReading > gMaxReads) // stats
|
|
gMaxReads = gReading;
|
|
|
|
PR_ExitMonitor (gMonitor);
|
|
// -- read lock entered
|
|
|
|
last = gCounter;
|
|
|
|
spin (aWorkDelay);
|
|
|
|
PR_ASSERT (gCounter == last); // test invariance
|
|
|
|
// -- exit read lock
|
|
PR_EnterMonitor (gMonitor); // read unlock
|
|
gReading--;
|
|
|
|
// if ((0 == gReading) && (0 < gWriteWaiting)) // notify waiting writes (do it anyway to show off the CondWait bug)
|
|
PR_NotifyAll (gMonitor);
|
|
PR_ExitMonitor (gMonitor);
|
|
// -- read lock exited
|
|
|
|
spin (aWaitDelay);
|
|
}
|
|
}
|
|
|
|
|
|
void fireThread (
|
|
char* aName, void (*aProc)(void *arg), Arg_t *aArg)
|
|
{
|
|
PRThread *thread = PR_CreateThread(
|
|
PR_USER_THREAD, aProc, aArg, PR_PRIORITY_NORMAL,
|
|
PR_LOCAL_THREAD, PR_UNJOINABLE_THREAD, 0);
|
|
}
|
|
|
|
int pseudoMain (int argc, char** argv, char *pad)
|
|
{
|
|
PRInt32 lastWriteCount = gCounter;
|
|
PRInt32 lastReadCount = gReads;
|
|
Arg_t a1 = {500, 250};
|
|
Arg_t a2 = {500, 500};
|
|
Arg_t a3 = {250, 500};
|
|
Arg_t a4 = {750, 250};
|
|
Arg_t a5 = {100, 750};
|
|
Arg_t a6 = {100, 500};
|
|
Arg_t a7 = {100, 750};
|
|
|
|
gMonitor = PR_NewMonitor ();
|
|
|
|
fireThread ("R1", doReadThread, &a1);
|
|
fireThread ("R2", doReadThread, &a2);
|
|
fireThread ("R3", doReadThread, &a3);
|
|
fireThread ("R4", doReadThread, &a4);
|
|
|
|
fireThread ("W1", doWriteThread, &a5);
|
|
fireThread ("W2", doWriteThread, &a6);
|
|
fireThread ("W3", doWriteThread, &a7);
|
|
|
|
fireThread ("R5", doReadThread, &a1);
|
|
fireThread ("R6", doReadThread, &a2);
|
|
fireThread ("R7", doReadThread, &a3);
|
|
fireThread ("R8", doReadThread, &a4);
|
|
|
|
fireThread ("W4", doWriteThread, &a5);
|
|
fireThread ("W5", doWriteThread, &a6);
|
|
fireThread ("W6", doWriteThread, &a7);
|
|
|
|
while (1)
|
|
{
|
|
PRInt32 writeCount, readCount;
|
|
PRIntervalTime fiveSecs = PR_SecondsToInterval(5);
|
|
PR_Sleep (fiveSecs); // get out of the way
|
|
|
|
// print some stats, not threadsafe, informative only
|
|
writeCount = gCounter;
|
|
readCount = gReads;
|
|
printf ("\ntick %d writes (+%d), %d reads (+%d) [max %d, %d, %d]",
|
|
writeCount, writeCount - lastWriteCount,
|
|
readCount, readCount - lastReadCount,
|
|
gMaxReads, gMaxWriteWaits, gMaxReadWaits);
|
|
lastWriteCount = writeCount;
|
|
lastReadCount = readCount;
|
|
gMaxReads = gMaxWriteWaits = gMaxReadWaits = 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void padStack (int argc, char** argv)
|
|
{
|
|
char pad[512]; /* Work around bug in nspr on windoze */
|
|
pseudoMain (argc, argv, pad);
|
|
}
|
|
|
|
void main (int argc, char **argv)
|
|
{
|
|
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
|
|
PR_STDIO_INIT();
|
|
padStack (argc, argv);
|
|
}
|
|
|
|
|
|
/* bug1test.c */
|