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