The Tor Browser: nsprpub/pr/tests/concur.c@ca08bd8f51b2

     1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

     2 /* This Source Code Form is subject to the terms of the Mozilla Public

     3  * License, v. 2.0. If a copy of the MPL was not distributed with this

     4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     6 /*

     7 ** File:            concur.c

     8 ** Description:     test of adding and removing concurrency options

     9 */

    11 #include "prcvar.h"

    12 #include "prinit.h"

    13 #include "prinrval.h"

    14 #include "prlock.h"

    15 #include "prprf.h"

    16 #include "prmem.h"

    17 #include "prlog.h"

    19 #include "plgetopt.h"

    21 #include "private/pprio.h"

    23 #include <stdlib.h>

    25 #define DEFAULT_RANGE 10

    26 #define DEFAULT_LOOPS 100

    28 static PRThreadScope thread_scope = PR_LOCAL_THREAD;

    30 typedef struct Context

    31 {

    32     PRLock *ml;

    33     PRCondVar *cv;

    34     PRIntn want, have;

    35 } Context;

    38 /*

    39 ** Make the instance of 'context' static (not on the stack)

    40 ** for Win16 threads

    41 */

    42 static Context context = {NULL, NULL, 0, 0};

    44 static void PR_CALLBACK Dull(void *arg)

    45 {

    46     Context *context = (Context*)arg;

    47     PR_Lock(context->ml);

    48     context->have += 1;

    49     while (context->want >= context->have)

    50         PR_WaitCondVar(context->cv, PR_INTERVAL_NO_TIMEOUT);

    51     context->have -= 1;

    52     PR_Unlock(context->ml);

    53 }  /* Dull */

    55 PRIntn PR_CALLBACK Concur(PRIntn argc, char **argv)

    56 {

    57     PRUintn cpus;

    58 	PLOptStatus os;

    59 	PRThread **threads;

    60     PRBool debug = PR_FALSE;

    61     PRUintn range = DEFAULT_RANGE;

    62 	PRStatus rc;

    63     PRUintn cnt;

    64     PRUintn loops = DEFAULT_LOOPS;

    65 	PRIntervalTime hundredMills = PR_MillisecondsToInterval(100);

    66 	PLOptState *opt = PL_CreateOptState(argc, argv, "Gdl:r:");

    67 	while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))

    68     {

    69 		if (PL_OPT_BAD == os) continue;

    70         switch (opt->option)

    71         {

    72         case 'G':  /* GLOBAL threads */

    73 			thread_scope = PR_GLOBAL_THREAD;

    74             break;

    75         case 'd':  /* debug mode */

    76 			debug = PR_TRUE;

    77             break;

    78         case 'r':  /* range limit */

    79 			range = atoi(opt->value);

    80             break;

    81         case 'l':  /* loop counter */

    82 			loops = atoi(opt->value);

    83             break;

    84          default:

    85             break;

    86         }

    87     }

    88 	PL_DestroyOptState(opt);

    90     if (0 == range) range = DEFAULT_RANGE;

    91     if (0 == loops) loops = DEFAULT_LOOPS;

    93     context.ml = PR_NewLock();

    94     context.cv = PR_NewCondVar(context.ml);

    96     if (debug)

    97         PR_fprintf(

    98             PR_STDERR, "Testing with %d CPUs and %d interations\n", range, loops);

   100 	threads = (PRThread**) PR_CALLOC(sizeof(PRThread*) * range);

   101     while (--loops > 0)

   102     {

   103         for (cpus = 1; cpus <= range; ++cpus)

   104         {

   105             PR_SetConcurrency(cpus);

   106             context.want = cpus;

   108             threads[cpus - 1] = PR_CreateThread(

   109                 PR_USER_THREAD, Dull, &context, PR_PRIORITY_NORMAL,

   110 				      thread_scope, PR_JOINABLE_THREAD, 0);

   111         }

   113         PR_Sleep(hundredMills);

   115         for (cpus = range; cpus > 0; cpus--)

   116         {

   117             PR_SetConcurrency(cpus);

   118             context.want = cpus - 1;

   120             PR_Lock(context.ml);

   121             PR_NotifyCondVar(context.cv);

   122             PR_Unlock(context.ml);

   123         }

   124 		for(cnt = 0; cnt < range; cnt++) {

   125 			rc = PR_JoinThread(threads[cnt]);

   126 			PR_ASSERT(rc == PR_SUCCESS);

   127 		}

   128     }

   131     if (debug)

   132         PR_fprintf(

   133             PR_STDERR, "Waiting for %d thread(s) to exit\n", context.have);

   135     while (context.have > 0) PR_Sleep(hundredMills);

   137     if (debug)

   138         PR_fprintf(

   139             PR_STDERR, "Finished [want: %d, have: %d]\n",

   140             context.want, context.have);

   142     PR_DestroyLock(context.ml);

   143     PR_DestroyCondVar(context.cv);

   144     PR_DELETE(threads);

   146     PR_fprintf(PR_STDERR, "PASSED\n");

   148     return 0;

   149 } /* Concur */

   151 int main(int argc, char **argv)

   152 {

   153     PR_STDIO_INIT();

   154     return PR_Initialize(Concur, argc, argv, 0);

   155 }  /* main */

   157 /* concur.c */

The Tor Browser / file revision