The Tor Browser / file revision

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

 /*

  *

  * RWLock tests

  *

  *	Several threads are created to access and modify data arrays using

  * 	PRRWLocks for synchronization. Two data arrays, array_A and array_B, are

  *	initialized with random data and a third array, array_C, is initialized

  *	with the sum of the first 2 arrays.

  *

  *	Each one of the threads acquires a read lock to verify that the sum of

  *	the arrays A and B is equal to array C, and acquires a write lock to

  *	consistently update arrays A and B so that their is equal to array C.

  *		

  */

 #include "nspr.h"

 #include "plgetopt.h"

 #include "prrwlock.h"

 static int _debug_on;

 static void rwtest(void *args);

 static PRInt32 *array_A,*array_B,*array_C;

 static void update_array(void);

 static void check_array(void);

 typedef struct thread_args {

 	PRRWLock	*rwlock;

 	PRInt32		loop_cnt;

 } thread_args;

 PRFileDesc  *output;

 PRFileDesc  *errhandle;

 #define	DEFAULT_THREAD_CNT	4

 #define	DEFAULT_LOOP_CNT	100

 #define	TEST_ARRAY_SIZE		100

 int main(int argc, char **argv)

 {

     PRInt32 cnt;

 	PRStatus rc;

 	PRInt32 i;

 	PRInt32 thread_cnt = DEFAULT_THREAD_CNT;

 	PRInt32 loop_cnt = DEFAULT_LOOP_CNT;

 	PRThread **threads;

 	thread_args *params;

 	PRRWLock	*rwlock1;

 	PLOptStatus os;

 	PLOptState *opt = PL_CreateOptState(argc, argv, "dt:c:");

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

     {

 		if (PL_OPT_BAD == os) continue;

         switch (opt->option)

         {

         case 'd':  /* debug mode */

 			_debug_on = 1;

             break;

         case 't':  /* thread count */

             thread_cnt = atoi(opt->value);

             break;

         case 'c':  /* loop count */

             loop_cnt = atoi(opt->value);

             break;

          default:

             break;

         }

     }

 	PL_DestroyOptState(opt);

 	PR_SetConcurrency(4);

     output = PR_GetSpecialFD(PR_StandardOutput);

     errhandle = PR_GetSpecialFD(PR_StandardError);

 	rwlock1 = PR_NewRWLock(0,"Lock 1");

 	if (rwlock1 == NULL) {

 		PR_fprintf(errhandle, "PR_NewRWLock failed - error %d\n",

 								PR_GetError());

 		return 1;

 	}

 	threads = (PRThread**) PR_CALLOC(sizeof(PRThread*) * thread_cnt);

 	params = (thread_args *) PR_CALLOC(sizeof(thread_args) * thread_cnt);

 	/*

 	 * allocate and initialize data arrays

 	 */

 	array_A =(PRInt32 *) PR_MALLOC(sizeof(PRInt32) * TEST_ARRAY_SIZE);

 	array_B =(PRInt32 *) PR_MALLOC(sizeof(PRInt32) * TEST_ARRAY_SIZE);

 	array_C =(PRInt32 *) PR_MALLOC(sizeof(PRInt32) * TEST_ARRAY_SIZE);

 	cnt = 0;

 	for (i=0; i < TEST_ARRAY_SIZE;i++) {

 		array_A[i] = cnt++;

 		array_B[i] = cnt++;

 		array_C[i] = array_A[i] + array_B[i];

 	}

 	if (_debug_on)

 		PR_fprintf(output,"%s: thread_cnt = %d loop_cnt = %d\n", argv[0],

 							thread_cnt, loop_cnt);

 	for(cnt = 0; cnt < thread_cnt; cnt++) {

 		PRThreadScope scope;

 		params[cnt].rwlock = rwlock1;

 		params[cnt].loop_cnt = loop_cnt;

 		/*

 		 * create LOCAL and GLOBAL threads alternately

 		 */

 		if (cnt & 1)

 			scope = PR_LOCAL_THREAD;

 		else

 			scope = PR_GLOBAL_THREAD;

 		threads[cnt] = PR_CreateThread(PR_USER_THREAD,

 						  rwtest, &params[cnt],

 						  PR_PRIORITY_NORMAL,

 						  scope,

 						  PR_JOINABLE_THREAD,

 						  0);

 		if (threads[cnt] == NULL) {

 			PR_fprintf(errhandle, "PR_CreateThread failed - error %d\n",

 								PR_GetError());

 			PR_ProcessExit(2);

 		}

 		if (_debug_on)

 			PR_fprintf(output,"%s: created thread = %p\n", argv[0],

 										threads[cnt]);

 	}

 	for(cnt = 0; cnt < thread_cnt; cnt++) {

     	rc = PR_JoinThread(threads[cnt]);

 		PR_ASSERT(rc == PR_SUCCESS);

 	}

 	PR_DELETE(threads);

 	PR_DELETE(params);

 	PR_DELETE(array_A);	

 	PR_DELETE(array_B);	

 	PR_DELETE(array_C);	

 	PR_DestroyRWLock(rwlock1);

 	printf("PASS\n");

 	return 0;

 }

 static void rwtest(void *args)

 {

     PRInt32 index;

 	thread_args *arg = (thread_args *) args;

 	for (index = 0; index < arg->loop_cnt; index++) {

 		/*

 		 * verify sum, update arrays and verify sum again

 		 */

 		PR_RWLock_Rlock(arg->rwlock);

 		check_array();

 		PR_RWLock_Unlock(arg->rwlock);

 		PR_RWLock_Wlock(arg->rwlock);

 		update_array();

 		PR_RWLock_Unlock(arg->rwlock);

 		PR_RWLock_Rlock(arg->rwlock);

 		check_array();

 		PR_RWLock_Unlock(arg->rwlock);

 	}

 	if (_debug_on)

 		PR_fprintf(output,

 		"Thread[0x%x] lock = 0x%x exiting\n",

 				PR_GetCurrentThread(), arg->rwlock);

 }

 static void check_array(void)

 {

 PRInt32 i;

 	for (i=0; i < TEST_ARRAY_SIZE;i++)

 		if (array_C[i] != (array_A[i] + array_B[i])) {

 			PR_fprintf(output, "Error - data check failed\n");

 			PR_ProcessExit(1);

 		}

 }

 static void update_array(void)

 {

 PRInt32 i;

 	for (i=0; i < TEST_ARRAY_SIZE;i++) {

 		array_A[i] += i;

 		array_B[i] -= i;

 	}

 }