1 /* This testcase is part of GDB, the GNU debugger. 2 3 Copyright 2015-2016 Free Software Foundation, Inc. 4 5 This program is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 3 of the License, or 8 (at your option) any later version. 9 10 This program 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 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 17 18 #define _GNU_SOURCE 19 #include <assert.h> 20 #include <pthread.h> 21 #include <stdlib.h> 22 #include <unistd.h> 23 #include <stdio.h> 24 #include <limits.h> 25 26 /* How many threads fit in the target's thread number space. */ 27 long tid_max = -1; 28 29 /* Number of threads spawned. */ 30 unsigned long thread_counter; 31 32 /* How long it takes to spawn as many threads as fits in the thread 33 number space. On systems where thread IDs are just monotonically 34 incremented, this is enough for the tid numbers to wrap around. On 35 targets that randomize thread IDs, this is enough time to give each 36 number in the thread number space some chance of reuse. It'll be 37 capped to a lower value if we can't compute it. */ 38 unsigned int reuse_time = -1; 39 40 void * 41 do_nothing_thread_func (void *arg) 42 { 43 usleep (1); 44 return NULL; 45 } 46 47 void * 48 spawner_thread_func (void *arg) 49 { 50 while (1) 51 { 52 pthread_t child; 53 int rc; 54 55 thread_counter++; 56 57 rc = pthread_create (&child, NULL, do_nothing_thread_func, NULL); 58 assert (rc == 0); 59 60 rc = pthread_join (child, NULL); 61 assert (rc == 0); 62 } 63 64 return NULL; 65 } 66 67 /* Called after the program is done counting number of spawned threads 68 for a period, to compute REUSE_TIME. */ 69 70 void 71 after_count (void) 72 { 73 } 74 75 /* Called after enough time has passed for TID reuse to occur. */ 76 77 void 78 after_reuse_time (void) 79 { 80 } 81 82 #ifdef __linux__ 83 84 /* Get the running system's configured pid_max. */ 85 86 static int 87 linux_proc_get_pid_max (void) 88 { 89 static const char filename[] ="/proc/sys/kernel/pid_max"; 90 FILE *file; 91 char buf[100]; 92 int retval = -1; 93 94 file = fopen (filename, "r"); 95 if (file == NULL) 96 { 97 fprintf (stderr, "unable to open %s\n", filename); 98 return -1; 99 } 100 101 if (fgets (buf, sizeof (buf), file) != NULL) 102 retval = strtol (buf, NULL, 10); 103 104 fclose (file); 105 return retval; 106 } 107 108 #endif 109 110 int 111 main (int argc, char *argv[]) 112 { 113 pthread_t child; 114 int rc; 115 unsigned int reuse_time_raw = 0; 116 117 rc = pthread_create (&child, NULL, spawner_thread_func, NULL); 118 assert (rc == 0); 119 120 #define COUNT_TIME 2 121 sleep (COUNT_TIME); 122 123 #ifdef __linux__ 124 tid_max = linux_proc_get_pid_max (); 125 #endif 126 /* If we don't know how many threads it would take to use the whole 127 number space on this system, just run the test for a bit. */ 128 if (tid_max > 0) 129 { 130 reuse_time_raw = tid_max / ((float) thread_counter / COUNT_TIME) + 0.5; 131 132 /* Give it a bit more, just in case. */ 133 reuse_time = reuse_time_raw + 3; 134 } 135 136 /* 4 seconds were sufficient on the machine this was first observed, 137 an Intel i7-2620M @ 2.70GHz running Linux 3.18.7, with 138 pid_max=32768. Going forward, as machines get faster, this will 139 need less time, unless pid_max is set to a very high number. To 140 avoid unreasonably long test time, cap to an upper bound. */ 141 if (reuse_time > 60) 142 reuse_time = 60; 143 printf ("thread_counter=%lu, tid_max = %ld, reuse_time_raw=%u, reuse_time=%u\n", 144 thread_counter, tid_max, reuse_time_raw, reuse_time); 145 after_count (); 146 147 sleep (reuse_time); 148 149 after_reuse_time (); 150 return 0; 151 } 152