← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/virtualbox-ose/gutsy

« back to all changes in this revision

Viewing changes to src/libs/xpcom18a4/nsprpub/pr/tests/perf.c

  • Committer: Bazaar Package Importer
  • Author(s): Steve Kowalik
  • Date: 2007-09-08 16:44:58 UTC
  • Revision ID: james.westby@ubuntu.com-20070908164458-wao29470vqtr8ksy
Tags: upstream-1.5.0-dfsg2
Import upstream version 1.5.0-dfsg2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libs/xpcom18a4/nsprpub/pr/tests/perf.c
 
1
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 
2
/* ***** BEGIN LICENSE BLOCK *****
 
3
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 
4
 *
 
5
 * The contents of this file are subject to the Mozilla Public License Version
 
6
 * 1.1 (the "License"); you may not use this file except in compliance with
 
7
 * the License. You may obtain a copy of the License at
 
8
 * http://www.mozilla.org/MPL/
 
9
 *
 
10
 * Software distributed under the License is distributed on an "AS IS" basis,
 
11
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 
12
 * for the specific language governing rights and limitations under the
 
13
 * License.
 
14
 *
 
15
 * The Original Code is the Netscape Portable Runtime (NSPR).
 
16
 *
 
17
 * The Initial Developer of the Original Code is
 
18
 * Netscape Communications Corporation.
 
19
 * Portions created by the Initial Developer are Copyright (C) 1998-2000
 
20
 * the Initial Developer. All Rights Reserved.
 
21
 *
 
22
 * Contributor(s):
 
23
 *
 
24
 * Alternatively, the contents of this file may be used under the terms of
 
25
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 
26
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 
27
 * in which case the provisions of the GPL or the LGPL are applicable instead
 
28
 * of those above. If you wish to allow use of your version of this file only
 
29
 * under the terms of either the GPL or the LGPL, and not to allow others to
 
30
 * use your version of this file under the terms of the MPL, indicate your
 
31
 * decision by deleting the provisions above and replace them with the notice
 
32
 * and other provisions required by the GPL or the LGPL. If you do not delete
 
33
 * the provisions above, a recipient may use your version of this file under
 
34
 * the terms of any one of the MPL, the GPL or the LGPL.
 
35
 *
 
36
 * ***** END LICENSE BLOCK ***** */
 
37
 
 
38
#include "nspr.h"
 
39
#include "plgetopt.h"
 
40
 
 
41
#include <stdio.h>
 
42
#include <stdlib.h>
 
43
#include <string.h>
 
44
 
 
45
int _debug_on = 0;
 
46
#define DPRINTF(arg) if (_debug_on) printf arg
 
47
 
 
48
#ifdef XP_MAC
 
49
#include "prlog.h"
 
50
#include "prsem.h"
 
51
#define printf PR_LogPrint
 
52
extern void SetupMacPrintfLog(char *logFile);
 
53
#else
 
54
#include "obsolete/prsem.h"
 
55
#endif
 
56
 
 
57
PRLock *lock;
 
58
PRMonitor *mon;
 
59
PRMonitor *mon2;
 
60
 
 
61
#define DEFAULT_COUNT    1000
 
62
 
 
63
PRInt32 count;
 
64
 
 
65
static void nop(int a, int b, int c)
 
66
{
 
67
}
 
68
 
 
69
static void LocalProcedureCall(void)
 
70
{
 
71
    PRInt32 i;
 
72
 
 
73
    for (i = 0; i < count; i++) {
 
74
    nop(i, i, 5);
 
75
    }
 
76
}
 
77
 
 
78
static void DLLProcedureCall(void)
 
79
{
 
80
    PRInt32 i;
 
81
        PRThreadState state;
 
82
        PRThread *self = PR_CurrentThread();
 
83
 
 
84
    for (i = 0; i < count; i++) {
 
85
        state = PR_GetThreadState(self);
 
86
    }
 
87
}
 
88
 
 
89
static void Now(void)
 
90
{
 
91
    PRInt32 i;
 
92
    PRTime time;
 
93
 
 
94
    for (i = 0; i < count; i++) {
 
95
        time = PR_Now();
 
96
    }
 
97
}
 
98
 
 
99
static void Interval(void)
 
