1 /* Copyright (C) 2018-2023 Free Software Foundation, Inc.
2 Contributed by Jakub Jelinek <jakub@redhat.com>.
3
4 This file is part of the GNU Offloading and Multi Processing Library
5 (libgomp).
6
7 Libgomp is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
11
12 Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
14 FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 more details.
16
17 Under Section 7 of GPL version 3, you are granted additional
18 permissions described in the GCC Runtime Library Exception, version
19 3.1, as published by the Free Software Foundation.
20
21 You should have received a copy of the GNU General Public License and
22 a copy of the GCC Runtime Library Exception along with this program;
23 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 <http://www.gnu.org/licenses/>. */
25
26 #include "libgomp.h"
27 #include <string.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #ifdef HAVE_UNISTD_H
31 #include <unistd.h>
32 #endif
33 #ifdef HAVE_INTTYPES_H
34 # include <inttypes.h> /* For PRIx64. */
35 #endif
36 #ifdef HAVE_UNAME
37 #include <sys/utsname.h>
38 #endif
39
40 ialias_redirect (omp_get_team_num)
41 ialias_redirect (omp_get_num_teams)
42
43 bool
44 gomp_print_string (const char *str, size_t len)
45 {
46 return fwrite (str, 1, len, stderr) != len;
47 }
48
49 void
50 gomp_set_affinity_format (const char *format, size_t len)
51 {
52 if (len < gomp_affinity_format_len)
53 memcpy (gomp_affinity_format_var, format, len);
54 else
55 {
56 char *p;
57 if (gomp_affinity_format_len)
58 p = gomp_realloc (gomp_affinity_format_var, len + 1);
59 else
60 p = gomp_malloc (len + 1);
61 memcpy (p, format, len);
62 gomp_affinity_format_var = p;
63 gomp_affinity_format_len = len + 1;
64 }
65 gomp_affinity_format_var[len] = '\0';
66 }
67
68 void
69 omp_set_affinity_format (const char *format)
70 {
71 gomp_set_affinity_format (format, strlen (format));
72 }
73
74 size_t
75 omp_get_affinity_format (char *buffer, size_t size)
76 {
77 size_t len = strlen (gomp_affinity_format_var);
78 if (size)
79 {
80 if (len < size)
81 memcpy (buffer, gomp_affinity_format_var, len + 1);
82 else
83 {
84 memcpy (buffer, gomp_affinity_format_var, size - 1);
85 buffer[size - 1] = '\0';
86 }
87 }
88 return len;
89 }
90
91 void
92 gomp_display_string (char *buffer, size_t size, size_t *ret,
93 const char *str, size_t len)
94 {
95 size_t r = *ret;
96 if (size && r < size)
97 {
98 size_t l = len;
99 if (size - r < len)
100 l = size - r;
101 memcpy (buffer + r, str, l);
102 }
103 *ret += len;
104 if (__builtin_expect (r > *ret, 0))
105 gomp_fatal ("overflow in omp_capture_affinity");
106 }
107
108 static void
109 gomp_display_repeat (char *buffer, size_t size, size_t *ret,
110 char c, size_t len)
111 {
112 size_t r = *ret;
113 if (size && r < size)
114 {
115 size_t l = len;
116 if (size - r < len)
117 l = size - r;
118 memset (buffer + r, c, l);
119 }
120 *ret += len;
121 if (__builtin_expect (r > *ret, 0))
122 gomp_fatal ("overflow in omp_capture_affinity");
123 }
124
125 static void
126 gomp_display_num (char *buffer, size_t size, size_t *ret,
127 bool zero, bool right, size_t sz, char *buf)
128 {
129 size_t l = strlen (buf);
130 if (sz == (size_t) -1 || l >= sz)
131 {
132 gomp_display_string (buffer, size, ret, buf, l);
133 return;
134 }
135 if (zero)
136 {
137 if (buf[0] == '-')
138 gomp_display_string (buffer, size, ret, buf, 1);
139 else if (buf[0] == '0' && buf[1] == 'x')
140 gomp_display_string (buffer, size, ret, buf, 2);
141 gomp_display_repeat (buffer, size, ret, '0', sz - l);
142 if (buf[0] == '-')
143 gomp_display_string (buffer, size, ret, buf + 1, l - 1);
144 else if (buf[0] == '0' && buf[1] == 'x')
145 gomp_display_string (buffer, size, ret, buf + 2, l - 2);
146 else
147 gomp_display_string (buffer, size, ret, buf, l);
148 }
149 else if (right)
150 {
151 gomp_display_repeat (buffer, size, ret, ' ', sz - l);
152 gomp_display_string (buffer, size, ret, buf, l);
153 }
154 else
155 {
156 gomp_display_string (buffer, size, ret, buf, l);
157 gomp_display_repeat (buffer, size, ret, ' ', sz - l);
158 }
159 }
160
161 static void
162 gomp_display_int (char *buffer, size_t size, size_t *ret,
163 bool zero, bool right, size_t sz, int num)
164 {
165 char buf[3 * sizeof (int) + 2];
166 sprintf (buf, "%d", num);
167 gomp_display_num (buffer, size, ret, zero, right, sz, buf);
168 }
169
170 static void
171 gomp_display_string_len (char *buffer, size_t size, size_t *ret,
172 bool right, size_t sz, char *str, size_t len)
173 {
174 if (sz == (size_t) -1 || len >= sz)
175 {
176 gomp_display_string (buffer, size, ret, str, len);
177 return;
178 }
179
180 if (right)
181 {
182 gomp_display_repeat (buffer, size, ret, ' ', sz - len);
183 gomp_display_string (buffer, size, ret, str, len);
184 }
185 else
186 {
187 gomp_display_string (buffer, size, ret, str, len);
188 gomp_display_repeat (buffer, size, ret, ' ', sz - len);
189 }
190 }
191
192 static void
193 gomp_display_hostname (char *buffer, size_t size, size_t *ret,
194 bool right, size_t sz)
195 {
196 #ifdef HAVE_GETHOSTNAME
197 {
198 char buf[256];
199 char *b = buf;
200 size_t len = 256;
201 do
202 {
203 b[len - 1] = '\0';
204 if (gethostname (b, len - 1) == 0)
205 {
206 size_t l = strlen (b);
207 if (l < len - 1)
208 {
209 gomp_display_string_len (buffer, size, ret,
210 right, sz, b, l);
211 if (b != buf)
212 free (b);
213 return;
214 }
215 }
216 if (len == 1048576)
217 break;
218 len = len * 2;
219 if (len == 512)
220 b = gomp_malloc (len);
221 else
222 b = gomp_realloc (b, len);
223 }
224 while (1);
225 if (b != buf)
226 free (b);
227 }
228 #endif
229 #ifdef HAVE_UNAME
230 {
231 struct utsname buf;
232 if (uname (&buf) == 0)
233 {
234 gomp_display_string_len (buffer, size, ret, right, sz,
235 buf.nodename, strlen (buf.nodename));
236 return;
237 }
238 }
239 #endif
240 gomp_display_string_len (buffer, size, ret, right, sz, "node", 4);
241 }
242
243 struct affinity_types_struct {
244 char long_str[18];
245 char long_len;
246 char short_c; };
247
248 static struct affinity_types_struct affinity_types[] =
249 {
250 #define AFFINITY_TYPE(l, s) \
251 { #l, sizeof (#l) - 1, s }
252 AFFINITY_TYPE (team_num, 't'),
253 AFFINITY_TYPE (num_teams, 'T'),
254 AFFINITY_TYPE (nesting_level, 'L'),
255 AFFINITY_TYPE (thread_num, 'n'),
256 AFFINITY_TYPE (num_threads, 'N'),
257 AFFINITY_TYPE (ancestor_tnum, 'a'),
258 AFFINITY_TYPE (host, 'H'),
259 AFFINITY_TYPE (process_id, 'P'),
260 AFFINITY_TYPE (native_thread_id, 'i'),
261 AFFINITY_TYPE (thread_affinity, 'A')
262 #undef AFFINITY_TYPE
263 };
264
265 size_t
266 gomp_display_affinity (char *buffer, size_t size,
267 const char *format, gomp_thread_handle handle,
268 struct gomp_team_state *ts, unsigned int place)
269 {
270 size_t ret = 0;
271 do
272 {
273 const char *p = strchr (format, '%');
274 bool zero = false;
275 bool right = false;
276 size_t sz = -1;
277 char c;
278 int val;
279 if (p == NULL)
280 p = strchr (format, '\0');
281 if (p != format)
282 gomp_display_string (buffer, size, &ret,
283 format, p - format);
284 if (*p == '\0')
285 break;
286 p++;
287 if (*p == '%')
288 {
289 gomp_display_string (buffer, size, &ret, "%", 1);
290 format = p + 1;
291 continue;
292 }
293 if (*p == '0')
294 {
295 zero = true;
296 p++;
297 if (*p != '.')
298 gomp_fatal ("leading zero not followed by dot in affinity format");
299 }
300 if (*p == '.')
301 {
302 right = true;
303 p++;
304 }
305 if (*p >= '1' && *p <= '9')
306 {
307 char *end;
308 sz = strtoul (p, &end, 10);
309 p = end;
310 }
311 else if (zero || right)
312 gomp_fatal ("leading zero or right justification in affinity format "
313 "requires size");
314 c = *p;
315 if (c == '{')
316 {
317 int i;
318 for (i = 0;
319 i < sizeof (affinity_types) / sizeof (affinity_types[0]); ++i)
320 if (strncmp (p + 1, affinity_types[i].long_str,
321 affinity_types[i].long_len) == 0
322 && p[affinity_types[i].long_len + 1] == '}')
323 {
324 c = affinity_types[i].short_c;
325 p += affinity_types[i].long_len + 1;
326 break;
327 }
328 if (c == '{')
329 {
330 char *q = strchr (p + 1, '}');
331 if (q)
332 gomp_fatal ("unsupported long type name '%.*s' in affinity "
333 "format", (int) (q - (p + 1)), p + 1);
334 else
335 gomp_fatal ("unterminated long type name '%s' in affinity "
336 "format", p + 1);
337 }
338 }
339 switch (c)
340 {
341 case 't':
342 val = omp_get_team_num ();
343 goto do_int;
344 case 'T':
345 val = omp_get_num_teams ();
346 goto do_int;
347 case 'L':
348 val = ts->level;
349 goto do_int;
350 case 'n':
351 val = ts->team_id;
352 goto do_int;
353 case 'N':
354 val = ts->team ? ts->team->nthreads : 1;
355 goto do_int;
356 case 'a':
357 val = ts->team ? ts->team->prev_ts.team_id : -1;
358 goto do_int;
359 case 'H':
360 gomp_display_hostname (buffer, size, &ret, right, sz);
361 break;
362 case 'P':
363 #ifdef HAVE_GETPID
364 val = getpid ();
365 #else
366 val = 0;
367 #endif
368 goto do_int;
369 case 'i':
370 #if defined(LIBGOMP_USE_PTHREADS) && defined(__GNUC__)
371 {
372 char buf[3 * (sizeof (handle) + sizeof (uintptr_t) + sizeof (int))
373 + 4];
374 /* This macro returns expr unmodified for integral or pointer
375 types and 0 for anything else (e.g. aggregates). */
376 #define gomp_nonaggregate(expr) \
377 __builtin_choose_expr (__builtin_classify_type (expr) == 1 \
378 || __builtin_classify_type (expr) == 5, expr, 0)
379 /* This macro returns expr unmodified for integral types,
380 (uintptr_t) (expr) for pointer types and 0 for anything else
381 (e.g. aggregates). */
382 #define gomp_integral(expr) \
383 __builtin_choose_expr (__builtin_classify_type (expr) == 5, \
384 (uintptr_t) gomp_nonaggregate (expr), \
385 gomp_nonaggregate (expr))
386
387 if (sizeof (gomp_integral (handle)) == sizeof (unsigned long))
388 sprintf (buf, "0x%lx", (unsigned long) gomp_integral (handle));
389 #if defined (HAVE_INTTYPES_H) && defined (PRIx64)
390 else if (sizeof (gomp_integral (handle)) == sizeof (uint64_t))
391 sprintf (buf, "0x%" PRIx64, (uint64_t) gomp_integral (handle));
392 #else
393 else if (sizeof (gomp_integral (handle))
394 == sizeof (unsigned long long))
395 sprintf (buf, "0x%llx",
396 (unsigned long long) gomp_integral (handle));
397 #endif
398 else
399 sprintf (buf, "0x%x", (unsigned int) gomp_integral (handle));
400 gomp_display_num (buffer, size, &ret, zero, right, sz, buf);
401 break;
402 }
403 #else
404 val = 0;
405 goto do_int;
406 #endif
407 case 'A':
408 if (sz == (size_t) -1)
409 gomp_display_affinity_place (buffer, size, &ret,
410 place - 1);
411 else if (right)
412 {
413 size_t len = 0;
414 gomp_display_affinity_place (NULL, 0, &len, place - 1);
415 if (len < sz)
416 gomp_display_repeat (buffer, size, &ret, ' ', sz - len);
417 gomp_display_affinity_place (buffer, size, &ret, place - 1);
418 }
419 else
420 {
421 size_t start = ret;
422 gomp_display_affinity_place (buffer, size, &ret, place - 1);
423 if (ret - start < sz)
424 gomp_display_repeat (buffer, size, &ret, ' ', sz - (ret - start));
425 }
426 break;
427 do_int:
428 gomp_display_int (buffer, size, &ret, zero, right, sz, val);
429 break;
430 default:
431 gomp_fatal ("unsupported type %c in affinity format", c);
432 }
433 format = p + 1;
434 }
435 while (1);
436 return ret;
437 }
438
439 size_t
440 omp_capture_affinity (char *buffer, size_t size, const char *format)
441 {
442 struct gomp_thread *thr = gomp_thread ();
443 size_t ret
444 = gomp_display_affinity (buffer, size,
445 format && *format
446 ? format : gomp_affinity_format_var,
447 gomp_thread_self (), &thr->ts, thr->place);
448 if (size)
449 {
450 if (ret >= size)
451 buffer[size - 1] = '\0';
452 else
453 buffer[ret] = '\0';
454 }
455 return ret;
456 }
457 ialias (omp_capture_affinity)
458
459 void
460 omp_display_affinity (const char *format)
461 {
462 char buf[512];
463 char *b;
464 size_t ret = ialias_call (omp_capture_affinity) (buf, sizeof buf, format);
465 if (ret < sizeof buf)
466 {
467 buf[ret] = '\n';
468 gomp_print_string (buf, ret + 1);
469 return;
470 }
471 b = gomp_malloc (ret + 1);
472 ialias_call (omp_capture_affinity) (b, ret + 1, format);
473 b[ret] = '\n';
474 gomp_print_string (b, ret + 1);
475 free (b);
476 }
477
478 void
479 gomp_display_affinity_thread (gomp_thread_handle handle,
480 struct gomp_team_state *ts, unsigned int place)
481 {
482 char buf[512];
483 char *b;
484 size_t ret = gomp_display_affinity (buf, sizeof buf, gomp_affinity_format_var,
485 handle, ts, place);
486 if (ret < sizeof buf)
487 {
488 buf[ret] = '\n';
489 gomp_print_string (buf, ret + 1);
490 return;
491 }
492 b = gomp_malloc (ret + 1);
493 gomp_display_affinity (b, ret + 1, gomp_affinity_format_var,
494 handle, ts, place);
495 b[ret] = '\n';
496 gomp_print_string (b, ret + 1);
497 free (b);
498 }