kernel/tools/testing/selftests/timers/threadtest.c

   1 /* threadtest.c
   2  *              by: john stultz (johnstul@us.ibm.com)
   3  *              (C) Copyright IBM 2004, 2005, 2006, 2012
   4  *              Licensed under the GPLv2
   5  *
   6  *  To build:
   7  *      $ gcc threadtest.c -o threadtest -lrt
   8  *
   9  *   This program is free software: you can redistribute it and/or modify
  10  *   it under the terms of the GNU General Public License as published by
  11  *   the Free Software Foundation, either version 2 of the License, or
  12  *   (at your option) any later version.
  13  *
  14  *   This program is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *   GNU General Public License for more details.
  18  */
  19 #include <stdio.h>
  20 #include <unistd.h>
  21 #include <stdlib.h>
  22 #include <sys/time.h>
  23 #include <pthread.h>
  24 #ifdef KTEST
  25 #include "../kselftest.h"
  26 #else
  27 static inline int ksft_exit_pass(void)
  28 {
  29         exit(0);
  30 }
  31 static inline int ksft_exit_fail(void)
  32 {
  33         exit(1);
  34 }
  35 #endif
  36
  37
  38 /* serializes shared list access */
  39 pthread_mutex_t list_lock = PTHREAD_MUTEX_INITIALIZER;
  40 /* serializes console output */
  41 pthread_mutex_t print_lock = PTHREAD_MUTEX_INITIALIZER;
  42
  43
  44 #define MAX_THREADS 128
  45 #define LISTSIZE 128
  46
  47 int done = 0;
  48
  49 struct timespec global_list[LISTSIZE];
  50 int listcount = 0;
  51
  52
  53 void checklist(struct timespec *list, int size)
  54 {
  55         int i, j;
  56         struct timespec *a, *b;
  57
  58         /* scan the list */
  59         for (i = 0; i < size-1; i++) {
  60                 a = &list[i];
  61                 b = &list[i+1];
  62
  63                 /* look for any time inconsistencies */
  64                 if ((b->tv_sec <= a->tv_sec) &&
  65                         (b->tv_nsec < a->tv_nsec)) {
  66
  67                         /* flag other threads */
  68                         done = 1;
  69
  70                         /*serialize printing to avoid junky output*/
  71                         pthread_mutex_lock(&print_lock);
  72
  73                         /* dump the list */
  74                         printf("\n");
  75                         for (j = 0; j < size; j++) {
  76                                 if (j == i)
  77                                         printf("---------------\n");
  78                                 printf("%lu:%lu\n", list[j].tv_sec, list[j].tv_nsec);
  79                                 if (j == i+1)
  80                                         printf("---------------\n");
  81                         }
  82                         printf("[FAILED]\n");
  83
  84                         pthread_mutex_unlock(&print_lock);
  85                 }
  86         }
  87 }
  88
  89 /* The shared thread shares a global list
  90  * that each thread fills while holding the lock.
  91  * This stresses clock syncronization across cpus.
  92  */
  93 void *shared_thread(void *arg)
  94 {
  95         while (!done) {
  96                 /* protect the list */
  97                 pthread_mutex_lock(&list_lock);
  98
  99                 /* see if we're ready to check the list */
 100                 if (listcount >= LISTSIZE) {
 101                         checklist(global_list, LISTSIZE);
 102                         listcount = 0;
 103                 }
 104                 clock_gettime(CLOCK_MONOTONIC, &global_list[listcount++]);
 105
 106                 pthread_mutex_unlock(&list_lock);
 107         }
 108         return NULL;
 109 }
 110
 111
 112 /* Each independent thread fills in its own
 113  * list. This stresses clock_gettime() lock contention.
 114  */
 115 void *independent_thread(void *arg)
 116 {
 117         struct timespec my_list[LISTSIZE];
 118         int count;
 119
 120         while (!done) {
 121                 /* fill the list */
 122                 for (count = 0; count < LISTSIZE; count++)
 123                         clock_gettime(CLOCK_MONOTONIC, &my_list[count]);
 124                 checklist(my_list, LISTSIZE);
 125         }
 126         return NULL;
 127 }
 128
 129 #define DEFAULT_THREAD_COUNT 8
 130 #define DEFAULT_RUNTIME 30
 131
 132 int main(int argc, char **argv)
 133 {
 134         int thread_count, i;
 135         time_t start, now, runtime;
 136         char buf[255];
 137         pthread_t pth[MAX_THREADS];
 138         int opt;
 139         void *tret;
 140         int ret = 0;
 141         void *(*thread)(void *) = shared_thread;
 142
 143         thread_count = DEFAULT_THREAD_COUNT;
 144         runtime = DEFAULT_RUNTIME;
 145
 146         /* Process arguments */
 147         while ((opt = getopt(argc, argv, "t:n:i")) != -1) {
 148                 switch (opt) {
 149                 case 't':
 150                         runtime = atoi(optarg);
 151                         break;
 152                 case 'n':
 153                         thread_count = atoi(optarg);
 154                         break;
 155                 case 'i':
 156                         thread = independent_thread;
 157                         printf("using independent threads\n");
 158                         break;
 159                 default:
 160                         printf("Usage: %s [-t <secs>] [-n <numthreads>] [-i]\n", argv[0]);
 161                         printf("        -t: time to run\n");
 162                         printf("        -n: number of threads\n");
 163                         printf("        -i: use independent threads\n");
 164                         return -1;
 165                 }
 166         }
 167
 168         if (thread_count > MAX_THREADS)
 169                 thread_count = MAX_THREADS;
 170
 171
 172         setbuf(stdout, NULL);
 173
 174         start = time(0);
 175         strftime(buf, 255, "%a, %d %b %Y %T %z", localtime(&start));
 176         printf("%s\n", buf);
 177         printf("Testing consistency with %i threads for %ld seconds: ", thread_count, runtime);
 178
 179         /* spawn */
 180         for (i = 0; i < thread_count; i++)
 181                 pthread_create(&pth[i], 0, thread, 0);
 182
 183         while (time(&now) < start + runtime) {
 184                 sleep(1);
 185                 if (done) {
 186                         ret = 1;
 187                         strftime(buf, 255, "%a, %d %b %Y %T %z", localtime(&now));
 188                         printf("%s\n", buf);
 189                         goto out;
 190                 }
 191         }
 192         printf("[OK]\n");
 193         done = 1;
 194
 195 out:
 196         /* wait */
 197         for (i = 0; i < thread_count; i++)
 198                 pthread_join(pth[i], &tret);
 199
 200         /* die */
 201         if (ret)
 202                 ksft_exit_fail();
 203         return ksft_exit_pass();
 204 }