100
{
 
101
    PRInt32 i;
 
102
    PRIntervalTime time;
 
103
 
 
104
    for (i = 0; i < count; i++) {
 
105
        time = PR_IntervalNow();
 
106
    }
 
107
}
 
108
 
 
109
static void IdleLock(void)
 
110
{
 
111
    PRInt32 i;
 
112
 
 
113
    for (i = 0; i < count; i++) {
 
114
    PR_Lock(lock);
 
115
    PR_Unlock(lock);
 
116
    }
 
117
}
 
118
 
 
119
static void IdleMonitor(void)
 
120
{
 
121
    PRInt32 i;
 
122
 
 
123
    for (i = 0; i < count; i++) {
 
124
    PR_EnterMonitor(mon);
 
125
    PR_ExitMonitor(mon);
 
126
    }
 
127
}
 
128
 
 
129
static void IdleCMonitor(void)
 
130
{
 
131
    PRInt32 i;
 
132
 
 
133
    for (i = 0; i < count; i++) {
 
134
    PR_CEnterMonitor((void*)7);
 
135
    PR_CExitMonitor((void*)7);
 
136
    }
 
137
}
 
138
 
 
139
/************************************************************************/
 
140
 
 
141
static void PR_CALLBACK dull(void *arg)
 
142
{
 
143
}
 
144
 
 
145
static void CDThread(void)
 
146
{
 
147
    PRInt32 i;
 
148
    int num_threads = count;
 
149
 
 
150
    /*
 
151
     * Cannot create too many threads
 
152
     */
 
153
    if (num_threads > 1000)
 
154
    num_threads = 1000;
 
155
 
 
156
    for (i = 0; i < num_threads; i++) {
 
157
        PRThread *t = PR_CreateThread(PR_USER_THREAD,
 
158
                      dull, 0, 
 
159
                      PR_PRIORITY_NORMAL,
 
160
                      PR_LOCAL_THREAD,
 
161
                      PR_UNJOINABLE_THREAD,
 
162
                      0);
 
163
        if (NULL == t) {
 
164
            fprintf(stderr, "CDThread: cannot create thread %3d\n", i);
 
165
        } else {
 
166
            DPRINTF(("CDThread: created thread %3d \n",i));
 
167
        }
 
168
        PR_Sleep(0);
 
169
    }
 
170
}
 
171
 
 
172
static int alive;
 
173
static int cxq;
 
174
 
 
175
static void PR_CALLBACK CXReader(void *arg)
 
176
{
 
177
    PRInt32 i, n;
 
178
 
 
179
    PR_EnterMonitor(mon);
 
180
    n = count / 2;
 
181
    for (i = 0; i < n; i++) {
 
182
    while (cxq == 0) {
 
183
            DPRINTF(("CXReader: thread = 0x%lx waiting\n",
 
184
                    PR_GetCurrentThread()));
 
185
        PR_Wait(mon, PR_INTERVAL_NO_TIMEOUT);
 
186
    }
 
187
    --cxq;
 
188
    PR_Notify(mon);
 
189
    }
 
190
    PR_ExitMonitor(mon);
 
191
 
 
192
    PR_EnterMonitor(mon2);
 
193
    --alive;
 
194
    PR_Notify(mon2);
 
195
    PR_ExitMonitor(mon2);
 
196
    DPRINTF(("CXReader: thread = 0x%lx exiting\n", PR_GetCurrentThread()));
 
197
}
 
198
 
 
199
static void PR_CALLBACK CXWriter(void *arg)
 
200
{
 
201
    PRInt32 i, n;
 
202
 
 
203
    PR_EnterMonitor(mon);
 
204
    n = count / 2;
 
205
    for (i = 0; i < n; i++) {
 
206
    while (cxq == 1) {
 
207
            DPRINTF(("CXWriter: thread = 0x%lx waiting\n",
 
208
                    PR_GetCurrentThread()));
 
209
        PR_Wait(mon, PR_INTERVAL_NO_TIMEOUT);
 
210
    }
 
211
    ++cxq;
 
212
    PR_Notify(mon);
 
213
    }
 
214
    PR_ExitMonitor(mon);
 
215
 
 
216
    PR_EnterMonitor(mon2);
 
217
    --alive;
 
218
    PR_Notify(mon2);
 
219
    PR_ExitMonitor(mon2);
 
220
    DPRINTF(("CXWriter: thread = 0x%lx exiting\n", PR_GetCurrentThread()));
 
221
}
 
