nptl/perf.c

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