src/third_party/mozjs-45/nsprpub/pr/tests/cvar.c - cobalt - Git at Google

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

 /***********************************************************************
 **  1996 - Netscape Communications Corporation
 **
 ** Name: cvar.c
 **
 ** Description: Tests Condition Variable Operations
 **
 ** Modification History:
 ** 13-May-97 AGarcia- Converted the test to accomodate the debug_mode flag.
 **	         The debug mode will print all of the printfs associated with this test.
 **			 The regress mode will be the default mode. Since the regress tool limits
 **           the output to a one line status:PASS or FAIL,all of the printf statements
 **			 have been handled with an if (debug_mode) statement.
 ** 04-June-97 AGarcia removed the Test_Result function. Regress tool has been updated to
 **			recognize the return code from tha main program.
 ** 12-June-97 Revert to return code 0 and 1.
 ***********************************************************************/

 /***********************************************************************
 ** Includes
 ***********************************************************************/

 #include "nspr.h"

 /* Used to get the command line option */
 #include "plgetopt.h"

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 PRMonitor *mon;
 #define DEFAULT_COUNT   1000
 PRInt32 count = 0;
 PRIntn debug_mode;

 #define kQSIZE	1

 typedef struct {
 	PRLock		*bufLock;
 	int			startIdx;
 	int			numFull;
 	PRCondVar	*notFull;
 	PRCondVar	*notEmpty;
 	void		*data[kQSIZE];
 } CircBuf;

 static PRBool failed = PR_FALSE;

 /*
 ** NewCB creates and initializes a new circular buffer.
 */
 static CircBuf* NewCB(void)
 {
 	CircBuf		*cbp;

 	cbp = PR_NEW(CircBuf);
 	if (cbp == NULL)
 		return (NULL);

 	cbp->bufLock 	= PR_NewLock();
 	cbp->startIdx 	= 0;
 	cbp->numFull 	= 0;
 	cbp->notFull	= PR_NewCondVar(cbp->bufLock);
 	cbp->notEmpty	= PR_NewCondVar(cbp->bufLock);

 	return (cbp);
 }

 /*
 ** DeleteCB frees a circular buffer.
 */
 static void DeleteCB(CircBuf *cbp)
 {
 	PR_DestroyLock(cbp->bufLock);
 	PR_DestroyCondVar(cbp->notFull);
 	PR_DestroyCondVar(cbp->notEmpty);
 	PR_DELETE(cbp);
 }


 /*
 ** PutCBData puts new data on the queue.  If the queue is full, it waits
 ** until there is room.
 */
 static void PutCBData(CircBuf *cbp, void *data)
 {
 	PR_Lock(cbp->bufLock);
 	/* wait while the buffer is full */
 	while (cbp->numFull == kQSIZE)
 		PR_WaitCondVar(cbp->notFull,PR_INTERVAL_NO_TIMEOUT);
 	cbp->data[(cbp->startIdx + cbp->numFull) % kQSIZE] = data;
 	cbp->numFull += 1;

 	/* let a waiting reader know that there is data */
 	PR_NotifyCondVar(cbp->notEmpty);
 	PR_Unlock(cbp->bufLock);

 }


 /*
 ** GetCBData gets the oldest data on the queue.  If the queue is empty, it waits
 ** until new data appears.
 */
 static void* GetCBData(CircBuf *cbp)
 {
 	void *data;

 	PR_Lock(cbp->bufLock);
 	/* wait while the buffer is empty */
 	while (cbp->numFull == 0)
 		PR_WaitCondVar(cbp->notEmpty,PR_INTERVAL_NO_TIMEOUT);
 	data = cbp->data[cbp->startIdx];
 	cbp->startIdx =(cbp->startIdx + 1) % kQSIZE;
 	cbp->numFull -= 1;

 	/* let a waiting writer know that there is room */
 	PR_NotifyCondVar(cbp->notFull);
 	PR_Unlock(cbp->bufLock);

 	return (data);
 }


 /************************************************************************/

 static int alive;

 static void PR_CALLBACK CXReader(void *arg)
 {
 	CircBuf *cbp = (CircBuf *)arg;
     PRInt32 i, n;
     void *data;

     n = count / 2;
     for (i = 0; i < n; i++) {
 		data = GetCBData(cbp);
 		if ((int)data != i)
     		if (debug_mode) printf("data mismatch at for i = %d usec\n", i);
     }

     PR_EnterMonitor(mon);
     --alive;
     PR_Notify(mon);
     PR_ExitMonitor(mon);
 }

 static void PR_CALLBACK CXWriter(void *arg)
 {
 	CircBuf *cbp = (CircBuf *)arg;
     PRInt32 i, n;

     n = count / 2;
     for (i = 0; i < n; i++)
 		PutCBData(cbp, (void *)i);

     PR_EnterMonitor(mon);
     --alive;
     PR_Notify(mon);
     PR_ExitMonitor(mon);
 }

 static void CondWaitContextSwitch(PRThreadScope scope1, PRThreadScope scope2)
 {
     PRThread *t1, *t2;
 	CircBuf *cbp;

     PR_EnterMonitor(mon);

     alive = 2;

 	cbp =  NewCB();

 	t1 = PR_CreateThread(PR_USER_THREAD,
 				      CXReader, cbp,
 				      PR_PRIORITY_NORMAL,
 				      scope1,
     				  PR_UNJOINABLE_THREAD,
 				      0);
 	PR_ASSERT(t1);
 	t2 = PR_CreateThread(PR_USER_THREAD,
 				      CXWriter, cbp,
 				      PR_PRIORITY_NORMAL,
 				      scope2,
     				  PR_UNJOINABLE_THREAD,
 				      0);
 	PR_ASSERT(t2);

     /* Wait for both of the threads to exit */
     while (alive) {
 	PR_Wait(mon, PR_INTERVAL_NO_TIMEOUT);
     }

 	DeleteCB(cbp);

     PR_ExitMonitor(mon);
 }

 static void CondWaitContextSwitchUU(void)
 {
     CondWaitContextSwitch(PR_LOCAL_THREAD, PR_LOCAL_THREAD);
 }

 static void CondWaitContextSwitchUK(void)
 {
     CondWaitContextSwitch(PR_LOCAL_THREAD, PR_GLOBAL_THREAD);
 }

 static void CondWaitContextSwitchKK(void)
 {
     CondWaitContextSwitch(PR_GLOBAL_THREAD, PR_GLOBAL_THREAD);
 }

 /************************************************************************/

 static void Measure(void (*func)(void), const char *msg)
 {
     PRIntervalTime start, stop;
     double d;

     start = PR_IntervalNow();
     (*func)();
     stop = PR_IntervalNow();

     d = (double)PR_IntervalToMicroseconds(stop - start);

     if (debug_mode) printf("%40s: %6.2f usec\n", msg, d / count);

     if (0 ==  d) failed = PR_TRUE;
 }

 static PRIntn PR_CALLBACK RealMain(int argc, char **argv)
 {
 	/* The command line argument: -d is used to determine if the test is being run
 	in debug mode. The regress tool requires only one line output:PASS or FAIL.
 	All of the printfs associated with this test has been handled with a if (debug_mode)
 	test.
 	Usage: test_name [-d] [-c n]
 	*/
 	PLOptStatus os;
 	PLOptState *opt = PL_CreateOptState(argc, argv, "dc:");
 	while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
     {
 		if (PL_OPT_BAD == os) continue;
         switch (opt->option)
         {
         case 'd':  /* debug mode */
 			debug_mode = 1;
             break;
         case 'c':  /* loop count */
             count = atoi(opt->value);
             break;
          default:
             break;
         }
     }
 	PL_DestroyOptState(opt);

     if (0 == count) count = DEFAULT_COUNT;

     mon = PR_NewMonitor();

     Measure(CondWaitContextSwitchUU, "cond var wait context switch- user/user");
     Measure(CondWaitContextSwitchUK, "cond var wait context switch- user/kernel");
     Measure(CondWaitContextSwitchKK, "cond var wait context switch- kernel/kernel");

 	PR_DestroyMonitor(mon);

 	if (debug_mode) printf("%s\n", (failed) ? "FAILED" : "PASSED");

 	if(failed)
 		return 1;
 	else
 		return 0;
 }


 int main(int argc, char *argv[])
 {
     PRIntn rv;

     PR_STDIO_INIT();
     rv = PR_Initialize(RealMain, argc, argv, 0);
     return rv;
 }  /* main */
	/* -- 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/. */

	/***********************************************************************
	** 1996 - Netscape Communications Corporation
	**
	** Name: cvar.c
	**
	** Description: Tests Condition Variable Operations
	**
	** Modification History:
	** 13-May-97 AGarcia- Converted the test to accomodate the debug_mode flag.
	** The debug mode will print all of the printfs associated with this test.
	** The regress mode will be the default mode. Since the regress tool limits
	** the output to a one line status:PASS or FAIL,all of the printf statements
	** have been handled with an if (debug_mode) statement.
	** 04-June-97 AGarcia removed the Test_Result function. Regress tool has been updated to
	** recognize the return code from tha main program.
	** 12-June-97 Revert to return code 0 and 1.
	***********************************************************************/

	/***********************************************************************
	** Includes
	***********************************************************************/

	#include "nspr.h"

	/* Used to get the command line option */
	#include "plgetopt.h"

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	PRMonitor *mon;
	#define DEFAULT_COUNT 1000
	PRInt32 count = 0;
	PRIntn debug_mode;

	#define kQSIZE 1

	typedef struct {
	PRLock *bufLock;
	int startIdx;
	int numFull;
	PRCondVar *notFull;
	PRCondVar *notEmpty;
	void *data[kQSIZE];
	} CircBuf;

	static PRBool failed = PR_FALSE;

	/*
	** NewCB creates and initializes a new circular buffer.
	*/
	static CircBuf* NewCB(void)
	{
	CircBuf *cbp;

	cbp = PR_NEW(CircBuf);
	if (cbp == NULL)
	return (NULL);

	cbp->bufLock = PR_NewLock();
	cbp->startIdx = 0;
	cbp->numFull = 0;
	cbp->notFull = PR_NewCondVar(cbp->bufLock);
	cbp->notEmpty = PR_NewCondVar(cbp->bufLock);

	return (cbp);
	}

	/*
	** DeleteCB frees a circular buffer.
	*/
	static void DeleteCB(CircBuf *cbp)
	{
	PR_DestroyLock(cbp->bufLock);
	PR_DestroyCondVar(cbp->notFull);
	PR_DestroyCondVar(cbp->notEmpty);
	PR_DELETE(cbp);
	}


	/*
	** PutCBData puts new data on the queue. If the queue is full, it waits
	** until there is room.
	*/
	static void PutCBData(CircBuf cbp, void data)
	{
	PR_Lock(cbp->bufLock);
	/* wait while the buffer is full */
	while (cbp->numFull == kQSIZE)
	PR_WaitCondVar(cbp->notFull,PR_INTERVAL_NO_TIMEOUT);
	cbp->data[(cbp->startIdx + cbp->numFull) % kQSIZE] = data;
	cbp->numFull += 1;

	/* let a waiting reader know that there is data */
	PR_NotifyCondVar(cbp->notEmpty);
	PR_Unlock(cbp->bufLock);

	}


	/*
	** GetCBData gets the oldest data on the queue. If the queue is empty, it waits
	** until new data appears.
	*/
	static void* GetCBData(CircBuf *cbp)
	{
	void *data;

	PR_Lock(cbp->bufLock);
	/* wait while the buffer is empty */
	while (cbp->numFull == 0)
	PR_WaitCondVar(cbp->notEmpty,PR_INTERVAL_NO_TIMEOUT);
	data = cbp->data[cbp->startIdx];
	cbp->startIdx =(cbp->startIdx + 1) % kQSIZE;
	cbp->numFull -= 1;

	/* let a waiting writer know that there is room */
	PR_NotifyCondVar(cbp->notFull);
	PR_Unlock(cbp->bufLock);

	return (data);
	}


	/************************************************************************/

	static int alive;

	static void PR_CALLBACK CXReader(void *arg)
	{
	CircBuf cbp = (CircBuf )arg;
	PRInt32 i, n;
	void *data;

	n = count / 2;
	for (i = 0; i < n; i++) {
	data = GetCBData(cbp);
	if ((int)data != i)
	if (debug_mode) printf("data mismatch at for i = %d usec\n", i);
	}

	PR_EnterMonitor(mon);
	--alive;
	PR_Notify(mon);
	PR_ExitMonitor(mon);
	}

	static void PR_CALLBACK CXWriter(void *arg)
	{
	CircBuf cbp = (CircBuf )arg;
	PRInt32 i, n;

	n = count / 2;
	for (i = 0; i < n; i++)
	PutCBData(cbp, (void *)i);

	PR_EnterMonitor(mon);
	--alive;
	PR_Notify(mon);
	PR_ExitMonitor(mon);
	}

	static void CondWaitContextSwitch(PRThreadScope scope1, PRThreadScope scope2)
	{
	PRThread t1, t2;
	CircBuf *cbp;

	PR_EnterMonitor(mon);

	alive = 2;

	cbp = NewCB();

	t1 = PR_CreateThread(PR_USER_THREAD,
	CXReader, cbp,
	PR_PRIORITY_NORMAL,
	scope1,
	PR_UNJOINABLE_THREAD,
	0);
	PR_ASSERT(t1);
	t2 = PR_CreateThread(PR_USER_THREAD,
	CXWriter, cbp,
	PR_PRIORITY_NORMAL,
	scope2,
	PR_UNJOINABLE_THREAD,
	0);
	PR_ASSERT(t2);

	/* Wait for both of the threads to exit */
	while (alive) {
	PR_Wait(mon, PR_INTERVAL_NO_TIMEOUT);
	}

	DeleteCB(cbp);

	PR_ExitMonitor(mon);
	}

	static void CondWaitContextSwitchUU(void)
	{
	CondWaitContextSwitch(PR_LOCAL_THREAD, PR_LOCAL_THREAD);
	}

	static void CondWaitContextSwitchUK(void)
	{
	CondWaitContextSwitch(PR_LOCAL_THREAD, PR_GLOBAL_THREAD);
	}

	static void CondWaitContextSwitchKK(void)
	{
	CondWaitContextSwitch(PR_GLOBAL_THREAD, PR_GLOBAL_THREAD);
	}

	/************************************************************************/

	static void Measure(void (func)(void), const char msg)
	{
	PRIntervalTime start, stop;
	double d;

	start = PR_IntervalNow();
	(*func)();
	stop = PR_IntervalNow();

	d = (double)PR_IntervalToMicroseconds(stop - start);

	if (debug_mode) printf("%40s: %6.2f usec\n", msg, d / count);

	if (0 == d) failed = PR_TRUE;
	}

	static PRIntn PR_CALLBACK RealMain(int argc, char **argv)
	{
	/* The command line argument: -d is used to determine if the test is being run
	in debug mode. The regress tool requires only one line output:PASS or FAIL.
	All of the printfs associated with this test has been handled with a if (debug_mode)
	test.
	Usage: test_name [-d] [-c n]
	*/
	PLOptStatus os;
	PLOptState *opt = PL_CreateOptState(argc, argv, "dc:");
	while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
	{
	if (PL_OPT_BAD == os) continue;
	switch (opt->option)
	{
	case 'd': /* debug mode */
	debug_mode = 1;
	break;
	case 'c': /* loop count */
	count = atoi(opt->value);
	break;
	default:
	break;
	}
	}
	PL_DestroyOptState(opt);

	if (0 == count) count = DEFAULT_COUNT;

	mon = PR_NewMonitor();

	Measure(CondWaitContextSwitchUU, "cond var wait context switch- user/user");
	Measure(CondWaitContextSwitchUK, "cond var wait context switch- user/kernel");
	Measure(CondWaitContextSwitchKK, "cond var wait context switch- kernel/kernel");

	PR_DestroyMonitor(mon);

	if (debug_mode) printf("%s\n", (failed) ? "FAILED" : "PASSED");

	if(failed)
	return 1;
	else
	return 0;
	}


	int main(int argc, char *argv[])
	{
	PRIntn rv;

	PR_STDIO_INIT();
	rv = PR_Initialize(RealMain, argc, argv, 0);
	return rv;
	} /* main */