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 19 static 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 28 static 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 */ 35 int __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 */ 69 int __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 93 static 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 122 void __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 288 void __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 #else 298 buffer[size - 2] = 0; 299 if (gethostname(buffer, size) || buffer[size - 2] != 0) 300 KMP_STRCPY_S(buffer, size, unknown); 301 #endif 302 } 303 304 /* Expand the meta characters in the filename: 305 * Currently defined characters are: 306 * %H the hostname 307 * %P the number of threads used. 308 * %I the unique identifier for this run. 309 */ 310 311 void __kmp_expand_file_name(char *result, size_t rlen, char *pattern) { 312 char *pos = result, *end = result + rlen - 1; 313 char buffer[256]; 314 int default_cpu_width = 1; 315 int snp_result; 316 317 KMP_DEBUG_ASSERT(rlen > 0); 318 *end = 0; 319 { 320 int i; 321 for (i = __kmp_xproc; i >= 10; i /= 10, ++default_cpu_width) 322 ; 323 } 324 325 if (pattern != NULL) { 326 while (*pattern != '\0' && pos < end) { 327 if (*pattern != '%') { 328 *pos++ = *pattern++; 329 } else { 330 char *old_pattern = pattern; 331 int width = 1; 332 int cpu_width = default_cpu_width; 333 334 ++pattern; 335 336 if (*pattern >= '0' && *pattern <= '9') { 337 width = 0; 338 do { 339 width = (width * 10) + *pattern++ - '0'; 340 } while (*pattern >= '0' && *pattern <= '9'); 341 if (width < 0 || width > 1024) 342 width = 1; 343 344 cpu_width = width; 345 } 346 347 switch (*pattern) { 348 case 'H': 349 case 'h': { 350 __kmp_expand_host_name(buffer, sizeof(buffer)); 351 KMP_STRNCPY(pos, buffer, end - pos + 1); 352 if (*end == 0) { 353 while (*pos) 354 ++pos; 355 ++pattern; 356 } else 357 pos = end; 358 } break; 359 case 'P': 360 case 'p': { 361 snp_result = KMP_SNPRINTF(pos, end - pos + 1, "%0*d", cpu_width, 362 __kmp_dflt_team_nth); 363 if (snp_result >= 0 && snp_result <= end - pos) { 364 while (*pos) 365 ++pos; 366 ++pattern; 367 } else 368 pos = end; 369 } break; 370 case 'I': 371 case 'i': { 372 pid_t id = getpid(); 373 #if (KMP_ARCH_X86_64 || KMP_ARCH_AARCH64) && defined(__MINGW32__) 374 snp_result = KMP_SNPRINTF(pos, end - pos + 1, "%0*lld", width, id); 375 #else 376 snp_result = KMP_SNPRINTF(pos, end - pos + 1, "%0*d", width, id); 377 #endif 378 if (snp_result >= 0 && snp_result <= end - pos) { 379 while (*pos) 380 ++pos; 381 ++pattern; 382 } else 383 pos = end; 384 break; 385 } 386 case '%': { 387 *pos++ = '%'; 388 ++pattern; 389 break; 390 } 391 default: { 392 *pos++ = '%'; 393 pattern = old_pattern + 1; 394 break; 395 } 396 } 397 } 398 } 399 /* TODO: How do we get rid of this? */ 400 if (*pattern != '\0') 401 KMP_FATAL(FileNameTooLong); 402 } 403 404 *pos = '\0'; 405 } 406 407 #if !OMPT_SUPPORT 408 extern "C" { 409 typedef struct ompt_start_tool_result_t ompt_start_tool_result_t; 410 // Define symbols expected by VERSION script 411 ompt_start_tool_result_t *ompt_start_tool(unsigned int omp_version, 412 const char *runtime_version) { 413 return nullptr; 414 } 415 416 void ompt_libomp_connect(ompt_start_tool_result_t *result) { result = nullptr; } 417 } 418 #endif 419