contrib/openmp/runtime/src/kmp_utility.cpp

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