The Tor Browser / file revision

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

   PR_STDIO_INIT();

   padStack (argc, argv);

 }

 /* bug1test.c */