The Tor Browser / file comparison

comparison: nsprpub/pr/tests/inrval.c

nsprpub/pr/tests/inrval.c

branch
TOR_BUG_9701
changeset 13
44a2da4a2ab2
equal deleted inserted replaced
-1:000000000000 0:af14fac47c40
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/. */
5
6 /*
7 ** file: inrval.c
8 ** description: Interval conversion test.
9 ** Modification History:
10 ** 15-May-97 AGarcia- Converted the test to accomodate the debug_mode flag.
11 ** The debug mode will print all of the printfs associated with this test.
12 ** The regress mode will be the default mode. Since the regress tool limits
13 ** the output to a one line status:PASS or FAIL,all of the printf statements
14 ** have been handled with an if (debug_mode) statement.
15 ** 04-June-97 AGarcia removed the Test_Result function. Regress tool has been updated to
16 ** recognize the return code from tha main program.
17 **/
18 /***********************************************************************
19 ** Includes
20 ***********************************************************************/
21 /* Used to get the command line option */
22 #include "plgetopt.h"
23
24 #include "prinit.h"
25 #include "obsolete/pralarm.h"
26
27 #include "prio.h"
28 #include "prprf.h"
29 #include "prlock.h"
30 #include "prlong.h"
31 #include "prcvar.h"
32 #include "prinrval.h"
33 #include "prtime.h"
34
35 #include "plgetopt.h"
36
37 #include <stdio.h>
38 #include <stdlib.h>
39
40 static PRIntn debug_mode;
41 static PRFileDesc *output;
42
43
44 static void TestConversions(void)
45 {
46 PRIntervalTime ticks = PR_TicksPerSecond();
47
48 if (debug_mode) {
49 PR_fprintf(output, "PR_TicksPerSecond: %ld\n\n", ticks);
50 PR_fprintf(output, "PR_SecondsToInterval(1): %ld\n", PR_SecondsToInterval(1));
51 PR_fprintf(output, "PR_MillisecondsToInterval(1000): %ld\n", PR_MillisecondsToInterval(1000));
52 PR_fprintf(output, "PR_MicrosecondsToInterval(1000000): %ld\n\n", PR_MicrosecondsToInterval(1000000));
53
54 PR_fprintf(output, "PR_SecondsToInterval(3): %ld\n", PR_SecondsToInterval(3));
55 PR_fprintf(output, "PR_MillisecondsToInterval(3000): %ld\n", PR_MillisecondsToInterval(3000));
56 PR_fprintf(output, "PR_MicrosecondsToInterval(3000000): %ld\n\n", PR_MicrosecondsToInterval(3000000));
57
58 PR_fprintf(output, "PR_IntervalToSeconds(%ld): %ld\n", ticks, PR_IntervalToSeconds(ticks));
59 PR_fprintf(output, "PR_IntervalToMilliseconds(%ld): %ld\n", ticks, PR_IntervalToMilliseconds(ticks));
60 PR_fprintf(output, "PR_IntervalToMicroseconds(%ld): %ld\n\n", ticks, PR_IntervalToMicroseconds(ticks));
61
62 ticks *= 3;
63 PR_fprintf(output, "PR_IntervalToSeconds(%ld): %ld\n", ticks, PR_IntervalToSeconds(ticks));
64 PR_fprintf(output, "PR_IntervalToMilliseconds(%ld): %ld\n", ticks, PR_IntervalToMilliseconds(ticks));
65 PR_fprintf(output, "PR_IntervalToMicroseconds(%ld): %ld\n\n", ticks, PR_IntervalToMicroseconds(ticks));
66 } /*end debug mode */
67 } /* TestConversions */
68
69 static void TestIntervalOverhead(void)
70 {
71 /* Hopefully the optimizer won't delete this function */
72 PRUint32 elapsed, per_call, loops = 1000000;
73
74 PRIntervalTime timeout, timein = PR_IntervalNow();
75 while (--loops > 0)
76 timeout = PR_IntervalNow();
77
78 elapsed = 1000U * PR_IntervalToMicroseconds(timeout - timein);
79 per_call = elapsed / 1000000U;
80 PR_fprintf(
81 output, "Overhead of 'PR_IntervalNow()' is %u nsecs\n\n", per_call);
82 } /* TestIntervalOverhead */
83
84 static void TestNowOverhead(void)
85 {
86 PRTime timeout, timein;
87 PRInt32 overhead, loops = 1000000;
88 PRInt64 elapsed, per_call, ten23rd, ten26th;
89
90 LL_I2L(ten23rd, 1000);
91 LL_I2L(ten26th, 1000000);
92
93 timein = PR_Now();
94 while (--loops > 0)
95 timeout = PR_Now();
96
97 LL_SUB(elapsed, timeout, timein);
98 LL_MUL(elapsed, elapsed, ten23rd);
99 LL_DIV(per_call, elapsed, ten26th);
100 LL_L2I(overhead, per_call);
101 PR_fprintf(
102 output, "Overhead of 'PR_Now()' is %u nsecs\n\n", overhead);
103 } /* TestNowOverhead */
104
105 static void TestIntervals(void)
106 {
107 PRStatus rv;
108 PRUint32 delta;
109 PRInt32 seconds;
110 PRUint64 elapsed, thousand;
111 PRTime timein, timeout;
112 PRLock *ml = PR_NewLock();
113 PRCondVar *cv = PR_NewCondVar(ml);
114 for (seconds = 0; seconds < 10; ++seconds)
115 {
116 PRIntervalTime ticks = PR_SecondsToInterval(seconds);
117 PR_Lock(ml);
118 timein = PR_Now();
119 rv = PR_WaitCondVar(cv, ticks);
120 timeout = PR_Now();
121 PR_Unlock(ml);
122 LL_SUB(elapsed, timeout, timein);
123 LL_I2L(thousand, 1000);
124 LL_DIV(elapsed, elapsed, thousand);
125 LL_L2UI(delta, elapsed);
126 if (debug_mode) PR_fprintf(output,
127 "TestIntervals: %swaiting %ld seconds took %ld msecs\n",
128 ((rv == PR_SUCCESS) ? "" : "FAILED "), seconds, delta);
129 }
130 PR_DestroyCondVar(cv);
131 PR_DestroyLock(ml);
132 if (debug_mode) PR_fprintf(output, "\n");
133 } /* TestIntervals */
134
135 static PRIntn PR_CALLBACK RealMain(int argc, char** argv)
136 {
137 PRUint32 vcpu, cpus = 0, loops = 1000;
138
139 /* The command line argument: -d is used to determine if the test is being run
140 in debug mode. The regress tool requires only one line output:PASS or FAIL.
141 All of the printfs associated with this test has been handled with a if (debug_mode)
142 test.
143 Usage: test_name -d
144 */
145
146 /* main test */
147
148 PLOptStatus os;
149 PLOptState *opt = PL_CreateOptState(argc, argv, "dl:c:");
150 while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
151 {
152 if (PL_OPT_BAD == os) continue;
153 switch (opt->option)
154 {
155 case 'd': /* debug mode */
156 debug_mode = 1;
157 break;
158 case 'c': /* concurrency counter */
159 cpus = atoi(opt->value);
160 break;
161 case 'l': /* loop counter */
162 loops = atoi(opt->value);
163 break;
164 default:
165 break;
166 }
167 }
168 PL_DestroyOptState(opt);
169
170 output = PR_GetSpecialFD(PR_StandardOutput);
171 PR_fprintf(output, "inrval: Examine stdout to determine results.\n");
172
173 if (cpus == 0) cpus = 8;
174 if (loops == 0) loops = 1000;
175
176 if (debug_mode > 0)
177 {
178 PR_fprintf(output, "Inrval: Using %d loops\n", loops);
179 PR_fprintf(output, "Inrval: Using 1 and %d cpu(s)\n", cpus);
180 }
181
182 for (vcpu = 1; vcpu <= cpus; vcpu += cpus - 1)
183 {
184 if (debug_mode)
185 PR_fprintf(output, "\nInrval: Using %d CPU(s)\n\n", vcpu);
186 PR_SetConcurrency(vcpu);
187
188 TestNowOverhead();
189 TestIntervalOverhead();
190 TestConversions();
191 TestIntervals();
192 }
193
194 return 0;
195 }
196
197
198 int main(int argc, char **argv)
199 {
200 PRIntn rv;
201
202 PR_STDIO_INIT();
203 rv = PR_Initialize(RealMain, argc, argv, 0);
204 return rv;
205 } /* main */
206

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial