/* Copyright (C) 2002-2018 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.

   The GNU C Library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Lesser General Public

   License as published by the Free Software Foundation; either

   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with the GNU C Library; if not, see

   <http://www.gnu.org/licenses/>.  */

#define _GNU_SOURCE	1

#include <argp.h>

#include <error.h>

#include <errno.h>

#include <fcntl.h>

#include <inttypes.h>

#include <limits.h>

#include <pthread.h>

#include <signal.h>

#include <stdbool.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <unistd.h>

#include <sys/param.h>

#include <sys/types.h>

#ifndef MAX_THREADS

# define MAX_THREADS		100000

#endif

#ifndef DEFAULT_THREADS

# define DEFAULT_THREADS	50

#endif

#define OPT_TO_THREAD		300

#define OPT_TO_PROCESS		301

#define OPT_SYNC_SIGNAL		302

#define OPT_SYNC_JOIN		303

#define OPT_TOPLEVEL		304

static const struct argp_option options[] =

  {

    { NULL, 0, NULL, 0, "\

This is a test for threads so we allow ther user to selection the number of \

threads which are used at any one time.  Independently the total number of \

rounds can be selected.  This is the total number of threads which will have \

run when the process terminates:" },

    { "threads", 't', "NUMBER", 0, "Number of threads used at once" },

    { "starts", 's', "NUMBER", 0, "Total number of working threads" },

    { "toplevel", OPT_TOPLEVEL, "NUMBER", 0,

      "Number of toplevel threads which start the other threads; this \

implies --sync-join" },

    { NULL, 0, NULL, 0, "\

Each thread can do one of two things: sleep or do work.  The latter is 100% \

CPU bound.  The work load is the probability a thread does work.  All values \

from zero to 100 (inclusive) are valid.  How often each thread repeats this \

can be determined by the number of rounds.  The work cost determines how long \

each work session (not sleeping) takes.  If it is zero a thread would \

effectively nothing.  By setting the number of rounds to zero the thread \

does no work at all and pure thread creation times can be measured." },

    { "workload", 'w', "PERCENT", 0, "Percentage of time spent working" },

    { "workcost", 'c', "NUMBER", 0,

      "Factor in the cost of each round of working" },

    { "rounds", 'r', "NUMBER", 0, "Number of rounds each thread runs" },

    { NULL, 0, NULL, 0, "\

There are a number of different methods how thread creation can be \

synchronized.  Synchronization is necessary since the number of concurrently \

running threads is limited." },

    { "sync-signal", OPT_SYNC_SIGNAL, NULL, 0,

      "Synchronize using a signal (default)" },

    { "sync-join", OPT_SYNC_JOIN, NULL, 0, "Synchronize using pthread_join" },

    { NULL, 0, NULL, 0, "\

One parameter for each threads execution is the size of the stack.  If this \

parameter is not used the system's default stack size is used.  If many \

threads are used the stack size should be chosen quite small." },

    { "stacksize", 'S', "BYTES", 0, "Size of threads stack" },

    { "guardsize", 'g', "BYTES", 0,

      "Size of stack guard area; must fit into the stack" },

    { NULL, 0, NULL, 0, "Signal options:" },

    { "to-thread", OPT_TO_THREAD, NULL, 0, "Send signal to main thread" },

    { "to-process", OPT_TO_PROCESS, NULL, 0,

      "Send signal to process (default)" },

    { NULL, 0, NULL, 0, "Administrative options:" },

    { "progress", 'p', NULL, 0, "Show signs of progress" },

    { "timing", 'T', NULL, 0,

      "Measure time from startup to the last thread finishing" },

    { NULL, 0, NULL, 0, NULL }

  };

/* Prototype for option handler.  */

static error_t parse_opt (int key, char *arg, struct argp_state *state);

/* Data structure to communicate with argp functions.  */

static struct argp argp =

{

  options, parse_opt

};

static unsigned long int threads = DEFAULT_THREADS;

static unsigned long int workload = 75;

static unsigned long int workcost = 20;

static unsigned long int rounds = 10;

static long int starts = 5000;

static unsigned long int stacksize;

static long int guardsize = -1;

static bool progress;

static bool timing;

static bool to_thread;

static unsigned long int toplevel = 1;

static long int running;

static pthread_mutex_t running_mutex = PTHREAD_MUTEX_INITIALIZER;

static pid_t pid;

static pthread_t tmain;

static clockid_t cl;

static struct timespec start_time;

static pthread_mutex_t sum_mutex = PTHREAD_MUTEX_INITIALIZER;

unsigned int sum;

static enum

  {

    sync_signal,

    sync_join

  }

sync_method;

/* We use 64bit values for the times.  */

typedef unsigned long long int hp_timing_t;

/* Attributes for all created threads.  */

static pthread_attr_t attr;

static void *

work (void *arg)

{

  unsigned long int i;

  unsigned int state = (unsigned long int) arg;

  for (i = 0; i < rounds; ++i)

    {

      /* Determine what to do.  */

      unsigned int rnum;

      /* Uniform distribution.  */

      do

	rnum = rand_r (&state);

      while (rnum >= UINT_MAX - (UINT_MAX % 100));

      rnum %= 100;

      if (rnum < workload)

	{

	  int j;

	  int a[4] = { i, rnum, i + rnum, rnum - i };

	  if (progress)

	    write (STDERR_FILENO, "c", 1);

	  for (j = 0; j < workcost; ++j)

	    {

	      a[0] += a[3] >> 12;

	      a[1] += a[2] >> 20;

	      a[2] += a[1] ^ 0x3423423;

	      a[3] += a[0] - a[1];

	    }

	  pthread_mutex_lock (&sum_mutex);

	  sum += a[0] + a[1] + a[2] + a[3];

	  pthread_mutex_unlock (&sum_mutex);

	}

      else

	{

	  /* Just sleep.  */

	  struct timespec tv;

	  tv.tv_sec = 0;

	  tv.tv_nsec = 10000000;

	  if (progress)

	    write (STDERR_FILENO, "w", 1);

	  nanosleep (&tv, NULL);

	}

    }

  return NULL;

}

static void *

thread_function (void *arg)

{

  work (arg);

  pthread_mutex_lock (&running_mutex);

  if (--running <= 0 && starts <= 0)

    {

      /* We are done.  */

      if (progress)

	write (STDERR_FILENO, "\n", 1);

      if (timing)

	{

	  struct timespec end_time;

	  if (clock_gettime (cl, &end_time) == 0)

	    {

	      end_time.tv_sec -= start_time.tv_sec;

	      end_time.tv_nsec -= start_time.tv_nsec;

	      if (end_time.tv_nsec < 0)

		{

		  end_time.tv_nsec += 1000000000;

		  --end_time.tv_sec;

		}

	      printf ("\nRuntime: %lu.%09lu seconds\n",

		      (unsigned long int) end_time.tv_sec,

		      (unsigned long int) end_time.tv_nsec);

	    }

	}

      printf ("Result: %08x\n", sum);

      exit (0);

    }

  pthread_mutex_unlock (&running_mutex);

  if (sync_method == sync_signal)

    {

      if (to_thread)

	/* This code sends a signal to the main thread.  */

	pthread_kill (tmain, SIGUSR1);

      else

	/* Use this code to test sending a signal to the process.  */

	kill (pid, SIGUSR1);

    }

  if (progress)

    write (STDERR_FILENO, "f", 1);

  return NULL;

}

struct start_info

{

  unsigned int starts;

  unsigned int threads;

};

static void *

start_threads (void *arg)

{

  struct start_info *si = arg;

  unsigned int starts = si->starts;

  pthread_t ths[si->threads];

  unsigned int state = starts;

  unsigned int n;

  unsigned int i = 0;

  int err;

  if (progress)

    write (STDERR_FILENO, "T", 1);

  memset (ths, '\0', sizeof (pthread_t) * si->threads);

  while (starts-- > 0)

    {

      if (ths[i] != 0)

	{

	  /* Wait for the threads in the order they were created.  */

	  err = pthread_join (ths[i], NULL);

	  if (err != 0)

	    error (EXIT_FAILURE, err, "cannot join thread");

	  if (progress)

	    write (STDERR_FILENO, "f", 1);

	}

      err = pthread_create (&ths[i], &attr, work,

			    (void *) (long) (rand_r (&state) + starts + i));

      if (err != 0)

	error (EXIT_FAILURE, err, "cannot start thread");

      if (progress)

	write (STDERR_FILENO, "t", 1);

      if (++i == si->threads)

	i = 0;

    }

  n = i;

  do

    {

      if (ths[i] != 0)

	{

	  err = pthread_join (ths[i], NULL);

	  if (err != 0)

	    error (EXIT_FAILURE, err, "cannot join thread");

	  if (progress)

	    write (STDERR_FILENO, "f", 1);

	}

      if (++i == si->threads)

	i = 0;

    }

  while (i != n);

  if (progress)

    write (STDERR_FILENO, "F", 1);

  return NULL;

}

int

main (int argc, char *argv[])

{

  int remaining;

  sigset_t ss;

  pthread_t th;

  pthread_t *ths = NULL;

  int empty = 0;

  int last;

  bool cont = true;

  /* Parse and process arguments.  */

  argp_parse (&argp, argc, argv, 0, &remaining, NULL);

  if (sync_method == sync_join)

    {

      ths = (pthread_t *) calloc (threads, sizeof (pthread_t));

      if (ths == NULL)

	error (EXIT_FAILURE, errno,

	       "cannot allocate memory for thread descriptor array");

      last = threads;

    }

  else

    {

      ths = &th;

      last = 1;

    }

  if (toplevel > threads)

    {

      printf ("resetting number of toplevel threads to %lu to not surpass number to concurrent threads\n",

	      threads);

      toplevel = threads;

    }

  if (timing)

    {

      if (clock_getcpuclockid (0, &cl) != 0

	  || clock_gettime (cl, &start_time) != 0)

	timing = false;

    }

  /* We need this later.  */

  pid = getpid ();

  tmain = pthread_self ();

  /* We use signal SIGUSR1 for communication between the threads and

     the main thread.  We only want sychronous notification.  */

  if (sync_method == sync_signal)

    {

      sigemptyset (&ss);

      sigaddset (&ss, SIGUSR1);

      if (sigprocmask (SIG_BLOCK, &ss, NULL) != 0)

	error (EXIT_FAILURE, errno, "cannot set signal mask");

    }

  /* Create the thread attributes.  */

  pthread_attr_init (&attr);

  /* If the user provided a stack size use it.  */

  if (stacksize != 0

      && pthread_attr_setstacksize (&attr, stacksize) != 0)

    puts ("could not set stack size; will use default");

  /* And stack guard size.  */

  if (guardsize != -1

      && pthread_attr_setguardsize (&attr, guardsize) != 0)

    puts ("invalid stack guard size; will use default");

  /* All threads are created detached if we are not using pthread_join

     to synchronize.  */

  if (sync_method != sync_join)

    pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);

  if (sync_method == sync_signal)

    {

      while (1)

	{

	  int err;

	  bool do_wait = false;

	  pthread_mutex_lock (&running_mutex);

	  if (starts-- < 0)

	    cont = false;

	  else

	    do_wait = ++running >= threads && starts > 0;

	  pthread_mutex_unlock (&running_mutex);

	  if (! cont)

	    break;

	  if (progress)

	    write (STDERR_FILENO, "t", 1);

	  err = pthread_create (&ths[empty], &attr, thread_function,

				(void *) starts);

	  if (err != 0)

	    error (EXIT_FAILURE, err, "cannot start thread %lu", starts);

	  if (++empty == last)

	    empty = 0;

	  if (do_wait)

	    sigwaitinfo (&ss, NULL);

	}

      /* Do nothing anymore.  On of the threads will terminate the program.  */

      sigfillset (&ss);

      sigdelset (&ss, SIGINT);

      while (1)

	sigsuspend (&ss);

    }

  else

    {

      pthread_t ths[toplevel];

      struct start_info si[toplevel];

      unsigned int i;

      for (i = 0; i < toplevel; ++i)

	{

	  unsigned int child_starts = starts / (toplevel - i);

	  unsigned int child_threads = threads / (toplevel - i);

	  int err;

	  si[i].starts = child_starts;

	  si[i].threads = child_threads;

	  err = pthread_create (&ths[i], &attr, start_threads, &si[i]);

	  if (err != 0)

	    error (EXIT_FAILURE, err, "cannot start thread");

	  starts -= child_starts;

	  threads -= child_threads;

	}

      for (i = 0; i < toplevel; ++i)

	{

	  int err = pthread_join (ths[i], NULL);

	  if (err != 0)

	    error (EXIT_FAILURE, err, "cannot join thread");

	}

      /* We are done.  */

      if (progress)

	write (STDERR_FILENO, "\n", 1);

      if (timing)

	{

	  struct timespec end_time;

	  if (clock_gettime (cl, &end_time) == 0)

	    {

	      end_time.tv_sec -= start_time.tv_sec;

	      end_time.tv_nsec -= start_time.tv_nsec;

	      if (end_time.tv_nsec < 0)

		{

		  end_time.tv_nsec += 1000000000;

		  --end_time.tv_sec;

		}

	      printf ("\nRuntime: %lu.%09lu seconds\n",

		      (unsigned long int) end_time.tv_sec,

		      (unsigned long int) end_time.tv_nsec);

	    }

	}

      printf ("Result: %08x\n", sum);

      exit (0);

    }

  /* NOTREACHED */

  return 0;

}

/* Handle program arguments.  */

static error_t

parse_opt (int key, char *arg, struct argp_state *state)

{

  unsigned long int num;

  long int snum;

  switch (key)

    {

    case 't':

      num = strtoul (arg, NULL, 0);

      if (num <= MAX_THREADS)

	threads = num;

      else

	printf ("\

number of threads limited to %u; recompile with a higher limit if necessary",

		MAX_THREADS);

      break;

    case 'w':

      num = strtoul (arg, NULL, 0);

      if (num <= 100)

	workload = num;

      else

	puts ("workload must be between 0 and 100 percent");

      break;

    case 'c':

      workcost = strtoul (arg, NULL, 0);

      break;

    case 'r':

      rounds = strtoul (arg, NULL, 0);

      break;

    case 's':

      starts = strtoul (arg, NULL, 0);

      break;

    case 'S':

      num = strtoul (arg, NULL, 0);

      if (num >= PTHREAD_STACK_MIN)

	stacksize = num;

      else

	printf ("minimum stack size is %d\n", PTHREAD_STACK_MIN);

      break;

    case 'g':

      snum = strtol (arg, NULL, 0);

      if (snum < 0)

	printf ("invalid guard size %s\n", arg);

      else

	guardsize = snum;

      break;

    case 'p':

      progress = true;

      break;

    case 'T':

      timing = true;

      break;

    case OPT_TO_THREAD:

      to_thread = true;

      break;

    case OPT_TO_PROCESS:

      to_thread = false;

      break;

    case OPT_SYNC_SIGNAL:

      sync_method = sync_signal;

      break;

    case OPT_SYNC_JOIN:

      sync_method = sync_join;

      break;

    case OPT_TOPLEVEL:

      num = strtoul (arg, NULL, 0);

      if (num < MAX_THREADS)

	toplevel = num;

      else

	printf ("\

number of threads limited to %u; recompile with a higher limit if necessary",

		MAX_THREADS);

      sync_method = sync_join;

      break;

    default:

      return ARGP_ERR_UNKNOWN;

    }

  return 0;

}

static hp_timing_t

get_clockfreq (void)

{

  /* We read the information from the /proc filesystem.  It contains at

     least one line like

	cpu MHz         : 497.840237

     or also

	cpu MHz         : 497.841

     We search for this line and convert the number in an integer.  */

  static hp_timing_t result;

  int fd;

  /* If this function was called before, we know the result.  */

  if (result != 0)

    return result;

  fd = open ("/proc/cpuinfo", O_RDONLY);

  if (__glibc_likely (fd != -1))

    {

      /* XXX AFAIK the /proc filesystem can generate "files" only up

         to a size of 4096 bytes.  */

      char buf[4096];

      ssize_t n;

      n = read (fd, buf, sizeof buf);

      if (__builtin_expect (n, 1) > 0)

	{

	  char *mhz = memmem (buf, n, "cpu MHz", 7);

	  if (__glibc_likely (mhz != NULL))

	    {

	      char *endp = buf + n;

	      int seen_decpoint = 0;

	      int ndigits = 0;

	      /* Search for the beginning of the string.  */

	      while (mhz < endp && (*mhz < '0' || *mhz > '9') && *mhz != '\n')

		++mhz;

	      while (mhz < endp && *mhz != '\n')

		{

		  if (*mhz >= '0' && *mhz <= '9')

		    {

		      result *= 10;

		      result += *mhz - '0';

		      if (seen_decpoint)

			++ndigits;

		    }

		  else if (*mhz == '.')

		    seen_decpoint = 1;

		  ++mhz;

		}

	      /* Compensate for missing digits at the end.  */

	      while (ndigits++ < 6)

		result *= 10;

	    }

	}

      close (fd);

    }

  return result;

}

int

clock_getcpuclockid (pid_t pid, clockid_t *clock_id)

{

  /* We don't allow any process ID but our own.  */

  if (pid != 0 && pid != getpid ())

    return EPERM;

#ifdef CLOCK_PROCESS_CPUTIME_ID

  /* Store the number.  */

  *clock_id = CLOCK_PROCESS_CPUTIME_ID;

  return 0;

#else

  /* We don't have a timer for that.  */

  return ENOENT;

#endif

}

#ifdef i386

#define HP_TIMING_NOW(Var)	__asm__ __volatile__ ("rdtsc" : "=A" (Var))

#elif defined __x86_64__

# define HP_TIMING_NOW(Var) \

  ({ unsigned int _hi, _lo; \

     asm volatile ("rdtsc" : "=a" (_lo), "=d" (_hi)); \

     (Var) = ((unsigned long long int) _hi << 32) | _lo; })

#elif defined __ia64__

#define HP_TIMING_NOW(Var)	__asm__ __volatile__ ("mov %0=ar.itc" : "=r" (Var) : : "memory")

#else

#error "HP_TIMING_NOW missing"

#endif

/* Get current value of CLOCK and store it in TP.  */

int

clock_gettime (clockid_t clock_id, struct timespec *tp)

{

  int retval = -1;

  switch (clock_id)

    {

    case CLOCK_PROCESS_CPUTIME_ID:

      {

	static hp_timing_t freq;

	hp_timing_t tsc;

	/* Get the current counter.  */

	HP_TIMING_NOW (tsc);

	if (freq == 0)

	  {

	    freq = get_clockfreq ();

	    if (freq == 0)

	      return EINVAL;

	  }

	/* Compute the seconds.  */

	tp->tv_sec = tsc / freq;

	/* And the nanoseconds.  This computation should be stable until

	   we get machines with about 16GHz frequency.  */

	tp->tv_nsec = ((tsc % freq) * UINT64_C (1000000000)) / freq;

	retval = 0;

      }

    break;

    default:

      errno = EINVAL;

      break;

    }

  return retval;

}