1/*
2 * kmp_utility.cpp -- Utility routines for the OpenMP support library.
3 */
4
5//===----------------------------------------------------------------------===//
6//
7// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
8// See https://llvm.org/LICENSE.txt for license information.
9// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
10//
11//===----------------------------------------------------------------------===//
12
13#include "kmp.h"
14#include "kmp_i18n.h"
15#include "kmp_str.h"
16#include "kmp_wrapper_getpid.h"
17#include <float.h>
18
19static const char *unknown = "unknown";
20
21#if KMP_ARCH_X86 || KMP_ARCH_X86_64
22
23/* NOTE: If called before serial_initialize (i.e. from runtime_initialize), then
24 the debugging package has not been initialized yet, and only "0" will print
25 debugging output since the environment variables have not been read. */
26
27#ifdef KMP_DEBUG
28static int trace_level = 5;
29#endif
30
31static kmp_uint64 __kmp_parse_frequency( // R: Frequency in Hz.
32 char const *frequency // I: Float number and unit: MHz, GHz, or TGz.
33) {
34
35 double value = 0.0;
36 char *unit = NULL;
37 kmp_uint64 result = 0; /* Zero is a better unknown value than all ones. */
38
39 if (frequency == NULL) {
40 return result;
41 }
42 value = strtod(nptr: frequency, endptr: &unit);
43 if (0 < value &&
44 value <= DBL_MAX) { // Good value (not overflow, underflow, etc).
45 if (strcmp(s1: unit, s2: "MHz") == 0) {
46 value = value * 1.0E+6;
47 } else if (strcmp(s1: unit, s2: "GHz") == 0) {
48 value = value * 1.0E+9;
49 } else if (strcmp(s1: unit, s2: "THz") == 0) {
50 value = value * 1.0E+12;
51 } else { // Wrong unit.
52 return result;
53 }
54 result = (kmp_uint64)value; // rounds down
55 }
56 return result;
57
58} // func __kmp_parse_cpu_frequency
59
60void __kmp_query_cpuid(kmp_cpuinfo_t *p) {
61 struct kmp_cpuid buf;
62 int max_arg;
63#ifdef KMP_DEBUG
64 int cflush_size;
65#endif
66
67 p->initialized = 1;
68
69 p->flags.sse2 = 1; // Assume SSE2 by default.
70
71 __kmp_x86_cpuid(leaf: 0, subleaf: 0, p: &buf);
72
73 KA_TRACE(trace_level,
74 ("INFO: CPUID %d: EAX=0x%08X EBX=0x%08X ECX=0x%08X EDX=0x%08X\n", 0,
75 buf.eax, buf.ebx, buf.ecx, buf.edx));
76
77 max_arg = buf.eax;
78
79 p->apic_id = -1;
80
81 if (max_arg >= 1) {
82 int i;
83 kmp_uint32 t, data[4];
84
85 __kmp_x86_cpuid(leaf: 1, subleaf: 0, p: &buf);
86 KA_TRACE(trace_level,
87 ("INFO: CPUID %d: EAX=0x%08X EBX=0x%08X ECX=0x%08X EDX=0x%08X\n",
88 1, buf.eax, buf.ebx, buf.ecx, buf.edx));
89
90 {
91#define get_value(reg, lo, mask) (((reg) >> (lo)) & (mask))
92
93 p->signature = buf.eax;
94 p->family = get_value(buf.eax, 20, 0xff) + get_value(buf.eax, 8, 0x0f);
95 p->model =
96 (get_value(buf.eax, 16, 0x0f) << 4) + get_value(buf.eax, 4, 0x0f);
97 p->stepping = get_value(buf.eax, 0, 0x0f);
98
99#undef get_value
100
101 KA_TRACE(trace_level, (" family = %d, model = %d, stepping = %d\n",
102 p->family, p->model, p->stepping));
103 }
104
105 for (t = buf.ebx, i = 0; i < 4; t >>= 8, ++i) {
106 data[i] = (t & 0xff);
107 }
108
109 p->flags.sse2 = (buf.edx >> 26) & 1;
110
111#ifdef KMP_DEBUG
112
113 if ((buf.edx >> 4) & 1) {
114 /* TSC - Timestamp Counter Available */
115 KA_TRACE(trace_level, (" TSC"));
116 }
117 if ((buf.edx >> 8) & 1) {
118 /* CX8 - CMPXCHG8B Instruction Available */
119 KA_TRACE(trace_level, (" CX8"));
120 }
121 if ((buf.edx >> 9) & 1) {
122 /* APIC - Local APIC Present (multi-processor operation support */
123 KA_TRACE(trace_level, (" APIC"));
124 }
125 if ((buf.edx >> 15) & 1) {
126 /* CMOV - Conditional MOVe Instruction Available */
127 KA_TRACE(trace_level, (" CMOV"));
128 }
129 if ((buf.edx >> 18) & 1) {
130 /* PSN - Processor Serial Number Available */
131 KA_TRACE(trace_level, (" PSN"));
132 }
133 if ((buf.edx >> 19) & 1) {
134 /* CLFLUSH - Cache Flush Instruction Available */
135 cflush_size =
136 data[1] * 8; /* Bits 15-08: CLFLUSH line size = 8 (64 bytes) */
137 KA_TRACE(trace_level, (" CLFLUSH(%db)", cflush_size));
138 }
139 if ((buf.edx >> 21) & 1) {
140 /* DTES - Debug Trace & EMON Store */
141 KA_TRACE(trace_level, (" DTES"));
142 }
143 if ((buf.edx >> 22) & 1) {
144 /* ACPI - ACPI Support Available */
145 KA_TRACE(trace_level, (" ACPI"));
146 }
147 if ((buf.edx >> 23) & 1) {
148 /* MMX - Multimedia Extensions */
149 KA_TRACE(trace_level, (" MMX"));
150 }
151 if ((buf.edx >> 25) & 1) {
152 /* SSE - SSE Instructions */
153 KA_TRACE(trace_level, (" SSE"));
154 }
155 if ((buf.edx >> 26) & 1) {
156 /* SSE2 - SSE2 Instructions */
157 KA_TRACE(trace_level, (" SSE2"));
158 }
159 if ((buf.edx >> 27) & 1) {
160 /* SLFSNP - Self-Snooping Cache */
161 KA_TRACE(trace_level, (" SLFSNP"));
162 }
163#endif /* KMP_DEBUG */
164
165 if ((buf.edx >> 28) & 1) {
166 /* Bits 23-16: Logical Processors per Physical Processor (1 for P4) */
167 p->apic_id = data[3]; /* Bits 31-24: Processor Initial APIC ID (X) */
168 KA_TRACE(trace_level, (" HT(%d TPUs)", data[2]));
169 }
170#ifdef KMP_DEBUG
171 if ((buf.edx >> 29) & 1) {
172 /* ATHROTL - Automatic Throttle Control */
173 KA_TRACE(trace_level, (" ATHROTL"));
174 }
175 KA_TRACE(trace_level, (" ]\n"));
176
177 for (i = 2; i <= max_arg; ++i) {
178 __kmp_x86_cpuid(leaf: i, subleaf: 0, p: &buf);
179 KA_TRACE(trace_level,
180 ("INFO: CPUID %d: EAX=0x%08X EBX=0x%08X ECX=0x%08X EDX=0x%08X\n",
181 i, buf.eax, buf.ebx, buf.ecx, buf.edx));
182 }
183#endif
184 p->flags.rtm = 0;
185 p->flags.hybrid = 0;
186 if (max_arg > 7) {
187 /* RTM bit CPUID.07:EBX, bit 11 */
188 /* HYRBID bit CPUID.07:EDX, bit 15 */
189 __kmp_x86_cpuid(leaf: 7, subleaf: 0, p: &buf);
190 p->flags.rtm = (buf.ebx >> 11) & 1;
191 p->flags.hybrid = (buf.edx >> 15) & 1;
192 if (p->flags.rtm) {
193 KA_TRACE(trace_level, (" RTM"));
194 }
195 if (p->flags.hybrid) {
196 KA_TRACE(trace_level, (" HYBRID"));
197 }
198 }
199 }
200
201 { // Parse CPU brand string for frequency, saving the string for later.
202 int i;
203 kmp_cpuid_t *base = (kmp_cpuid_t *)&p->name[0];
204
205 // Get CPU brand string.
206 for (i = 0; i < 3; ++i) {
207 __kmp_x86_cpuid(leaf: 0x80000002 + i, subleaf: 0, p: base + i);
208 }
209 p->name[sizeof(p->name) - 1] = 0; // Just in case. ;-)
210 KA_TRACE(trace_level, ("cpu brand string: \"%s\"\n", &p->name[0]));
211
212 // Parse frequency.
213 p->frequency = __kmp_parse_frequency(frequency: strrchr(s: &p->name[0], c: ' '));
214 KA_TRACE(trace_level,
215 ("cpu frequency from brand string: %" KMP_UINT64_SPEC "\n",
216 p->frequency));
217 }
218}
219
220#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
221
222void __kmp_expand_host_name(char *buffer, size_t size) {
223 KMP_DEBUG_ASSERT(size >= sizeof(unknown));
224#if KMP_OS_WINDOWS
225 {
226 DWORD s = size;
227
228 if (!GetComputerNameA(buffer, &s))
229 KMP_STRCPY_S(buffer, size, unknown);
230 }
231#elif KMP_OS_WASI
232 KMP_STRCPY_S(buffer, size, unknown);
233#else
234 buffer[size - 2] = 0;
235 if (gethostname(name: buffer, len: size) || buffer[size - 2] != 0)
236 KMP_STRCPY_S(buffer, size, unknown);
237#endif
238}
239
240/* Expand the meta characters in the filename:
241 * Currently defined characters are:
242 * %H the hostname
243 * %P the number of threads used.
244 * %I the unique identifier for this run.
245 */
246
247void __kmp_expand_file_name(char *result, size_t rlen, char *pattern) {
248 char *pos = result, *end = result + rlen - 1;
249 char buffer[256];
250 int default_cpu_width = 1;
251 int snp_result;
252
253 KMP_DEBUG_ASSERT(rlen > 0);
254 *end = 0;
255 {
256 int i;
257 for (i = __kmp_xproc; i >= 10; i /= 10, ++default_cpu_width)
258 ;
259 }
260
261 if (pattern != NULL) {
262 while (*pattern != '\0' && pos < end) {
263 if (*pattern != '%') {
264 *pos++ = *pattern++;
265 } else {
266 char *old_pattern = pattern;
267 int width = 1;
268 int cpu_width = default_cpu_width;
269
270 ++pattern;
271
272 if (*pattern >= '0' && *pattern <= '9') {
273 width = 0;
274 do {
275 width = (width * 10) + *pattern++ - '0';
276 } while (*pattern >= '0' && *pattern <= '9');
277 if (width < 0 || width > 1024)
278 width = 1;
279
280 cpu_width = width;
281 }
282
283 switch (*pattern) {
284 case 'H':
285 case 'h': {
286 __kmp_expand_host_name(buffer, size: sizeof(buffer));
287 KMP_STRNCPY(dest: pos, src: buffer, n: end - pos + 1);
288 if (*end == 0) {
289 while (*pos)
290 ++pos;
291 ++pattern;
292 } else
293 pos = end;
294 } break;
295 case 'P':
296 case 'p': {
297 snp_result = KMP_SNPRINTF(s: pos, maxlen: end - pos + 1, format: "%0*d", cpu_width,
298 __kmp_dflt_team_nth);
299 if (snp_result >= 0 && snp_result <= end - pos) {
300 while (*pos)
301 ++pos;
302 ++pattern;
303 } else
304 pos = end;
305 } break;
306 case 'I':
307 case 'i': {
308 pid_t id = getpid();
309#if (KMP_ARCH_X86_64 || KMP_ARCH_AARCH64) && defined(__MINGW32__)
310 snp_result = KMP_SNPRINTF(pos, end - pos + 1, "%0*lld", width, id);
311#else
312 snp_result = KMP_SNPRINTF(s: pos, maxlen: end - pos + 1, format: "%0*d", width, id);
313#endif
314 if (snp_result >= 0 && snp_result <= end - pos) {
315 while (*pos)
316 ++pos;
317 ++pattern;
318 } else
319 pos = end;
320 break;
321 }
322 case '%': {
323 *pos++ = '%';
324 ++pattern;
325 break;
326 }
327 default: {
328 *pos++ = '%';
329 pattern = old_pattern + 1;
330 break;
331 }
332 }
333 }
334 }
335 /* TODO: How do we get rid of this? */
336 if (*pattern != '\0')
337 KMP_FATAL(FileNameTooLong);
338 }
339
340 *pos = '\0';
341}
342
343#if !OMPT_SUPPORT
344extern "C" {
345typedef struct ompt_start_tool_result_t ompt_start_tool_result_t;
346// Define symbols expected by VERSION script
347ompt_start_tool_result_t *ompt_start_tool(unsigned int omp_version,
348 const char *runtime_version) {
349 return nullptr;
350}
351
352void ompt_libomp_connect(ompt_start_tool_result_t *result) { result = nullptr; }
353}
354#endif
355

source code of openmp/runtime/src/kmp_utility.cpp