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
31/* LOG_ID_BITS  = ( 1 + floor( log_2( max( log_per_phy - 1, 1 ))))
32 * APIC_ID      = (PHY_ID << LOG_ID_BITS) | LOG_ID
33 * PHY_ID       = APIC_ID >> LOG_ID_BITS
34 */
35int __kmp_get_physical_id(int log_per_phy, int apic_id) {
36  int index_lsb, index_msb, temp;
37
38  if (log_per_phy > 1) {
39    index_lsb = 0;
40    index_msb = 31;
41
42    temp = log_per_phy;
43    while ((temp & 1) == 0) {
44      temp >>= 1;
45      index_lsb++;
46    }
47
48    temp = log_per_phy;
49    while ((temp & 0x80000000) == 0) {
50      temp <<= 1;
51      index_msb--;
52    }
53
54    /* If >1 bits were set in log_per_phy, choose next higher power of 2 */
55    if (index_lsb != index_msb)
56      index_msb++;
57
58    return ((int)(apic_id >> index_msb));
59  }
60
61  return apic_id;
62}
63
64/*
65 * LOG_ID_BITS  = ( 1 + floor( log_2( max( log_per_phy - 1, 1 ))))
66 * APIC_ID      = (PHY_ID << LOG_ID_BITS) | LOG_ID
67 * LOG_ID       = APIC_ID & (( 1 << LOG_ID_BITS ) - 1 )
68 */
69int __kmp_get_logical_id(int log_per_phy, int apic_id) {
70  unsigned current_bit;
71  int bits_seen;
72
73  if (log_per_phy <= 1)
74    return (0);
75
76  bits_seen = 0;
77
78  for (current_bit = 1; log_per_phy != 0; current_bit <<= 1) {
79    if (log_per_phy & current_bit) {
80      log_per_phy &= ~current_bit;
81      bits_seen++;
82    }
83  }
84
85  /* If exactly 1 bit was set in log_per_phy, choose next lower power of 2 */
86  if (bits_seen == 1) {
87    current_bit >>= 1;
88  }
89
90  return ((int)((current_bit - 1) & apic_id));
91}
92
93static kmp_uint64 __kmp_parse_frequency( // R: Frequency in Hz.
94    char const *frequency // I: Float number and unit: MHz, GHz, or TGz.
95) {
96
97  double value = 0.0;
98  char *unit = NULL;
99  kmp_uint64 result = 0; /* Zero is a better unknown value than all ones. */
100
101  if (frequency == NULL) {
102    return result;
103  }
104  value = strtod(frequency, &unit);
105  if (0 < value &&
106      value <= DBL_MAX) { // Good value (not overflow, underflow, etc).
107    if (strcmp(unit, "MHz") == 0) {
108      value = value * 1.0E+6;
109    } else if (strcmp(unit, "GHz") == 0) {
110      value = value * 1.0E+9;
111    } else if (strcmp(unit, "THz") == 0) {
112      value = value * 1.0E+12;
113    } else { // Wrong unit.
114      return result;
115    }
116    result = (kmp_uint64)value; // rounds down
117  }
118  return result;
119
120} // func __kmp_parse_cpu_frequency
121
122void __kmp_query_cpuid(kmp_cpuinfo_t *p) {
123  struct kmp_cpuid buf;
124  int max_arg;
125  int log_per_phy;
126#ifdef KMP_DEBUG
127  int cflush_size;
128#endif
129
130  p->initialized = 1;
131
132  p->flags.sse2 = 1; // Assume SSE2 by default.
133
134  __kmp_x86_cpuid(0, 0, &buf);
135
136  KA_TRACE(trace_level,
137           ("INFO: CPUID %d: EAX=0x%08X EBX=0x%08X ECX=0x%08X EDX=0x%08X\n", 0,
138            buf.eax, buf.ebx, buf.ecx, buf.edx));
139
140  max_arg = buf.eax;
141
142  p->apic_id = -1;
143
144  if (max_arg >= 1) {
145    int i;
146    kmp_uint32 t, data[4];
147
148    __kmp_x86_cpuid(1, 0, &buf);
149    KA_TRACE(trace_level,
150             ("INFO: CPUID %d: EAX=0x%08X EBX=0x%08X ECX=0x%08X EDX=0x%08X\n",
151              1, buf.eax, buf.ebx, buf.ecx, buf.edx));
152
153    {
154#define get_value(reg, lo, mask) (((reg) >> (lo)) & (mask))
155
156      p->signature = buf.eax;
157      p->family = get_value(buf.eax, 20, 0xff) + get_value(buf.eax, 8, 0x0f);
158      p->model =
159          (get_value(buf.eax, 16, 0x0f) << 4) + get_value(buf.eax, 4, 0x0f);
160      p->stepping = get_value(buf.eax, 0, 0x0f);
161
162#undef get_value
163
164      KA_TRACE(trace_level, (" family = %d, model = %d, stepping = %d\n",
165                             p->family, p->model, p->stepping));
166    }
167
168    for (t = buf.ebx, i = 0; i < 4; t >>= 8, ++i) {
169      data[i] = (t & 0xff);
170    }
171
172    p->flags.sse2 = (buf.edx >> 26) & 1;
173
174#ifdef KMP_DEBUG
175
176    if ((buf.edx >> 4) & 1) {
177      /* TSC - Timestamp Counter Available */
178      KA_TRACE(trace_level, (" TSC"));
179    }
180    if ((buf.edx >> 8) & 1) {
181      /* CX8 - CMPXCHG8B Instruction Available */
182      KA_TRACE(trace_level, (" CX8"));
183    }
184    if ((buf.edx >> 9) & 1) {
185      /* APIC - Local APIC Present (multi-processor operation support */
186      KA_TRACE(trace_level, (" APIC"));
187    }
188    if ((buf.edx >> 15) & 1) {
189      /* CMOV - Conditional MOVe Instruction Available */
190      KA_TRACE(trace_level, (" CMOV"));
191    }
192    if ((buf.edx >> 18) & 1) {
193      /* PSN - Processor Serial Number Available */
194      KA_TRACE(trace_level, (" PSN"));
195    }
196    if ((buf.edx >> 19) & 1) {
197      /* CLFLUSH - Cache Flush Instruction Available */
198      cflush_size =
199          data[1] * 8; /* Bits 15-08: CLFLUSH line size = 8 (64 bytes) */
200      KA_TRACE(trace_level, (" CLFLUSH(%db)", cflush_size));
201    }
202    if ((buf.edx >> 21) & 1) {
203      /* DTES - Debug Trace & EMON Store */
204      KA_TRACE(trace_level, (" DTES"));
205    }
206    if ((buf.edx >> 22) & 1) {
207      /* ACPI - ACPI Support Available */
208      KA_TRACE(trace_level, (" ACPI"));
209    }
210    if ((buf.edx >> 23) & 1) {
211      /* MMX - Multimedia Extensions */
212      KA_TRACE(trace_level, (" MMX"));
213    }
214    if ((buf.edx >> 25) & 1) {
215      /* SSE - SSE Instructions */
216      KA_TRACE(trace_level, (" SSE"));
217    }
218    if ((buf.edx >> 26) & 1) {
219      /* SSE2 - SSE2 Instructions */
220      KA_TRACE(trace_level, (" SSE2"));
221    }
222    if ((buf.edx >> 27) & 1) {
223      /* SLFSNP - Self-Snooping Cache */
224      KA_TRACE(trace_level, (" SLFSNP"));
225    }
226#endif /* KMP_DEBUG */
227
228    if ((buf.edx >> 28) & 1) {
229      /* Bits 23-16: Logical Processors per Physical Processor (1 for P4) */
230      log_per_phy = data[2];
231      p->apic_id = data[3]; /* Bits 31-24: Processor Initial APIC ID (X) */
232      KA_TRACE(trace_level, (" HT(%d TPUs)", log_per_phy));
233      p->physical_id = __kmp_get_physical_id(log_per_phy, p->apic_id);
234      p->logical_id = __kmp_get_logical_id(log_per_phy, p->apic_id);
235    }
236#ifdef KMP_DEBUG
237    if ((buf.edx >> 29) & 1) {
238      /* ATHROTL - Automatic Throttle Control */
239      KA_TRACE(trace_level, (" ATHROTL"));
240    }
241    KA_TRACE(trace_level, (" ]\n"));
242
243    for (i = 2; i <= max_arg; ++i) {
244      __kmp_x86_cpuid(i, 0, &buf);
245      KA_TRACE(trace_level,
246               ("INFO: CPUID %d: EAX=0x%08X EBX=0x%08X ECX=0x%08X EDX=0x%08X\n",
247                i, buf.eax, buf.ebx, buf.ecx, buf.edx));
248    }
249#endif
250    p->flags.rtm = 0;
251    p->flags.hybrid = 0;
252    if (max_arg > 7) {
253      /* RTM bit CPUID.07:EBX, bit 11 */
254      /* HYRBID bit CPUID.07:EDX, bit 15 */
255      __kmp_x86_cpuid(7, 0, &buf);
256      p->flags.rtm = (buf.ebx >> 11) & 1;
257      p->flags.hybrid = (buf.edx >> 15) & 1;
258      if (p->flags.rtm) {
259        KA_TRACE(trace_level, (" RTM"));
260      }
261      if (p->flags.hybrid) {
262        KA_TRACE(trace_level, (" HYBRID"));
263      }
264    }
265  }
266
267  { // Parse CPU brand string for frequency, saving the string for later.
268    int i;
269    kmp_cpuid_t *base = (kmp_cpuid_t *)&p->name[0];
270
271    // Get CPU brand string.
272    for (i = 0; i < 3; ++i) {
273      __kmp_x86_cpuid(0x80000002 + i, 0, base + i);
274    }
275    p->name[sizeof(p->name) - 1] = 0; // Just in case. ;-)
276    KA_TRACE(trace_level, ("cpu brand string: \"%s\"\n", &p->name[0]));
277
278    // Parse frequency.
279    p->frequency = __kmp_parse_frequency(strrchr(&p->name[0], ' '));
280    KA_TRACE(trace_level,
281             ("cpu frequency from brand string: %" KMP_UINT64_SPEC "\n",
282              p->frequency));
283  }
284}
285
286#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
287
288void __kmp_expand_host_name(char *buffer, size_t size) {
289  KMP_DEBUG_ASSERT(size >= sizeof(unknown));
290#if KMP_OS_WINDOWS
291  {
292    DWORD s = size;
293
294    if (!GetComputerNameA(buffer, &s))
295      KMP_STRCPY_S(buffer, size, unknown);
296  }
297#elif KMP_OS_WASI
298  KMP_STRCPY_S(buffer, size, unknown);
299#else
300  buffer[size - 2] = 0;
301  if (gethostname(buffer, size) || buffer[size - 2] != 0)
302    KMP_STRCPY_S(buffer, size, unknown);
303#endif
304}
305
306/* Expand the meta characters in the filename:
307 * Currently defined characters are:
308 * %H the hostname
309 * %P the number of threads used.
310 * %I the unique identifier for this run.
311 */
312
313void __kmp_expand_file_name(char *result, size_t rlen, char *pattern) {
314  char *pos = result, *end = result + rlen - 1;
315  char buffer[256];
316  int default_cpu_width = 1;
317  int snp_result;
318
319  KMP_DEBUG_ASSERT(rlen > 0);
320  *end = 0;
321  {
322    int i;
323    for (i = __kmp_xproc; i >= 10; i /= 10, ++default_cpu_width)
324      ;
325  }
326
327  if (pattern != NULL) {
328    while (*pattern != '\0' && pos < end) {
329      if (*pattern != '%') {
330        *pos++ = *pattern++;
331      } else {
332        char *old_pattern = pattern;
333        int width = 1;
334        int cpu_width = default_cpu_width;
335
336        ++pattern;
337
338        if (*pattern >= '0' && *pattern <= '9') {
339          width = 0;
340          do {
341            width = (width * 10) + *pattern++ - '0';
342          } while (*pattern >= '0' && *pattern <= '9');
343          if (width < 0 || width > 1024)
344            width = 1;
345
346          cpu_width = width;
347        }
348
349        switch (*pattern) {
350        case 'H':
351        case 'h': {
352          __kmp_expand_host_name(buffer, sizeof(buffer));
353          KMP_STRNCPY(pos, buffer, end - pos + 1);
354          if (*end == 0) {
355            while (*pos)
356              ++pos;
357            ++pattern;
358          } else
359            pos = end;
360        } break;
361        case 'P':
362        case 'p': {
363          snp_result = KMP_SNPRINTF(pos, end - pos + 1, "%0*d", cpu_width,
364                                    __kmp_dflt_team_nth);
365          if (snp_result >= 0 && snp_result <= end - pos) {
366            while (*pos)
367              ++pos;
368            ++pattern;
369          } else
370            pos = end;
371        } break;
372        case 'I':
373        case 'i': {
374          pid_t id = getpid();
375#if (KMP_ARCH_X86_64 || KMP_ARCH_AARCH64) && defined(__MINGW32__)
376          snp_result = KMP_SNPRINTF(pos, end - pos + 1, "%0*lld", width, id);
377#else
378          snp_result = KMP_SNPRINTF(pos, end - pos + 1, "%0*d", width, id);
379#endif
380          if (snp_result >= 0 && snp_result <= end - pos) {
381            while (*pos)
382              ++pos;
383            ++pattern;
384          } else
385            pos = end;
386          break;
387        }
388        case '%': {
389          *pos++ = '%';
390          ++pattern;
391          break;
392        }
393        default: {
394          *pos++ = '%';
395          pattern = old_pattern + 1;
396          break;
397        }
398        }
399      }
400    }
401    /* TODO: How do we get rid of this? */
402    if (*pattern != '\0')
403      KMP_FATAL(FileNameTooLong);
404  }
405
406  *pos = '\0';
407}
408
409#if !OMPT_SUPPORT
410extern "C" {
411typedef struct ompt_start_tool_result_t ompt_start_tool_result_t;
412// Define symbols expected by VERSION script
413ompt_start_tool_result_t *ompt_start_tool(unsigned int omp_version,
414                                          const char *runtime_version) {
415  return nullptr;
416}
417
418void ompt_libomp_connect(ompt_start_tool_result_t *result) { result = nullptr; }
419}
420#endif
421