tor-browser

bug1test.c (5674B)

---

/* -*- 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/. */

/*
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);
}

int main(int argc, char** argv) {
 PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
 padStack(argc, argv);
}

/* bug1test.c */