222
 
 
223
static void ContextSwitch(PRThreadScope scope1, PRThreadScope scope2)
 
224
{
 
225
    PRThread *t1, *t2;
 
226
 
 
227
    PR_EnterMonitor(mon2);
 
228
    alive = 2;
 
229
    cxq = 0;
 
230
 
 
231
    t1 = PR_CreateThread(PR_USER_THREAD,
 
232
                      CXReader, 0, 
 
233
                      PR_PRIORITY_NORMAL,
 
234
                      scope1,
 
235
                      PR_UNJOINABLE_THREAD,
 
236
                      0);
 
237
    if (NULL == t1) {
 
238
        fprintf(stderr, "ContextSwitch: cannot create thread\n");
 
239
    } else {
 
240
        DPRINTF(("ContextSwitch: created %s thread = 0x%lx\n",
 
241
                (scope1 == PR_GLOBAL_THREAD ?
 
242
                "PR_GLOBAL_THREAD" : "PR_LOCAL_THREAD"),
 
243
                            t1));
 
244
    }
 
245
    t2 = PR_CreateThread(PR_USER_THREAD,
 
246
                      CXWriter, 0, 
 
247
                      PR_PRIORITY_NORMAL,
 
248
                      scope2,
 
249
                      PR_UNJOINABLE_THREAD,
 
250
                      0);
 
251
    if (NULL == t2) {
 
252
        fprintf(stderr, "ContextSwitch: cannot create thread\n");
 
253
    } else {
 
254
        DPRINTF(("ContextSwitch: created %s thread = 0x%lx\n",
 
255
                (scope2 == PR_GLOBAL_THREAD ?
 
256
                "PR_GLOBAL_THREAD" : "PR_LOCAL_THREAD"),
 
257
                            t2));
 
258
    }
 
259
 
 
260
    /* Wait for both of the threads to exit */
 
261
    while (alive) {
 
262
    PR_Wait(mon2, PR_INTERVAL_NO_TIMEOUT);
 
263
    }
 
264
    PR_ExitMonitor(mon2);
 
265
}
 
266
 
 
267
static void ContextSwitchUU(void)
 
268
{
 
269
    ContextSwitch(PR_LOCAL_THREAD, PR_LOCAL_THREAD);
 
270
}
 
271
 
 
272
static void ContextSwitchUK(void)
 
273
{
 
274
    ContextSwitch(PR_LOCAL_THREAD, PR_GLOBAL_THREAD);
 
275
}
 
276
 
 
277
static void ContextSwitchKU(void)
 
278
{
 
279
    ContextSwitch(PR_GLOBAL_THREAD, PR_LOCAL_THREAD);
 
280
}
 
281
 
 
282
static void ContextSwitchKK(void)
 
283
{
 
284
    ContextSwitch(PR_GLOBAL_THREAD, PR_GLOBAL_THREAD);
 
285
}
 
286
 
 
287
/************************************************************************/
 
288
 
 
289
static void PR_CALLBACK SemaThread(void *argSema)
 
290
{
 
291
    PRSemaphore **sem = (PRSemaphore **)argSema;
 
292
    PRInt32 i, n;
 
293
 
 
294
    n = count / 2;
 
295
    for (i = 0; i < n; i++) {
 
296
        DPRINTF(("SemaThread: thread = 0x%lx waiting on sem = 0x%lx\n",
 
297
                PR_GetCurrentThread(), sem[0]));
 
298
        PR_WaitSem(sem[0]);
 
299
        DPRINTF(("SemaThread: thread = 0x%lx posting on sem = 0x%lx\n",
 
300
                PR_GetCurrentThread(), sem[1]));
 
301
        PR_PostSem(sem[1]);
 
302
    }
 
303
 
 
304
    PR_EnterMonitor(mon2);
 
305
    --alive;
 
306
    PR_Notify(mon2);
 
307
    PR_ExitMonitor(mon2);
 
308
    DPRINTF(("SemaThread: thread = 0x%lx exiting\n", PR_GetCurrentThread()));
 
309
}
 
