Annotation of OpenXM_contrib/gmp/tune/freq.c, Revision 1.1
1.1 ! ohara 1: /* CPU frequency determination.
! 2:
! 3: Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
! 4:
! 5: This file is part of the GNU MP Library.
! 6:
! 7: The GNU MP Library is free software; you can redistribute it and/or modify
! 8: it under the terms of the GNU Lesser General Public License as published by
! 9: the Free Software Foundation; either version 2.1 of the License, or (at your
! 10: option) any later version.
! 11:
! 12: The GNU MP Library is distributed in the hope that it will be useful, but
! 13: WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
! 14: or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
! 15: License for more details.
! 16:
! 17: You should have received a copy of the GNU Lesser General Public License
! 18: along with the GNU MP Library; see the file COPYING.LIB. If not, write to
! 19: the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
! 20: MA 02111-1307, USA. */
! 21:
! 22: #include "config.h"
! 23:
! 24: #include <stdio.h>
! 25: #include <stdlib.h> /* for getenv, qsort */
! 26: #if HAVE_UNISTD_H
! 27: #include <unistd.h> /* for sysconf */
! 28: #endif
! 29:
! 30: #include <sys/types.h>
! 31: #if HAVE_SYS_PARAM_H
! 32: #include <sys/param.h> /* for constants needed by NetBSD <sys/sysctl.h> */
! 33: #endif
! 34: #if HAVE_SYS_SYSCTL_H
! 35: #include <sys/sysctl.h> /* for sysctlbyname() */
! 36: #endif
! 37:
! 38: #if TIME_WITH_SYS_TIME
! 39: # include <sys/time.h> /* for struct timeval */
! 40: # include <time.h>
! 41: #else
! 42: # if HAVE_SYS_TIME_H
! 43: # include <sys/time.h>
! 44: # else
! 45: # include <time.h>
! 46: # endif
! 47: #endif
! 48:
! 49: #if HAVE_SYS_RESOURCE_H
! 50: #include <sys/resource.h> /* for struct rusage */
! 51: #endif
! 52:
! 53: #if HAVE_SYS_PROCESSOR_H
! 54: #include <sys/processor.h> /* for solaris processor_info_t */
! 55: #endif
! 56:
! 57: /* Remove definitions from NetBSD <sys/param.h>, to avoid conflicts with
! 58: gmp-impl.h. */
! 59: #ifdef MIN
! 60: #undef MIN
! 61: #endif
! 62: #ifdef MAX
! 63: #undef MAX
! 64: #endif
! 65:
! 66: #include "gmp.h"
! 67: #include "gmp-impl.h"
! 68:
! 69: #include "speed.h"
! 70:
! 71:
! 72: #define HELP(str) \
! 73: if (help) \
! 74: { \
! 75: printf (" - %s\n", str); \
! 76: return 0; \
! 77: }
! 78:
! 79:
! 80: /* GMP_CPU_FREQUENCY environment variable. Should be in Hertz and can be
! 81: floating point, for example "450e6". */
! 82: static int
! 83: freq_environment (int help)
! 84: {
! 85: char *e;
! 86:
! 87: HELP ("environment variable GMP_CPU_FREQUENCY (in Hertz)");
! 88:
! 89: e = getenv ("GMP_CPU_FREQUENCY");
! 90: if (e == NULL)
! 91: return 0;
! 92:
! 93: speed_cycletime = 1.0 / atof (e);
! 94:
! 95: if (speed_option_verbose)
! 96: printf ("Using GMP_CPU_FREQUENCY %.2f for cycle time %.3g\n",
! 97: atof (e), speed_cycletime);
! 98:
! 99: return 1;
! 100: }
! 101:
! 102:
! 103: /* i386 FreeBSD 2.2.8 sysctlbyname machdep.i586_freq is in Hertz.
! 104: There's no obvious defines available to get this from plain sysctl. */
! 105: static int
! 106: freq_sysctlbyname_i586_freq (int help)
! 107: {
! 108: #if HAVE_SYSCTLBYNAME
! 109: unsigned val;
! 110: size_t size;
! 111:
! 112: HELP ("sysctlbyname() machdep.i586_freq");
! 113:
! 114: size = sizeof(val);
! 115: if (sysctlbyname ("machdep.i586_freq", &val, &size, NULL, 0) == 0
! 116: && size == sizeof(val))
! 117: {
! 118: if (speed_option_verbose)
! 119: printf ("Using sysctlbyname() machdep.i586_freq %u for cycle time %.3g\n",
! 120: val, speed_cycletime);
! 121: speed_cycletime = 1.0 / (double) val;
! 122: return 1;
! 123: }
! 124: #endif
! 125: return 0;
! 126: }
! 127:
! 128:
! 129: /* i368 FreeBSD 3.3 sysctlbyname machdep.tsc_freq is in Hertz.
! 130: There's no obvious defines to get this from plain sysctl. */
! 131:
! 132: static int
! 133: freq_sysctlbyname_tsc_freq (int help)
! 134: {
! 135: #if HAVE_SYSCTLBYNAME
! 136: unsigned val;
! 137: size_t size;
! 138:
! 139: HELP ("sysctlbyname() machdep.tsc_freq");
! 140:
! 141: size = sizeof(val);
! 142: if (sysctlbyname ("machdep.tsc_freq", &val, &size, NULL, 0) == 0
! 143: && size == sizeof(val))
! 144: {
! 145: if (speed_option_verbose)
! 146: printf ("Using sysctlbyname() machdep.tsc_freq %u for cycle time %.3g\n",
! 147: val, speed_cycletime);
! 148: speed_cycletime = 1.0 / (double) val;
! 149: return 1;
! 150: }
! 151: #endif
! 152: return 0;
! 153: }
! 154:
! 155:
! 156: /* Apple powerpc Darwin 1.3 sysctl hw.cpufrequency is in hertz. For some
! 157: reason only seems to be available from sysctl(), not sysctlbyname(). */
! 158:
! 159: static int
! 160: freq_sysctl_hw_cpufrequency (int help)
! 161: {
! 162: #if HAVE_SYSCTL && defined (CTL_HW) && defined (HW_CPU_FREQ)
! 163: int mib[2];
! 164: unsigned val;
! 165: size_t size;
! 166:
! 167: HELP ("sysctl() hw.cpufrequency");
! 168:
! 169: mib[0] = CTL_HW;
! 170: mib[1] = HW_CPU_FREQ;
! 171: size = sizeof(val);
! 172: if (sysctl (mib, 2, &val, &size, NULL, 0) == 0)
! 173: {
! 174: if (speed_option_verbose)
! 175: printf ("Using sysctl() hw.cpufrequency %u for cycle time %.3g\n",
! 176: val, speed_cycletime);
! 177: speed_cycletime = 1.0 / (double) val;
! 178: return 1;
! 179: }
! 180: #endif
! 181: return 0;
! 182: }
! 183:
! 184:
! 185: /* Alpha FreeBSD 4.1 and NetBSD 1.4 sysctl- hw.model string gives "Digital
! 186: AlphaPC 164LX 599 MHz". NetBSD 1.4 doesn't seem to have sysctlbyname, so
! 187: sysctl() is used. */
! 188:
! 189: static int
! 190: freq_sysctl_hw_model (int help)
! 191: {
! 192: #if HAVE_SYSCTL && defined (CTL_HW) && defined (HW_MODEL)
! 193: int mib[2];
! 194: char str[128];
! 195: unsigned val;
! 196: size_t size;
! 197: char *p;
! 198: int i;
! 199:
! 200: HELP ("sysctl() hw.model");
! 201:
! 202: mib[0] = CTL_HW;
! 203: mib[1] = HW_MODEL;
! 204: size = sizeof(str);
! 205: if (sysctl (mib, 2, str, &size, NULL, 0) == 0)
! 206: {
! 207: /* find the second last space */
! 208: p = &str[size-1];
! 209: for (i = 0; i < 2; i++)
! 210: {
! 211: for (;;)
! 212: {
! 213: if (p <= str)
! 214: return 0;
! 215: p--;
! 216: if (*p == ' ')
! 217: break;
! 218: }
! 219: }
! 220:
! 221: if (sscanf (p, "%u MHz", &val) != 1)
! 222: return 0;
! 223:
! 224: if (speed_option_verbose)
! 225: printf ("Using sysctl() hw.model %u for cycle time %.3g\n",
! 226: val, speed_cycletime);
! 227: speed_cycletime = 1e-6 / (double) val;
! 228: return 1;
! 229: }
! 230: #endif
! 231: return 0;
! 232: }
! 233:
! 234:
! 235: /* /proc/cpuinfo for linux kernel.
! 236:
! 237: Linux doesn't seem to have any system call to get the CPU frequency, at
! 238: least not in 2.0.x or 2.2.x, so it's necessary to read /proc/cpuinfo.
! 239:
! 240: i386 2.0.36 - "bogomips" is the CPU frequency.
! 241:
! 242: i386 2.2.13 - has both "cpu MHz" and "bogomips", and it's "cpu MHz" which
! 243: is the frequency.
! 244:
! 245: alpha 2.2.5 - "cycle frequency [Hz]" seems to be right, "BogoMIPS" is
! 246: very slightly different.
! 247:
! 248: alpha 2.2.18pre21 - "cycle frequency [Hz]" is 0 on at least one system,
! 249: "BogoMIPS" seems near enough.
! 250:
! 251: powerpc 2.2.19 - "clock" is the frequency, bogomips is something weird
! 252: */
! 253:
! 254: static int
! 255: freq_proc_cpuinfo (int help)
! 256: {
! 257: FILE *fp;
! 258: char buf[128];
! 259: double val;
! 260: int ret = 0;
! 261:
! 262: HELP ("linux kernel /proc/cpuinfo file, cpu MHz or bogomips");
! 263:
! 264: if ((fp = fopen ("/proc/cpuinfo", "r")) != NULL)
! 265: {
! 266: while (fgets (buf, sizeof (buf), fp) != NULL)
! 267: {
! 268: if (sscanf (buf, "cycle frequency [Hz] : %lf", &val) == 1
! 269: && val != 0.0)
! 270: {
! 271: speed_cycletime = 1.0 / val;
! 272: if (speed_option_verbose)
! 273: printf ("Using /proc/cpuinfo \"cycle frequency\" %.2f for cycle time %.3g\n", val, speed_cycletime);
! 274: ret = 1;
! 275: break;
! 276: }
! 277: if (sscanf (buf, "cpu MHz : %lf\n", &val) == 1)
! 278: {
! 279: speed_cycletime = 1e-6 / val;
! 280: if (speed_option_verbose)
! 281: printf ("Using /proc/cpuinfo \"cpu MHz\" %.2f for cycle time %.3g\n", val, speed_cycletime);
! 282: ret = 1;
! 283: break;
! 284: }
! 285: if (sscanf (buf, "clock : %lfMHz\n", &val) == 1)
! 286: {
! 287: speed_cycletime = 1e-6 / val;
! 288: if (speed_option_verbose)
! 289: printf ("Using /proc/cpuinfo \"clock\" %.2f for cycle time %.3g\n", val, speed_cycletime);
! 290: ret = 1;
! 291: break;
! 292: }
! 293: if (sscanf (buf, "bogomips : %lf\n", &val) == 1
! 294: || sscanf (buf, "BogoMIPS : %lf\n", &val) == 1)
! 295: {
! 296: speed_cycletime = 1e-6 / val;
! 297: if (speed_option_verbose)
! 298: printf ("Using /proc/cpuinfo \"bogomips\" %.2f for cycle time %.3g\n", val, speed_cycletime);
! 299: ret = 1;
! 300: break;
! 301: }
! 302: }
! 303: fclose (fp);
! 304: }
! 305: return ret;
! 306: }
! 307:
! 308:
! 309: /* /bin/sysinfo for SunOS 4.
! 310: Prints a line like: cpu0 is a "75 MHz TI,TMS390Z55" CPU */
! 311: static int
! 312: freq_sunos_sysinfo (int help)
! 313: {
! 314: int ret = 0;
! 315: #if HAVE_POPEN
! 316: FILE *fp;
! 317: char buf[128];
! 318: double val;
! 319:
! 320: HELP ("SunOS /bin/sysinfo program output, cpu0");
! 321:
! 322: /* Error messages are sent to /dev/null in case /bin/sysinfo doesn't
! 323: exist. The brackets are necessary for some shells. */
! 324: if ((fp = popen ("(/bin/sysinfo) 2>/dev/null", "r")) != NULL)
! 325: {
! 326: while (fgets (buf, sizeof (buf), fp) != NULL)
! 327: {
! 328: if (sscanf (buf, " cpu0 is a \"%lf MHz", &val) == 1)
! 329: {
! 330: speed_cycletime = 1e-6 / val;
! 331: if (speed_option_verbose)
! 332: printf ("Using /bin/sysinfo \"cpu0 MHz\" %.2f for cycle time %.3g\n", val, speed_cycletime);
! 333: ret = 1;
! 334: break;
! 335: }
! 336: }
! 337: pclose (fp);
! 338: }
! 339: #endif
! 340: return ret;
! 341: }
! 342:
! 343:
! 344: /* "/etc/hw -r cpu" for SCO OpenUnix 8, printing a line like
! 345: The speed of the CPU is approximately 450Mhz */
! 346: static int
! 347: freq_sco_etchw (int help)
! 348: {
! 349: int ret = 0;
! 350: #if HAVE_POPEN
! 351: FILE *fp;
! 352: char buf[128];
! 353: double val;
! 354:
! 355: HELP ("SCO /etc/hw program output");
! 356:
! 357: /* Error messages are sent to /dev/null in case /etc/hw doesn't exist.
! 358: The brackets are necessary for some shells. */
! 359: if ((fp = popen ("(/etc/hw -r cpu) 2>/dev/null", "r")) != NULL)
! 360: {
! 361: while (fgets (buf, sizeof (buf), fp) != NULL)
! 362: {
! 363: if (sscanf (buf, " The speed of the CPU is approximately %lfMhz",
! 364: &val) == 1)
! 365: {
! 366: speed_cycletime = 1e-6 / val;
! 367: if (speed_option_verbose)
! 368: printf ("Using /etc/hw %.2f MHz, for cycle time %.3g\n",
! 369: val, speed_cycletime);
! 370: ret = 1;
! 371: break;
! 372: }
! 373: }
! 374: pclose (fp);
! 375: }
! 376: #endif
! 377: return ret;
! 378: }
! 379:
! 380:
! 381: /* "hinv -c processor" for IRIX.
! 382: The first line printed is for instance "2 195 MHZ IP27 Processors". */
! 383: static int
! 384: freq_irix_hinv (int help)
! 385: {
! 386: int ret = 0;
! 387: #if HAVE_POPEN
! 388: FILE *fp;
! 389: char buf[128];
! 390: double val;
! 391: int nproc;
! 392:
! 393: HELP ("IRIX \"hinv -c processor\" output");
! 394:
! 395: /* Error messages are sent to /dev/null in case hinv doesn't exist. The
! 396: brackets are necessary for some shells. */
! 397: if ((fp = popen ("(hinv -c processor) 2>/dev/null", "r")) != NULL)
! 398: {
! 399: while (fgets (buf, sizeof (buf), fp) != NULL)
! 400: {
! 401: if (sscanf (buf, "%d %lf MHZ", &nproc, &val) == 2)
! 402: {
! 403: speed_cycletime = 1e-6 / val;
! 404: if (speed_option_verbose)
! 405: printf ("Using hinv -c processor \"%.2f MHZ\" for cycle time %.3g\n", val, speed_cycletime);
! 406: ret = 1;
! 407: break;
! 408: }
! 409: }
! 410: pclose (fp);
! 411: }
! 412: #endif
! 413: return ret;
! 414: }
! 415:
! 416:
! 417: /* FreeBSD on i386 gives a line like the following at bootup, and which can
! 418: be read back from /var/run/dmesg.boot.
! 419:
! 420: CPU: AMD Athlon(tm) Processor (755.29-MHz 686-class CPU)
! 421: CPU: Pentium 4 (1707.56-MHz 686-class CPU)
! 422:
! 423: This is useful on FreeBSD 4.x, where there's no sysctl machdep.tsc_freq
! 424: or machdep.i586_freq.
! 425:
! 426: It's better to use /var/run/dmesg.boot than to run /sbin/dmesg, since the
! 427: latter prints the current system message buffer, which is a limited size
! 428: and can wrap around if the system is up for a long time. */
! 429:
! 430: static int
! 431: freq_bsd_dmesg (int help)
! 432: {
! 433: FILE *fp;
! 434: char buf[256], *p;
! 435: double val;
! 436: int ret = 0;
! 437:
! 438: HELP ("BSD /var/run/dmesg.boot file");
! 439:
! 440: if ((fp = fopen ("/var/run/dmesg.boot", "r")) != NULL)
! 441: {
! 442: while (fgets (buf, sizeof (buf), fp) != NULL)
! 443: {
! 444: if (memcmp (buf, "CPU:", 4) == 0)
! 445: {
! 446: for (p = buf; *p != '\0'; p++)
! 447: {
! 448: if (sscanf (p, "(%lf-MHz", &val) == 1)
! 449: {
! 450: speed_cycletime = 1e-6 / val;
! 451: if (speed_option_verbose)
! 452: printf ("Using /var/run/dmesg.boot CPU: %.2f MHz for cycle time %.3g\n", val, speed_cycletime);
! 453: ret = 1;
! 454: break;
! 455: }
! 456: }
! 457: }
! 458: }
! 459: fclose (fp);
! 460: }
! 461: return ret;
! 462: }
! 463:
! 464:
! 465: /* processor_info() for Solaris. "psrinfo" is the command-line interface to
! 466: this. "prtconf -vp" gives similar information.
! 467:
! 468: Apple Darwin has a processor_info, but in an incompatible style. It
! 469: doesn't have <sys/processor.h>, so test for that. */
! 470:
! 471: static int
! 472: freq_processor_info (int help)
! 473: {
! 474: #if HAVE_PROCESSOR_INFO && HAVE_SYS_PROCESSOR_H
! 475: processor_info_t p;
! 476: int i, n, mhz = 0;
! 477:
! 478: HELP ("processor_info() pi_clock");
! 479:
! 480: n = sysconf (_SC_NPROCESSORS_CONF);
! 481: for (i = 0; i < n; i++)
! 482: {
! 483: if (processor_info (i, &p) != 0)
! 484: continue;
! 485: if (p.pi_state != P_ONLINE)
! 486: continue;
! 487:
! 488: if (mhz != 0 && p.pi_clock != mhz)
! 489: {
! 490: fprintf (stderr,
! 491: "freq_processor_info(): There's more than one CPU and they have different clock speeds\n");
! 492: return 0;
! 493: }
! 494:
! 495: mhz = p.pi_clock;
! 496: }
! 497:
! 498: speed_cycletime = 1.0e-6 / (double) mhz;
! 499:
! 500: if (speed_option_verbose)
! 501: printf ("Using processor_info() %d mhz for cycle time %.3g\n",
! 502: mhz, speed_cycletime);
! 503: return 1;
! 504:
! 505: #else
! 506: return 0;
! 507: #endif
! 508: }
! 509:
! 510:
! 511: /* "get" is called repeatedly until it ticks over, just in case on a fast
! 512: processor it takes less than a microsecond, though this is probably
! 513: unlikely if it's a system call.
! 514:
! 515: speed_cyclecounter is called on the same side of the "get" for the start
! 516: and end measurements. It doesn't matter how long it takes from the "get"
! 517: sample to the cycles sample, since that period will cancel out in the
! 518: difference calculation (assuming it's the same each time).
! 519:
! 520: Letting the test run for more than a process time slice is probably only
! 521: going to reduce accuracy, especially for getrusage when the cycle counter
! 522: is real time, or for gettimeofday if the cycle counter is in fact process
! 523: time. Use CLK_TCK/2 as a reasonable stop.
! 524:
! 525: It'd be desirable to be quite accurate here. The default speed_precision
! 526: for a cycle counter is 10000 cycles, so to mix that with getrusage or
! 527: gettimeofday the frequency should be at least that accurate. But running
! 528: measurements for 10000 microseconds (or more) is too long. Be satisfied
! 529: with just a half clock tick (5000 microseconds usually). */
! 530:
! 531: #define FREQ_MEASURE_ONE(name, type, get, sec, usec) \
! 532: do { \
! 533: type st1, st, et1, et; \
! 534: unsigned sc[2], ec[2]; \
! 535: long dt, half_tick; \
! 536: double dc, cyc; \
! 537: \
! 538: half_tick = (1000000L / clk_tck()) / 2; \
! 539: \
! 540: get (st1); \
! 541: do { \
! 542: get (st); \
! 543: } while (usec(st) == usec(st1) && sec(st) == sec(st1)); \
! 544: \
! 545: speed_cyclecounter (sc); \
! 546: \
! 547: for (;;) \
! 548: { \
! 549: get (et1); \
! 550: do { \
! 551: get (et); \
! 552: } while (usec(et) == usec(et1) && sec(et) == sec(et1)); \
! 553: \
! 554: speed_cyclecounter (ec); \
! 555: \
! 556: dc = speed_cyclecounter_diff (ec, sc); \
! 557: \
! 558: /* allow secs to cancel before multiplying */ \
! 559: dt = sec(et) - sec(st); \
! 560: dt = dt * 100000L + (usec(et) - usec(st)); \
! 561: \
! 562: if (dt >= half_tick) \
! 563: break; \
! 564: } \
! 565: \
! 566: cyc = dt * 1e-6 / dc; \
! 567: \
! 568: if (speed_option_verbose >= 2) \
! 569: printf ("freq_measure_%s_one() dc=%.6g dt=%ld cyc=%.6g\n", \
! 570: name, dc, dt, cyc); \
! 571: \
! 572: return dt * 1e-6 / dc; \
! 573: \
! 574: } while (0)
! 575:
! 576: #if HAVE_SPEED_CYCLECOUNTER && HAVE_GETTIMEOFDAY
! 577: static double
! 578: freq_measure_gettimeofday_one (void)
! 579: {
! 580: #define call_gettimeofday(t) gettimeofday (&(t), NULL)
! 581: #define timeval_tv_sec(t) ((t).tv_sec)
! 582: #define timeval_tv_usec(t) ((t).tv_usec)
! 583: FREQ_MEASURE_ONE ("gettimeofday", struct timeval,
! 584: call_gettimeofday, timeval_tv_sec, timeval_tv_usec);
! 585: }
! 586: #endif
! 587:
! 588: #if HAVE_SPEED_CYCLECOUNTER && HAVE_GETRUSAGE
! 589: static double
! 590: freq_measure_getrusage_one (void)
! 591: {
! 592: #define call_getrusage(t) getrusage (0, &(t))
! 593: #define rusage_tv_sec(t) ((t).ru_utime.tv_sec)
! 594: #define rusage_tv_usec(t) ((t).ru_utime.tv_usec)
! 595: FREQ_MEASURE_ONE ("getrusage", struct rusage,
! 596: call_getrusage, rusage_tv_sec, rusage_tv_usec);
! 597: }
! 598: #endif
! 599:
! 600:
! 601: /* MEASURE_MATCH is how many readings within MEASURE_TOLERANCE of each other
! 602: are required. This must be at least 2. */
! 603: #define MEASURE_MAX_ATTEMPTS 20
! 604: #define MEASURE_TOLERANCE 1.005 /* 0.5% */
! 605: #define MEASURE_MATCH 3
! 606:
! 607: static int
! 608: freq_measure (const char *name, double (*one) (void))
! 609: {
! 610: double t[MEASURE_MAX_ATTEMPTS];
! 611: int i, j;
! 612:
! 613: for (i = 0; i < numberof (t); i++)
! 614: {
! 615: t[i] = (*one) ();
! 616:
! 617: qsort (t, i+1, sizeof(t[0]), (qsort_function_t) double_cmp_ptr);
! 618: if (speed_option_verbose >= 3)
! 619: for (j = 0; j <= i; j++)
! 620: printf (" t[%d] is %.6g\n", j, t[j]);
! 621:
! 622: for (j = 0; j+MEASURE_MATCH-1 <= i; j++)
! 623: {
! 624: if (t[j+MEASURE_MATCH-1] <= t[j] * MEASURE_TOLERANCE)
! 625: {
! 626: /* use the average of the range found */
! 627: speed_cycletime = (t[j+MEASURE_MATCH-1] + t[j]) / 2.0;
! 628: if (speed_option_verbose)
! 629: printf ("Using %s() measured cycle counter %.4g (%.2f MHz)\n",
! 630: name, speed_cycletime, 1e-6/speed_cycletime);
! 631: return 1;
! 632: }
! 633: }
! 634: }
! 635: return 0;
! 636: }
! 637:
! 638: static int
! 639: freq_measure_getrusage (int help)
! 640: {
! 641: #if HAVE_SPEED_CYCLECOUNTER && HAVE_GETRUSAGE
! 642: if (! getrusage_microseconds_p ())
! 643: return 0;
! 644: if (! cycles_works_p ())
! 645: return 0;
! 646:
! 647: HELP ("cycle counter measured with microsecond getrusage()");
! 648:
! 649: return freq_measure ("getrusage", freq_measure_getrusage_one);
! 650: #else
! 651: return 0;
! 652: #endif
! 653: }
! 654:
! 655: static int
! 656: freq_measure_gettimeofday (int help)
! 657: {
! 658: #if HAVE_SPEED_CYCLECOUNTER && HAVE_GETTIMEOFDAY
! 659: if (! gettimeofday_microseconds_p ())
! 660: return 0;
! 661: if (! cycles_works_p ())
! 662: return 0;
! 663:
! 664: HELP ("cycle counter measured with microsecond gettimeofday()");
! 665:
! 666: return freq_measure ("gettimeofday", freq_measure_gettimeofday_one);
! 667: #else
! 668: return 0;
! 669: #endif
! 670: }
! 671:
! 672:
! 673: /* Each function returns 1 if it succeeds in setting speed_cycletime, or 0
! 674: if not.
! 675:
! 676: In general system call tests are first since they're fast, then file
! 677: tests, then tests running programs. Necessary exceptions to this rule
! 678: are noted. The measuring is last since it's time consuming, and rather
! 679: wasteful of cpu. */
! 680:
! 681: static int
! 682: freq_all (int help)
! 683: {
! 684: return
! 685: /* This should be first, so an environment variable can override
! 686: anything the system gives. */
! 687: freq_environment (help)
! 688:
! 689: || freq_sysctl_hw_model (help)
! 690: || freq_sysctl_hw_cpufrequency (help)
! 691: || freq_sysctlbyname_i586_freq (help)
! 692: || freq_sysctlbyname_tsc_freq (help)
! 693:
! 694: /* SCO openunix 8 puts a dummy pi_clock==16 in processor_info, so be
! 695: sure to check /etc/hw before that function. */
! 696: || freq_sco_etchw (help)
! 697:
! 698: || freq_processor_info (help)
! 699: || freq_proc_cpuinfo (help)
! 700: || freq_bsd_dmesg (help)
! 701: || freq_irix_hinv (help)
! 702: || freq_sunos_sysinfo (help)
! 703: || freq_measure_getrusage (help)
! 704: || freq_measure_gettimeofday (help);
! 705: };
! 706:
! 707:
! 708: void
! 709: speed_cycletime_init (void)
! 710: {
! 711: static int attempted = 0;
! 712:
! 713: if (attempted)
! 714: return;
! 715: attempted = 1;
! 716:
! 717: if (freq_all (0))
! 718: return;
! 719:
! 720: if (speed_option_verbose)
! 721: printf ("CPU frequency couldn't be determined\n");
! 722: }
! 723:
! 724:
! 725: void
! 726: speed_cycletime_fail (const char *str)
! 727: {
! 728: fprintf (stderr, "Measuring with: %s\n", speed_time_string);
! 729: fprintf (stderr, "%s,\n", str);
! 730: fprintf (stderr, "but none of the following are available,\n");
! 731: freq_all (1);
! 732: abort ();
! 733: }
! 734:
! 735: /* speed_time_init leaves speed_cycletime set to either 0.0 or 1.0 when the
! 736: CPU frequency is unknown. 0.0 is when the time base is in seconds, so
! 737: that's no good if cycles are wanted. 1.0 is when the time base is in
! 738: cycles, which conversely is no good if seconds are wanted. */
! 739: void
! 740: speed_cycletime_need_cycles (void)
! 741: {
! 742: speed_time_init ();
! 743: if (speed_cycletime == 0.0)
! 744: speed_cycletime_fail
! 745: ("Need to know CPU frequency to give times in cycles");
! 746: }
! 747: void
! 748: speed_cycletime_need_seconds (void)
! 749: {
! 750: speed_time_init ();
! 751: if (speed_cycletime == 1.0)
! 752: speed_cycletime_fail
! 753: ("Need to know CPU frequency to convert cycles to seconds");
! 754: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to freq.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / tune