Initial revision
[kopensolaris-gnu/glibc.git] / nptl / perf.c
1 /* Copyright (C) 2002 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 #define _GNU_SOURCE     1
21 #include <argp.h>
22 #include <error.h>
23 #include <errno.h>
24 #include <fcntl.h>
25 #include <inttypes.h>
26 #include <limits.h>
27 #include <pthread.h>
28 #include <signal.h>
29 #include <stdbool.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <time.h>
33 #include <unistd.h>
34 #include <sys/param.h>
35 #include <sys/types.h>
36
37 #ifndef MAX_THREADS
38 # define MAX_THREADS            100000
39 #endif
40 #ifndef DEFAULT_THREADS
41 # define DEFAULT_THREADS        50
42 #endif
43
44
45 #define OPT_TO_THREAD           300
46 #define OPT_TO_PROCESS          301
47 #define OPT_SYNC_SIGNAL         302
48 #define OPT_SYNC_JOIN           303
49 #define OPT_TOPLEVEL            304
50
51
52 static const struct argp_option options[] =
53   {
54     { NULL, 0, NULL, 0, "\
55 This is a test for threads so we allow ther user to selection the number of \
56 threads which are used at any one time.  Independently the total number of \
57 rounds can be selected.  This is the total number of threads which will have \
58 run when the process terminates:" },
59     { "threads", 't', "NUMBER", 0, "Number of threads used at once" },
60     { "starts", 's', "NUMBER", 0, "Total number of working threads" },
61     { "toplevel", OPT_TOPLEVEL, "NUMBER", 0,
62       "Number of toplevel threads which start the other threads; this \
63 implies --sync-join" },
64
65     { NULL, 0, NULL, 0, "\
66 Each thread can do one of two things: sleep or do work.  The latter is 100% \
67 CPU bound.  The work load is the probability a thread does work.  All values \
68 from zero to 100 (inclusive) are valid.  How often each thread repeats this \
69 can be determined by the number of rounds.  The work cost determines how long \
70 each work session (not sleeping) takes.  If it is zero a thread would \
71 effectively nothing.  By setting the number of rounds to zero the thread \
72 does no work at all and pure thread creation times can be measured." },
73     { "workload", 'w', "PERCENT", 0, "Percentage of time spent working" },
74     { "workcost", 'c', "NUMBER", 0,
75       "Factor in the cost of each round of working" },
76     { "rounds", 'r', "NUMBER", 0, "Number of rounds each thread runs" },
77
78     { NULL, 0, NULL, 0, "\
79 There are a number of different methods how thread creation can be \
80 synchronized.  Synchronization is necessary since the number of concurrently \
81 running threads is limited." },
82     { "sync-signal", OPT_SYNC_SIGNAL, NULL, 0,
83       "Synchronize using a signal (default)" },
84     { "sync-join", OPT_SYNC_JOIN, NULL, 0, "Synchronize using pthread_join" },
85
86     { NULL, 0, NULL, 0, "\
87 One parameter for each threads execution is the size of the stack.  If this \
88 parameter is not used the system's default stack size is used.  If many \
89 threads are used the stack size should be chosen quite small." },
90     { "stacksize", 'S', "BYTES", 0, "Size of threads stack" },
91     { "guardsize", 'g', "BYTES", 0,
92       "Size of stack guard area; must fit into the stack" },
93
94     { NULL, 0, NULL, 0, "Signal options:" },
95     { "to-thread", OPT_TO_THREAD, NULL, 0, "Send signal to main thread" },
96     { "to-process", OPT_TO_PROCESS, NULL, 0,
97       "Send signal to process (default)" },
98
99     { NULL, 0, NULL, 0, "Administrative options:" },
100     { "progress", 'p', NULL, 0, "Show signs of progress" },
101     { "timing", 'T', NULL, 0,
102       "Measure time from startup to the last thread finishing" },
103     { NULL, 0, NULL, 0, NULL }
104   };
105
106 /* Prototype for option handler.  */
107 static error_t parse_opt (int key, char *arg, struct argp_state *state);
108
109 /* Data structure to communicate with argp functions.  */
110 static struct argp argp =
111 {
112   options, parse_opt
113 };
114
115
116 static unsigned long int threads = DEFAULT_THREADS;
117 static unsigned long int workload = 75;
118 static unsigned long int workcost = 20;
119 static unsigned long int rounds = 10;
120 static long int starts = 5000;
121 static unsigned long int stacksize;
122 static long int guardsize = -1;
123 static bool progress;
124 static bool timing;
125 static bool to_thread;
126 static unsigned long int toplevel = 1;
127
128
129 static long int running;
130 static pthread_mutex_t running_mutex = PTHREAD_MUTEX_INITIALIZER;
131
132 static pid_t pid;
133 static pthread_t tmain;
134
135 static clockid_t cl;
136 static struct timespec start_time;
137
138
139 static pthread_mutex_t sum_mutex = PTHREAD_MUTEX_INITIALIZER;
140 unsigned int sum;
141
142 static enum
143   {
144     sync_signal,
145     sync_join
146   }
147 sync_method;
148
149
150 /* We use 64bit values for the times.  */
151 typedef unsigned long long int hp_timing_t;
152
153
154 /* Attributes for all created threads.  */
155 static pthread_attr_t attr;
156
157
158 static void *
159 work (void *arg)
160 {
161   unsigned long int i;
162   unsigned int state = (unsigned long int) arg;
163
164   for (i = 0; i < rounds; ++i)
165     {
166       /* Determine what to do.  */
167       unsigned int rnum;
168
169       /* Equal distribution.  */
170       do
171         rnum = rand_r (&state);
172       while (rnum >= UINT_MAX - (UINT_MAX % 100));
173
174       rnum %= 100;
175
176       if (rnum < workload)
177         {
178           int j;
179           int a[4] = { i, rnum, i + rnum, rnum - i };
180
181           if (progress)
182             write (STDERR_FILENO, "c", 1);
183
184           for (j = 0; j < workcost; ++j)
185             {
186               a[0] += a[3] >> 12;
187               a[1] += a[2] >> 20;
188               a[2] += a[1] ^ 0x3423423;
189               a[3] += a[0] - a[1];
190             }
191
192           pthread_mutex_lock (&sum_mutex);
193           sum += a[0] + a[1] + a[2] + a[3];
194           pthread_mutex_unlock (&sum_mutex);
195         }
196       else
197         {
198           /* Just sleep.  */
199           struct timespec tv;
200
201           tv.tv_sec = 0;
202           tv.tv_nsec = 10000000;
203
204           if (progress)
205             write (STDERR_FILENO, "w", 1);
206
207           nanosleep (&tv, NULL);
208         }
209     }
210
211   return NULL;
212 }
213
214
215 static void *
216 thread_function (void *arg)
217 {
218   work (arg);
219
220   pthread_mutex_lock (&running_mutex);
221   if (--running <= 0 && starts <= 0)
222     {
223       /* We are done.  */
224       if (progress)
225         write (STDERR_FILENO, "\n", 1);
226
227       if (timing)
228         {
229           struct timespec end_time;
230
231           if (clock_gettime (cl, &end_time) == 0)
232             {
233               end_time.tv_sec -= start_time.tv_sec;
234               end_time.tv_nsec -= start_time.tv_nsec;
235               if (end_time.tv_nsec < 0)
236                 {
237                   end_time.tv_nsec += 1000000000;
238                   --end_time.tv_sec;
239                 }
240
241               printf ("\nRuntime: %lu.%09lu seconds\n",
242                       (unsigned long int) end_time.tv_sec,
243                       (unsigned long int) end_time.tv_nsec);
244             }
245         }
246
247       printf ("Result: %08x\n", sum);
248
249       exit (0);
250     }
251   pthread_mutex_unlock (&running_mutex);
252
253   if (sync_method == sync_signal)
254     {
255       if (to_thread)
256         /* This code sends a signal to the main thread.  */
257         pthread_kill (tmain, SIGUSR1);
258       else
259         /* Use this code to test sending a signal to the process.  */
260         kill (pid, SIGUSR1);
261     }
262
263   if (progress)
264     write (STDERR_FILENO, "f", 1);
265
266   return NULL;
267 }
268
269
270 struct start_info
271 {
272   unsigned int starts;
273   unsigned int threads;
274 };
275
276
277 static void *
278 start_threads (void *arg)
279 {
280   struct start_info *si = arg;
281   unsigned int starts = si->starts;
282   pthread_t ths[si->threads];
283   unsigned int state = starts;
284   unsigned int n;
285   unsigned int i = 0;
286   int err;
287
288   if (progress)
289     write (STDERR_FILENO, "T", 1);
290
291   memset (ths, '\0', sizeof (pthread_t) * si->threads);
292
293   while (starts-- > 0)
294     {
295       if (ths[i] != 0)
296         {
297           /* Wait for the threads in the order they were created.  */
298           err = pthread_join (ths[i], NULL);
299           if (err != 0)
300             error (EXIT_FAILURE, err, "cannot join thread");
301
302           if (progress)
303             write (STDERR_FILENO, "f", 1);
304         }
305
306       err = pthread_create (&ths[i], &attr, work,
307                             (void *) (rand_r (&state) + starts + i));
308
309       if (err != 0)
310         error (EXIT_FAILURE, err, "cannot start thread");
311
312       if (progress)
313         write (STDERR_FILENO, "t", 1);
314
315       if (++i == si->threads)
316         i = 0;
317     }
318
319   n = i;
320   do
321     {
322       if (ths[i] != 0)
323         {
324           err = pthread_join (ths[i], NULL);
325           if (err != 0)
326             error (EXIT_FAILURE, err, "cannot join thread");
327
328           if (progress)
329             write (STDERR_FILENO, "f", 1);
330         }
331
332       if (++i == si->threads)
333         i = 0;
334     }
335   while (i != n);
336
337   if (progress)
338     write (STDERR_FILENO, "F", 1);
339
340   return NULL;
341 }
342
343
344 int
345 main (int argc, char *argv[])
346 {
347   int remaining;
348   sigset_t ss;
349   pthread_t th;
350   pthread_t *ths = NULL;
351   int empty = 0;
352   int last;
353   bool cont = true;
354
355   /* Parse and process arguments.  */
356   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
357
358   if (sync_method == sync_join)
359     {
360       ths = (pthread_t *) calloc (threads, sizeof (pthread_t));
361       if (ths == NULL)
362         error (EXIT_FAILURE, errno,
363                "cannot allocate memory for thread descriptor array");
364
365       last = threads;
366     }
367   else
368     {
369       ths = &th;
370       last = 1;
371     }
372
373   if (toplevel > threads)
374     {
375       printf ("resetting number of toplevel threads to %lu to not surpass number to concurrent threads\n",
376               threads);
377       toplevel = threads;
378     }
379
380   if (timing)
381     {
382       if (clock_getcpuclockid (0, &cl) != 0
383           || clock_gettime (cl, &start_time) != 0)
384         timing = false;
385     }
386
387   /* We need this later.  */
388   pid = getpid ();
389   tmain = pthread_self ();
390
391   /* We use signal SIGUSR1 for communication between the threads and
392      the main thread.  We only want sychronous notification.  */
393   if (sync_method == sync_signal)
394     {
395       sigemptyset (&ss);
396       sigaddset (&ss, SIGUSR1);
397       if (sigprocmask (SIG_BLOCK, &ss, NULL) != 0)
398         error (EXIT_FAILURE, errno, "cannot set signal mask");
399     }
400
401   /* Create the thread attributes.  */
402   pthread_attr_init (&attr);
403
404   /* If the user provided a stack size use it.  */
405   if (stacksize != 0
406       && pthread_attr_setstacksize (&attr, stacksize) != 0)
407     puts ("could not set stack size; will use default");
408   /* And stack guard size.  */
409   if (guardsize != -1
410       && pthread_attr_setguardsize (&attr, guardsize) != 0)
411     puts ("invalid stack guard size; will use default");
412
413   /* All threads are created detached if we are not using pthread_join
414      to synchronize.  */
415   if (sync_method != sync_join)
416     pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
417
418   if (sync_method == sync_signal)
419     {
420       while (1)
421         {
422           int err;
423           bool do_wait = false;
424
425           pthread_mutex_lock (&running_mutex);
426           if (starts-- < 0)
427             cont = false;
428           else
429             do_wait = ++running >= threads && starts > 0;
430
431           pthread_mutex_unlock (&running_mutex);
432
433           if (! cont)
434             break;
435
436           if (progress)
437             write (STDERR_FILENO, "t", 1);
438
439           err = pthread_create (&ths[empty], &attr, thread_function,
440                                 (void *) starts);
441           if (err != 0)
442             error (EXIT_FAILURE, err, "cannot start thread %lu", starts);
443
444           if (++empty == last)
445             empty = 0;
446
447           if (do_wait)
448             sigwaitinfo (&ss, NULL);
449         }
450
451       /* Do nothing anymore.  On of the threads will terminate the program.  */
452       sigfillset (&ss);
453       sigdelset (&ss, SIGINT);
454       while (1)
455         sigsuspend (&ss);
456     }
457   else
458     {
459       pthread_t ths[toplevel];
460       struct start_info si[toplevel];
461       unsigned int i;
462
463       for (i = 0; i < toplevel; ++i)
464         {
465           unsigned int child_starts = starts / (toplevel - i);
466           unsigned int child_threads = threads / (toplevel - i);
467           int err;
468
469           si[i].starts = child_starts;
470           si[i].threads = child_threads;
471
472           err = pthread_create (&ths[i], &attr, start_threads, &si[i]);
473           if (err != 0)
474             error (EXIT_FAILURE, err, "cannot start thread");
475
476           starts -= child_starts;
477           threads -= child_threads;
478         }
479
480       for (i = 0; i < toplevel; ++i)
481         {
482           int err = pthread_join (ths[i], NULL);
483
484           if (err != 0)
485             error (EXIT_FAILURE, err, "cannot join thread");
486         }
487
488       /* We are done.  */
489       if (progress)
490         write (STDERR_FILENO, "\n", 1);
491
492       if (timing)
493         {
494           struct timespec end_time;
495
496           if (clock_gettime (cl, &end_time) == 0)
497             {
498               end_time.tv_sec -= start_time.tv_sec;
499               end_time.tv_nsec -= start_time.tv_nsec;
500               if (end_time.tv_nsec < 0)
501                 {
502                   end_time.tv_nsec += 1000000000;
503                   --end_time.tv_sec;
504                 }
505
506               printf ("\nRuntime: %lu.%09lu seconds\n",
507                       (unsigned long int) end_time.tv_sec,
508                       (unsigned long int) end_time.tv_nsec);
509             }
510         }
511
512       printf ("Result: %08x\n", sum);
513
514       exit (0);
515     }
516
517   /* NOTREACHED */
518   return 0;
519 }
520
521
522 /* Handle program arguments.  */
523 static error_t
524 parse_opt (int key, char *arg, struct argp_state *state)
525 {
526   unsigned long int num;
527   long int snum;
528
529   switch (key)
530     {
531     case 't':
532       num = strtoul (arg, NULL, 0);
533       if (num < MAX_THREADS)
534         threads = num;
535       else
536         printf ("\
537 number of threads limited to %u; recompile with a higher limit if necessary",
538                 MAX_THREADS);
539       break;
540
541     case 'w':
542       num = strtoul (arg, NULL, 0);
543       if (num <= 100)
544         workload = num;
545       else
546         puts ("workload must be between 0 and 100 percent");
547       break;
548
549     case 'c':
550       workcost = strtoul (arg, NULL, 0);
551       break;
552
553     case 'r':
554       rounds = strtoul (arg, NULL, 0);
555       break;
556
557     case 's':
558       starts = strtoul (arg, NULL, 0);
559       break;
560
561     case 'S':
562       num = strtoul (arg, NULL, 0);
563       if (num >= PTHREAD_STACK_MIN)
564         stacksize = num;
565       else
566         printf ("minimum stack size is %d\n", PTHREAD_STACK_MIN);
567       break;
568
569     case 'g':
570       snum = strtol (arg, NULL, 0);
571       if (snum < 0)
572         printf ("invalid guard size %s\n", arg);
573       else
574         guardsize = snum;
575       break;
576
577     case 'p':
578       progress = true;
579       break;
580
581     case 'T':
582       timing = true;
583       break;
584
585     case OPT_TO_THREAD:
586       to_thread = true;
587       break;
588
589     case OPT_TO_PROCESS:
590       to_thread = false;
591       break;
592
593     case OPT_SYNC_SIGNAL:
594       sync_method = sync_signal;
595       break;
596
597     case OPT_SYNC_JOIN:
598       sync_method = sync_join;
599       break;
600
601     case OPT_TOPLEVEL:
602       num = strtoul (arg, NULL, 0);
603       if (num < MAX_THREADS)
604         toplevel = num;
605       else
606         printf ("\
607 number of threads limited to %u; recompile with a higher limit if necessary",
608                 MAX_THREADS);
609       sync_method = sync_join;
610       break;
611
612     default:
613       return ARGP_ERR_UNKNOWN;
614     }
615
616   return 0;
617 }
618
619
620 static hp_timing_t
621 get_clockfreq (void)
622 {
623   /* We read the information from the /proc filesystem.  It contains at
624      least one line like
625         cpu MHz         : 497.840237
626      or also
627         cpu MHz         : 497.841
628      We search for this line and convert the number in an integer.  */
629   static hp_timing_t result;
630   int fd;
631
632   /* If this function was called before, we know the result.  */
633   if (result != 0)
634     return result;
635
636   fd = open ("/proc/cpuinfo", O_RDONLY);
637   if (__builtin_expect (fd != -1, 1))
638     {
639       /* XXX AFAIK the /proc filesystem can generate "files" only up
640          to a size of 4096 bytes.  */
641       char buf[4096];
642       ssize_t n;
643
644       n = read (fd, buf, sizeof buf);
645       if (__builtin_expect (n, 1) > 0)
646         {
647           char *mhz = memmem (buf, n, "cpu MHz", 7);
648
649           if (__builtin_expect (mhz != NULL, 1))
650             {
651               char *endp = buf + n;
652               int seen_decpoint = 0;
653               int ndigits = 0;
654
655               /* Search for the beginning of the string.  */
656               while (mhz < endp && (*mhz < '0' || *mhz > '9') && *mhz != '\n')
657                 ++mhz;
658
659               while (mhz < endp && *mhz != '\n')
660                 {
661                   if (*mhz >= '0' && *mhz <= '9')
662                     {
663                       result *= 10;
664                       result += *mhz - '0';
665                       if (seen_decpoint)
666                         ++ndigits;
667                     }
668                   else if (*mhz == '.')
669                     seen_decpoint = 1;
670
671                   ++mhz;
672                 }
673
674               /* Compensate for missing digits at the end.  */
675               while (ndigits++ < 6)
676                 result *= 10;
677             }
678         }
679
680       close (fd);
681     }
682
683   return result;
684 }
685
686
687 int
688 clock_getcpuclockid (pid_t pid, clockid_t *clock_id)
689 {
690   /* We don't allow any process ID but our own.  */
691   if (pid != 0 && pid != getpid ())
692     return EPERM;
693
694 #ifdef CLOCK_PROCESS_CPUTIME_ID
695   /* Store the number.  */
696   *clock_id = CLOCK_PROCESS_CPUTIME_ID;
697
698   return 0;
699 #else
700   /* We don't have a timer for that.  */
701   return ENOENT;
702 #endif
703 }
704
705
706 #define HP_TIMING_NOW(Var)      __asm__ __volatile__ ("rdtsc" : "=A" (Var))
707
708 /* Get current value of CLOCK and store it in TP.  */
709 int
710 clock_gettime (clockid_t clock_id, struct timespec *tp)
711 {
712   int retval = -1;
713
714   switch (clock_id)
715     {
716     case CLOCK_PROCESS_CPUTIME_ID:
717       {
718
719         static hp_timing_t freq;
720         hp_timing_t tsc;
721
722         /* Get the current counter.  */
723         HP_TIMING_NOW (tsc);
724
725         if (freq == 0)
726           {
727             freq = get_clockfreq ();
728             if (freq == 0)
729               return EINVAL;
730           }
731
732         /* Compute the seconds.  */
733         tp->tv_sec = tsc / freq;
734
735         /* And the nanoseconds.  This computation should be stable until
736            we get machines with about 16GHz frequency.  */
737         tp->tv_nsec = ((tsc % freq) * UINT64_C (1000000000)) / freq;
738
739         retval = 0;
740       }
741     break;
742
743     default:
744       errno = EINVAL;
745       break;
746     }
747
748   return retval;
749 }