310
 
 
311
static  PRSemaphore *sem_set1[2];
 
312
static  PRSemaphore *sem_set2[2];
 
313
 
 
314
static void SemaContextSwitch(PRThreadScope scope1, PRThreadScope scope2)
 
315
{
 
316
    PRThread *t1, *t2;
 
317
    sem_set1[0] = PR_NewSem(1);
 
318
    sem_set1[1] = PR_NewSem(0);
 
319
    sem_set2[0] = sem_set1[1];
 
320
    sem_set2[1] = sem_set1[0];
 
321
 
 
322
    PR_EnterMonitor(mon2);
 
323
    alive = 2;
 
324
    cxq = 0;
 
325
 
 
326
    t1 = PR_CreateThread(PR_USER_THREAD,
 
327
                      SemaThread, 
 
328
                      sem_set1, 
 
329
                      PR_PRIORITY_NORMAL,
 
330
                      scope1,
 
331
                      PR_UNJOINABLE_THREAD,
 
332
                      0);
 
333
    if (NULL == t1) {
 
334
        fprintf(stderr, "SemaContextSwitch: cannot create thread\n");
 
335
    } else {
 
336
        DPRINTF(("SemaContextSwitch: created %s thread = 0x%lx\n",
 
337
                (scope1 == PR_GLOBAL_THREAD ?
 
338
                "PR_GLOBAL_THREAD" : "PR_LOCAL_THREAD"),
 
339
                            t1));
 
340
    }
 
341
    t2 = PR_CreateThread(PR_USER_THREAD,
 
342
                      SemaThread, 
 
343
                      sem_set2, 
 
344
                      PR_PRIORITY_NORMAL,
 
345
                      scope2,
 
346
                      PR_UNJOINABLE_THREAD,
 
347
                      0);
 
348
    if (NULL == t2) {
 
349
        fprintf(stderr, "SemaContextSwitch: cannot create thread\n");
 
350
    } else {
 
351
        DPRINTF(("SemaContextSwitch: created %s thread = 0x%lx\n",
 
352
                (scope2 == PR_GLOBAL_THREAD ?
 
353
                "PR_GLOBAL_THREAD" : "PR_LOCAL_THREAD"),
 
354
                            t2));
 
355
    }
 
356
 
 
357
    /* Wait for both of the threads to exit */
 
358
    while (alive) {
 
359
        PR_Wait(mon2, PR_INTERVAL_NO_TIMEOUT);
 
360
    }
 
361
    PR_ExitMonitor(mon2);
 
362
 
 
363
    PR_DestroySem(sem_set1[0]);
 
364
    PR_DestroySem(sem_set1[1]);
 
365
}
 
366
 
 
367
static void SemaContextSwitchUU(void)
 
368
{
 
369
    SemaContextSwitch(PR_LOCAL_THREAD, PR_LOCAL_THREAD);
 
370
}
 
371
 
 
372
static void SemaContextSwitchUK(void)
 
373
{
 
374
    SemaContextSwitch(PR_LOCAL_THREAD, PR_GLOBAL_THREAD);
 
375
}
 
376
 
 
377
static void SemaContextSwitchKU(void)
 
378
{
 
379
    SemaContextSwitch(PR_GLOBAL_THREAD, PR_LOCAL_THREAD);
 
380
}
 
381
 
 
382
static void SemaContextSwitchKK(void)
 
383
{
 
384
    SemaContextSwitch(PR_GLOBAL_THREAD, PR_GLOBAL_THREAD);
 
385
}
 
386
 
 
387
 
 
388
/************************************************************************/
 
389
 
 
390
static void Measure(void (*func)(void), const char *msg)
 
391
{
 
392
    PRIntervalTime start, stop;
 
393
    double d;
 
394
 
 
395
    start = PR_IntervalNow();
 
396
    (*func)();
 
397
    stop = PR_IntervalNow() - start;
 
398
    d = (double)PR_IntervalToMicroseconds(stop);
 
399
 
 
400
    printf("%40s: %6.2f usec\n", msg, d / count);
 
401
}
 
