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