]>
Commit | Line | Data |
---|---|---|
84060bad RM |
1 | /* Test program for process and thread CPU clocks. |
2 | Copyright (C) 2005 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, write to the Free | |
17 | Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA | |
18 | 02111-1307 USA. */ | |
19 | ||
20 | #include <unistd.h> | |
21 | ||
22 | #if (_POSIX_THREADS - 0) <= 0 | |
23 | ||
24 | # define TEST_FUNCTION 0 | |
25 | ||
26 | #else | |
27 | ||
28 | #include <stdio.h> | |
29 | #include <stdlib.h> | |
30 | #include <time.h> | |
31 | #include <fcntl.h> | |
32 | #include <string.h> | |
33 | #include <errno.h> | |
34 | #include <pthread.h> | |
35 | ||
36 | static pthread_barrier_t barrier; | |
37 | ||
38 | /* This function is intended to rack up both user and system time. */ | |
39 | static void * | |
40 | chew_cpu (void *arg) | |
41 | { | |
42 | pthread_barrier_wait (&barrier); | |
43 | ||
44 | while (1) | |
45 | { | |
46 | static volatile char buf[4096]; | |
47 | for (int i = 0; i < 100; ++i) | |
48 | for (size_t j = 0; j < sizeof buf; ++j) | |
49 | buf[j] = 0xaa; | |
50 | int nullfd = open ("/dev/null", O_WRONLY); | |
51 | for (int i = 0; i < 100; ++i) | |
52 | for (size_t j = 0; j < sizeof buf; ++j) | |
53 | buf[j] = 0xbb; | |
54 | write (nullfd, (char *) buf, sizeof buf); | |
55 | close (nullfd); | |
56 | } | |
57 | ||
58 | return NULL; | |
59 | } | |
60 | ||
61 | static unsigned long long int | |
62 | tsdiff (const struct timespec *before, const struct timespec *after) | |
63 | { | |
64 | struct timespec diff = { .tv_sec = after->tv_sec - before->tv_sec, | |
65 | .tv_nsec = after->tv_nsec - before->tv_nsec }; | |
66 | while (diff.tv_nsec < 0) | |
67 | { | |
68 | --diff.tv_sec; | |
69 | diff.tv_nsec += 1000000000; | |
70 | } | |
71 | return diff.tv_sec * 1000000000ULL + diff.tv_nsec; | |
72 | } | |
73 | ||
74 | static unsigned long long int | |
75 | test_nanosleep (clockid_t clock, const char *which, | |
76 | const struct timespec *before, int *bad) | |
77 | { | |
78 | const struct timespec sleeptime = { .tv_nsec = 100000000 }; | |
79 | int e = clock_nanosleep (clock, 0, &sleeptime, NULL); | |
80 | if (e == EINVAL || e == ENOTSUP || e == ENOSYS) | |
81 | { | |
82 | printf ("clock_nanosleep not supported for %s CPU clock: %s\n", | |
83 | which, strerror (e)); | |
84 | return 0; | |
85 | } | |
86 | if (e != 0) | |
87 | { | |
88 | printf ("clock_nanosleep on %s CPU clock: %s\n", which, strerror (e)); | |
89 | *bad = 1; | |
90 | return 0; | |
91 | } | |
92 | ||
93 | struct timespec after; | |
94 | if (clock_gettime (clock, &after) < 0) | |
95 | { | |
96 | printf ("clock_gettime on %s CPU clock %lx => %s\n", | |
97 | which, (unsigned long int) clock, strerror (errno)); | |
98 | *bad = 1; | |
99 | return 0; | |
100 | } | |
101 | ||
102 | unsigned long long int diff = tsdiff (before, &after); | |
103 | if (diff < sleeptime.tv_nsec || diff > sleeptime.tv_nsec * 2) | |
104 | { | |
105 | printf ("clock_nanosleep on %s slept %llu (outside reasonable range)\n", | |
106 | which, diff); | |
107 | *bad = 1; | |
108 | return diff; | |
109 | } | |
110 | ||
111 | struct timespec sleeptimeabs = sleeptime; | |
112 | sleeptimeabs.tv_sec += after.tv_sec; | |
113 | sleeptimeabs.tv_nsec += after.tv_nsec; | |
114 | while (sleeptimeabs.tv_nsec > 1000000000) | |
115 | { | |
116 | ++sleeptimeabs.tv_sec; | |
117 | sleeptimeabs.tv_nsec -= 1000000000; | |
118 | } | |
119 | e = clock_nanosleep (clock, TIMER_ABSTIME, &sleeptimeabs, NULL); | |
120 | if (e != 0) | |
121 | { | |
122 | printf ("absolute clock_nanosleep on %s CPU clock: %s\n", | |
123 | which, strerror (e)); | |
124 | *bad = 1; | |
125 | return diff; | |
126 | } | |
127 | ||
128 | struct timespec afterabs; | |
129 | if (clock_gettime (clock, &afterabs) < 0) | |
130 | { | |
131 | printf ("clock_gettime on %s CPU clock %lx => %s\n", | |
132 | which, (unsigned long int) clock, strerror (errno)); | |
133 | *bad = 1; | |
134 | return diff; | |
135 | } | |
136 | ||
137 | unsigned long long int sleepdiff = tsdiff (&sleeptimeabs, &afterabs); | |
138 | if (sleepdiff > sleeptime.tv_nsec) | |
139 | { | |
140 | printf ("\ | |
141 | absolute clock_nanosleep on %s %llu past target (outside reasonable range)\n", | |
142 | which, sleepdiff); | |
143 | *bad = 1; | |
144 | } | |
145 | ||
146 | unsigned long long int diffabs = tsdiff (&after, &afterabs); | |
147 | if (diffabs < sleeptime.tv_nsec || diffabs > sleeptime.tv_nsec * 2) | |
148 | { | |
149 | printf ("\ | |
150 | absolute clock_nanosleep on %s slept %llu (outside reasonable range)\n", | |
151 | which, diffabs); | |
152 | *bad = 1; | |
153 | } | |
154 | ||
155 | return diff + diffabs; | |
156 | } | |
157 | ||
158 | ||
159 | ||
160 | static int | |
161 | do_test (void) | |
162 | { | |
163 | int result = 0; | |
164 | clockid_t process_clock, th_clock, my_thread_clock; | |
165 | int e; | |
166 | pthread_t th; | |
167 | ||
168 | e = clock_getcpuclockid (0, &process_clock); | |
169 | if (e != 0) | |
170 | { | |
171 | printf ("clock_getcpuclockid on self => %s\n", strerror (e)); | |
172 | return 1; | |
173 | } | |
174 | ||
175 | e = pthread_getcpuclockid (pthread_self (), &my_thread_clock); | |
176 | if (e != 0) | |
177 | { | |
178 | printf ("pthread_getcpuclockid on self => %s\n", strerror (e)); | |
179 | return 1; | |
180 | } | |
181 | ||
182 | /* This is a kludge. This test fails if the semantics of thread and | |
183 | process clocks are wrong. The old code using hp-timing without kernel | |
184 | support has bogus semantics if there are context switches. We don't | |
185 | fail to report failure when the proper functionality is not available | |
186 | in the kernel. It so happens that Linux kernels without correct CPU | |
187 | clock support also lack CPU timer support, so we use use that to guess | |
188 | that we are using the bogus code and not test it. */ | |
189 | timer_t t; | |
190 | if (timer_create (my_thread_clock, NULL, &t) != 0) | |
191 | { | |
192 | printf ("timer_create: %m\n"); | |
193 | puts ("No support for CPU clocks with good semantics, skipping test"); | |
194 | return 0; | |
195 | } | |
196 | timer_delete (t); | |
197 | ||
198 | ||
199 | pthread_barrier_init (&barrier, NULL, 2); | |
200 | ||
201 | e = pthread_create (&th, NULL, chew_cpu, NULL); | |
202 | if (e != 0) | |
203 | { | |
204 | printf ("pthread_create: %s\n", strerror (e)); | |
205 | return 1; | |
206 | } | |
207 | ||
208 | e = pthread_getcpuclockid (th, &th_clock); | |
209 | if (e == ENOENT || e == ENOSYS || e == ENOTSUP) | |
210 | { | |
211 | puts ("pthread_getcpuclockid does not support other threads"); | |
212 | return 1; | |
213 | } | |
214 | ||
215 | pthread_barrier_wait (&barrier); | |
216 | ||
217 | struct timespec res; | |
218 | if (clock_getres (th_clock, &res) < 0) | |
219 | { | |
220 | printf ("clock_getres on thread clock %lx => %s\n", | |
221 | (unsigned long int) th_clock, strerror (errno)); | |
222 | result = 1; | |
223 | return 1; | |
224 | } | |
225 | printf ("live thread clock %lx resolution %lu.%.9lu\n", | |
226 | (unsigned long int) th_clock, res.tv_sec, res.tv_nsec); | |
227 | ||
228 | struct timespec process_before, process_after; | |
229 | if (clock_gettime (process_clock, &process_before) < 0) | |
230 | { | |
231 | printf ("clock_gettime on process clock %lx => %s\n", | |
232 | (unsigned long int) th_clock, strerror (errno)); | |
233 | return 1; | |
234 | } | |
235 | ||
236 | struct timespec before, after; | |
237 | if (clock_gettime (th_clock, &before) < 0) | |
238 | { | |
239 | printf ("clock_gettime on live thread clock %lx => %s\n", | |
240 | (unsigned long int) th_clock, strerror (errno)); | |
241 | return 1; | |
242 | } | |
243 | printf ("live thread before sleep => %lu.%.9lu\n", | |
244 | before.tv_sec, before.tv_nsec); | |
245 | ||
246 | struct timespec me_before, me_after; | |
247 | if (clock_gettime (my_thread_clock, &me_before) < 0) | |
248 | { | |
249 | printf ("clock_gettime on live thread clock %lx => %s\n", | |
250 | (unsigned long int) th_clock, strerror (errno)); | |
251 | return 1; | |
252 | } | |
253 | printf ("self thread before sleep => %lu.%.9lu\n", | |
254 | me_before.tv_sec, me_before.tv_nsec); | |
255 | ||
256 | struct timespec sleeptime = { .tv_nsec = 500000000 }; | |
257 | nanosleep (&sleeptime, NULL); | |
258 | ||
259 | if (clock_gettime (th_clock, &after) < 0) | |
260 | { | |
261 | printf ("clock_gettime on live thread clock %lx => %s\n", | |
262 | (unsigned long int) th_clock, strerror (errno)); | |
263 | return 1; | |
264 | } | |
265 | printf ("live thread after sleep => %lu.%.9lu\n", | |
266 | after.tv_sec, after.tv_nsec); | |
267 | ||
268 | if (clock_gettime (process_clock, &process_after) < 0) | |
269 | { | |
270 | printf ("clock_gettime on process clock %lx => %s\n", | |
271 | (unsigned long int) th_clock, strerror (errno)); | |
272 | return 1; | |
273 | } | |
274 | ||
275 | if (clock_gettime (my_thread_clock, &me_after) < 0) | |
276 | { | |
277 | printf ("clock_gettime on live thread clock %lx => %s\n", | |
278 | (unsigned long int) th_clock, strerror (errno)); | |
279 | return 1; | |
280 | } | |
281 | printf ("self thread after sleep => %lu.%.9lu\n", | |
282 | me_after.tv_sec, me_after.tv_nsec); | |
283 | ||
284 | unsigned long long int th_diff = tsdiff (&before, &after); | |
285 | unsigned long long int pdiff = tsdiff (&process_before, &process_after); | |
286 | unsigned long long int my_diff = tsdiff (&me_before, &me_after); | |
287 | ||
288 | if (th_diff < 100000000 || th_diff > 600000000) | |
289 | { | |
290 | printf ("thread before - after %llu outside reasonable range\n", | |
291 | th_diff); | |
292 | result = 1; | |
293 | } | |
294 | ||
295 | if (my_diff > 100000000) | |
296 | { | |
297 | printf ("self thread before - after %llu outside reasonable range\n", | |
298 | my_diff); | |
299 | result = 1; | |
300 | } | |
301 | ||
302 | if (pdiff < th_diff) | |
303 | { | |
304 | printf ("process before - after %llu outside reasonable range (%llu)\n", | |
305 | pdiff, th_diff); | |
306 | result = 1; | |
307 | } | |
308 | ||
309 | process_after.tv_nsec += test_nanosleep (th_clock, "thread", | |
310 | &after, &result); | |
311 | process_after.tv_nsec += test_nanosleep (process_clock, "process", | |
312 | &process_after, &result); | |
313 | test_nanosleep (CLOCK_PROCESS_CPUTIME_ID, | |
314 | "PROCESS_CPUTIME_ID", &process_after, &result); | |
315 | ||
316 | pthread_cancel (th); | |
317 | ||
318 | e = clock_nanosleep (CLOCK_THREAD_CPUTIME_ID, 0, &sleeptime, NULL); | |
319 | if (e != EINVAL) | |
320 | { | |
321 | printf ("clock_nanosleep CLOCK_THREAD_CPUTIME_ID: %s\n", | |
322 | strerror (e)); | |
323 | result = 1; | |
324 | } | |
325 | ||
326 | return result; | |
327 | } | |
328 | # define TIMEOUT 8 | |
329 | # define TEST_FUNCTION do_test () | |
330 | #endif | |
331 | ||
332 | #include "../test-skeleton.c" |