1 /* Test program for process and thread CPU clocks.
2 Copyright (C) 2005-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library 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 GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19 #include <unistd.h>
20 #include <stdint.h>
21
22 #if (_POSIX_THREADS - 0) <= 0
23
24 static int
25 do_test ()
26 {
27 return 0;
28 }
29
30 #else
31
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <time.h>
35 #include <fcntl.h>
36 #include <string.h>
37 #include <errno.h>
38 #include <pthread.h>
39
40 #include <support/xunistd.h>
41
42 static pthread_barrier_t barrier;
43
44 /* This function is intended to rack up both user and system time. */
45 static void *
46 chew_cpu (void *arg)
47 {
48 pthread_barrier_wait (&barrier);
49
50 while (1)
51 {
52 static volatile char buf[4096];
53 for (int i = 0; i < 100; ++i)
54 for (size_t j = 0; j < sizeof buf; ++j)
55 buf[j] = 0xaa;
56 int nullfd = open ("/dev/null", O_WRONLY);
57 for (int i = 0; i < 100; ++i)
58 for (size_t j = 0; j < sizeof buf; ++j)
59 buf[j] = 0xbb;
60 xwrite (nullfd, (char *) buf, sizeof buf);
61 close (nullfd);
62 }
63
64 return NULL;
65 }
66
67 static void
68 test_nanosleep (clockid_t clock, const char *which,
69 int *bad)
70 {
71 const struct timespec sleeptime = { .tv_nsec = 100000000 };
72 int e = clock_nanosleep (clock, 0, &sleeptime, NULL);
73 if (e == EINVAL || e == ENOTSUP || e == ENOSYS)
74 {
75 printf ("clock_nanosleep not supported for %s CPU clock: %s\n",
76 which, strerror (e));
77 return;
78 }
79 if (e != 0)
80 {
81 printf ("clock_nanosleep on %s CPU clock: %s\n", which, strerror (e));
82 *bad = 1;
83 return;
84 }
85
86 struct timespec after;
87 if (clock_gettime (clock, &after) < 0)
88 {
89 printf ("clock_gettime on %s CPU clock %lx => %s\n",
90 which, (unsigned long int) clock, strerror (errno));
91 *bad = 1;
92 return;
93 }
94
95 struct timespec sleeptimeabs = sleeptime;
96 sleeptimeabs.tv_sec += after.tv_sec;
97 sleeptimeabs.tv_nsec += after.tv_nsec;
98 while (sleeptimeabs.tv_nsec >= 1000000000)
99 {
100 ++sleeptimeabs.tv_sec;
101 sleeptimeabs.tv_nsec -= 1000000000;
102 }
103 e = clock_nanosleep (clock, TIMER_ABSTIME, &sleeptimeabs, NULL);
104 if (e != 0)
105 {
106 printf ("absolute clock_nanosleep on %s CPU clock: %s\n",
107 which, strerror (e));
108 *bad = 1;
109 return;
110 }
111
112 struct timespec afterabs;
113 if (clock_gettime (clock, &afterabs) < 0)
114 {
115 printf ("clock_gettime on %s CPU clock %lx => %s\n",
116 which, (unsigned long int) clock, strerror (errno));
117 *bad = 1;
118 return;
119 }
120
121 return;
122 }
123
124
125
126 static int
127 do_test (void)
128 {
129 int result = 0;
130 clockid_t process_clock, th_clock, my_thread_clock;
131 int e;
132 pthread_t th;
133
134 e = clock_getcpuclockid (0, &process_clock);
135 if (e != 0)
136 {
137 printf ("clock_getcpuclockid on self => %s\n", strerror (e));
138 return 1;
139 }
140
141 e = pthread_getcpuclockid (pthread_self (), &my_thread_clock);
142 if (e != 0)
143 {
144 printf ("pthread_getcpuclockid on self => %s\n", strerror (e));
145 return 1;
146 }
147
148 /* This is a kludge. This test fails if the semantics of thread and
149 process clocks are wrong. The old code using hp-timing without kernel
150 support has bogus semantics if there are context switches. We don't
151 fail to report failure when the proper functionality is not available
152 in the kernel. It so happens that Linux kernels without correct CPU
153 clock support also lack CPU timer support, so we use use that to guess
154 that we are using the bogus code and not test it. */
155 timer_t t;
156 if (timer_create (my_thread_clock, NULL, &t) != 0)
157 {
158 printf ("timer_create: %m\n");
159 puts ("No support for CPU clocks with good semantics, skipping test");
160 return 0;
161 }
162 timer_delete (t);
163
164
165 pthread_barrier_init (&barrier, NULL, 2);
166
167 e = pthread_create (&th, NULL, chew_cpu, NULL);
168 if (e != 0)
169 {
170 printf ("pthread_create: %s\n", strerror (e));
171 return 1;
172 }
173
174 e = pthread_getcpuclockid (th, &th_clock);
175 if (e == ENOENT || e == ENOSYS || e == ENOTSUP)
176 {
177 puts ("pthread_getcpuclockid does not support other threads");
178 return 1;
179 }
180
181 pthread_barrier_wait (&barrier);
182
183 struct timespec res;
184 if (clock_getres (th_clock, &res) < 0)
185 {
186 printf ("clock_getres on live thread clock %lx => %s\n",
187 (unsigned long int) th_clock, strerror (errno));
188 result = 1;
189 return 1;
190 }
191 printf ("live thread clock %lx resolution %ju.%.9ju\n",
192 (unsigned long int) th_clock,
193 (uintmax_t) res.tv_sec, (uintmax_t) res.tv_nsec);
194
195 struct timespec process_before, process_after;
196 if (clock_gettime (process_clock, &process_before) < 0)
197 {
198 printf ("clock_gettime on process clock %lx => %s\n",
199 (unsigned long int) process_clock, strerror (errno));
200 return 1;
201 }
202
203 struct timespec before, after;
204 if (clock_gettime (th_clock, &before) < 0)
205 {
206 printf ("clock_gettime on live thread clock %lx => %s\n",
207 (unsigned long int) th_clock, strerror (errno));
208 return 1;
209 }
210 printf ("live thread before sleep => %ju.%.9ju\n",
211 (uintmax_t) before.tv_sec, (uintmax_t) before.tv_nsec);
212
213 struct timespec me_before, me_after;
214 if (clock_gettime (my_thread_clock, &me_before) < 0)
215 {
216 printf ("clock_gettime on self thread clock %lx => %s\n",
217 (unsigned long int) my_thread_clock, strerror (errno));
218 return 1;
219 }
220 printf ("self thread before sleep => %ju.%.9ju\n",
221 (uintmax_t) me_before.tv_sec, (uintmax_t) me_before.tv_nsec);
222
223 struct timespec sleeptime = { .tv_nsec = 500000000 };
224 if (nanosleep (&sleeptime, NULL) != 0)
225 {
226 perror ("nanosleep");
227 return 1;
228 }
229
230 if (clock_gettime (th_clock, &after) < 0)
231 {
232 printf ("clock_gettime on live thread clock %lx => %s\n",
233 (unsigned long int) th_clock, strerror (errno));
234 return 1;
235 }
236 printf ("live thread after sleep => %ju.%.9ju\n",
237 (uintmax_t) after.tv_sec, (uintmax_t) after.tv_nsec);
238
239 if (clock_gettime (process_clock, &process_after) < 0)
240 {
241 printf ("clock_gettime on process clock %lx => %s\n",
242 (unsigned long int) process_clock, strerror (errno));
243 return 1;
244 }
245
246 if (clock_gettime (my_thread_clock, &me_after) < 0)
247 {
248 printf ("clock_gettime on self thread clock %lx => %s\n",
249 (unsigned long int) my_thread_clock, strerror (errno));
250 return 1;
251 }
252 printf ("self thread after sleep => %ju.%.9ju\n",
253 (uintmax_t) me_after.tv_sec, (uintmax_t) me_after.tv_nsec);
254
255 test_nanosleep (th_clock, "live thread",
256 &result);
257 test_nanosleep (process_clock, "process",
258 &result);
259 test_nanosleep (CLOCK_PROCESS_CPUTIME_ID,
260 "PROCESS_CPUTIME_ID", &result);
261
262 pthread_cancel (th);
263
264 e = clock_nanosleep (CLOCK_THREAD_CPUTIME_ID, 0, &sleeptime, NULL);
265 if (e != EINVAL)
266 {
267 printf ("clock_nanosleep CLOCK_THREAD_CPUTIME_ID: %s\n",
268 strerror (e));
269 result = 1;
270 }
271
272 return result;
273 }
274 #endif
275
276 #include <support/test-driver.c>