402
 
 
403
int main(int argc, char **argv)
 
404
{
 
405
        PLOptStatus os;
 
406
        PLOptState *opt = PL_CreateOptState(argc, argv, "dc:");
 
407
        while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
 
408
    {
 
409
                if (PL_OPT_BAD == os) continue;
 
410
        switch (opt->option)
 
411
        {
 
412
        case 'd':  /* debug mode */
 
413
                        _debug_on = 1;
 
414
            break;
 
415
        case 'c':  /* loop count */
 
416
            count = atoi(opt->value);
 
417
            break;
 
418
         default:
 
419
            break;
 
420
        }
 
421
    }
 
422
        PL_DestroyOptState(opt);
 
423
 
 
424
    if (0 == count) count = DEFAULT_COUNT;
 
425
    
 
426
    PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
 
427
        PR_BlockClockInterrupts();
 
428
        PR_UnblockClockInterrupts();
 
429
    PR_STDIO_INIT();
 
430
 
 
431
#ifdef XP_MAC
 
432
    SetupMacPrintfLog("perf.log");
 
433
#endif
 
434
 
 
435
    lock = PR_NewLock();
 
436
    mon = PR_NewMonitor();
 
437
    mon2 = PR_NewMonitor();
 
438
 
 
439
    Measure(LocalProcedureCall, "local procedure call overhead");
 
440
    Measure(DLLProcedureCall, "DLL procedure call overhead");
 
441
    Measure(Now, "current calendar time");
 
442
    Measure(Interval, "interval time");
 
443
    Measure(IdleLock, "idle lock lock/unlock pair");
 
444
    Measure(IdleMonitor, "idle monitor entry/exit pair");
 
445
    Measure(IdleCMonitor, "idle cache monitor entry/exit pair");
 
446
    Measure(CDThread, "create/destroy thread pair");
 
447
    Measure(ContextSwitchUU, "context switch - user/user");
 
448
    Measure(ContextSwitchUK, "context switch - user/kernel");
 
449
    Measure(ContextSwitchKU, "context switch - kernel/user");
 
450
    Measure(ContextSwitchKK, "context switch - kernel/kernel");
 
451
    Measure(SemaContextSwitchUU, "sema context switch - user/user");
 
452
    Measure(SemaContextSwitchUK, "sema context switch - user/kernel");
 
453
    Measure(SemaContextSwitchKU, "sema context switch - kernel/user");
 
454
    Measure(SemaContextSwitchKK, "sema context switch - kernel/kernel");
 
455
 
 
456
    printf("--------------\n");
 
457
    printf("Adding 7 additional CPUs\n");
 
458
 
 
459
    PR_SetConcurrency(8);
 
460
    printf("--------------\n");
 
461
 
 
462
    Measure(LocalProcedureCall, "local procedure call overhead");
 
463
    Measure(DLLProcedureCall, "DLL procedure call overhead");
 
464
    Measure(Now, "current calendar time");
 
465
    Measure(Interval, "interval time");
 
466
    Measure(IdleLock, "idle lock lock/unlock pair");
 
467
    Measure(IdleMonitor, "idle monitor entry/exit pair");
 
468
    Measure(IdleCMonitor, "idle cache monitor entry/exit pair");
 
469
    Measure(CDThread, "create/destroy thread pair");
 
470
    Measure(ContextSwitchUU, "context switch - user/user");
 
471
    Measure(ContextSwitchUK, "context switch - user/kernel");
 
472
    Measure(ContextSwitchKU, "context switch - kernel/user");
 
473
    Measure(ContextSwitchKK, "context switch - kernel/kernel");
 
474
    Measure(SemaContextSwitchUU, "sema context switch - user/user");
 
475
    Measure(SemaContextSwitchUK, "sema context switch - user/kernel");
 
476
    Measure(SemaContextSwitchKU, "sema context switch - kernel/user");
 
477
    Measure(SemaContextSwitchKK, "sema context switch - kernel/kernel");
 
478
 
 
479
    PR_DestroyLock(lock);
 
480
    PR_DestroyMonitor(mon);
 
481
    PR_DestroyMonitor(mon2);
 
482
 
 
483
    PR_Cleanup();
 
484
    return 0;
 
485
}