Annotation of OpenXM_contrib/gmp/tune/time.c, Revision 1.1
1.1 ! maekawa 1: /* Time routines for speed measurments. */
! 2:
! 3: /*
! 4: Copyright (C) 1999, 2000 Free Software Foundation, Inc.
! 5:
! 6: This file is part of the GNU MP Library.
! 7:
! 8: The GNU MP Library is free software; you can redistribute it and/or modify
! 9: it under the terms of the GNU Lesser General Public License as published by
! 10: the Free Software Foundation; either version 2.1 of the License, or (at your
! 11: option) any later version.
! 12:
! 13: The GNU MP Library is distributed in the hope that it will be useful, but
! 14: WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
! 15: or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
! 16: License for more details.
! 17:
! 18: You should have received a copy of the GNU Lesser General Public License
! 19: along with the GNU MP Library; see the file COPYING.LIB. If not, write to
! 20: the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
! 21: MA 02111-1307, USA.
! 22: */
! 23:
! 24: /* speed_time_init() - initialize timing things. speed_starttime() calls
! 25: this if it hasn't been done yet, so you only need to call this explicitly
! 26: if you want to use the global variables before the first measurement.
! 27:
! 28: speed_starttime() - start a time measurment.
! 29:
! 30: speed_endtime() - end a time measurment, return time taken, in seconds.
! 31:
! 32: speed_unittime - global variable with the unit of time measurement
! 33: accuracy, in seconds.
! 34:
! 35: speed_precision - global variable which is the intended accuracy of time
! 36: measurements. speed_measure() for instance runs target routines with
! 37: enough repetitions so it takes at least speed_unittime*speed_precision
! 38: seconds. A program can provide an option so the user can set this.
! 39:
! 40: speed_cycletime - the time in seconds for each CPU cycle, for example on
! 41: a 100 MHz CPU this would be 1.0e-8. If the CPU frequency is unknown,
! 42: speed_cycletime is 1.0. See speed_cycletime_init().
! 43:
! 44: speed_time_string - a string describing the time method in use.
! 45:
! 46:
! 47: Enhancements:
! 48:
! 49: Add support for accurate timing on more CPUs, machines and systems.
! 50:
! 51: Extend automatic CPU frequency determination to more kernels and systems.
! 52:
! 53: */
! 54:
! 55:
! 56: #include <stdio.h>
! 57: #include <stdlib.h> /* for getenv */
! 58: #if HAVE_UNISTD_H
! 59: #include <unistd.h>
! 60: #endif
! 61:
! 62: #include <sys/types.h>
! 63: #if HAVE_SYS_SYSCTL_H
! 64: #include <sys/sysctl.h>
! 65: #endif
! 66:
! 67: #include "gmp.h"
! 68: #include "gmp-impl.h"
! 69: #include "longlong.h"
! 70:
! 71: #include "speed.h"
! 72:
! 73:
! 74: #if HAVE_SPEED_CYCLECOUNTER
! 75: #define SPEED_USE_CYCLECOUNTER 1
! 76: #else
! 77: #define SPEED_USE_MICROSECOND_GETRUSAGE 0
! 78: #define SPEED_USE_MICROSECOND_GETTIMEOFDAY 1
! 79: #define SPEED_USE_TMS_UTIME 0
! 80: #endif
! 81:
! 82:
! 83: #define TIMEVAL_SECS(tp) \
! 84: ((double) (tp)->tv_sec + (double) (tp)->tv_usec * 1.0e-6)
! 85:
! 86:
! 87: /* Look for an environment variable for CPU clock frequency.
! 88: GMP_CPU_FREQUENCY should be in Hertz, in floating point form,
! 89: eg. "450e6". */
! 90: int
! 91: speed_cpu_frequency_environment (void)
! 92: {
! 93: char *e;
! 94:
! 95: e = getenv ("GMP_CPU_FREQUENCY");
! 96: if (e == NULL)
! 97: return 0;
! 98:
! 99: speed_cycletime = 1.0 / atof (e);
! 100: return 1;
! 101: }
! 102:
! 103:
! 104: /* On FreeBSD 3.3 the headers have #defines like CPU_WALLCLOCK under
! 105: CTL_MACHDEP but don't seem to have anything for machdep.tsc_freq or
! 106: machdep.i586_freq. Using the string forms with sysctlbyname() works
! 107: though, and lets libc worry about the defines and headers.
! 108:
! 109: FreeBSD 3.3 has tsc_freq, FreeBSD 2.2.8 has i586_freq instead.
! 110: The "sysctl -a" command prints everything available. */
! 111:
! 112: #if HAVE_SYSCTLBYNAME
! 113: int
! 114: speed_cpu_frequency_sysctlbyname (void)
! 115: {
! 116: unsigned val;
! 117: size_t valsize;
! 118:
! 119: valsize = sizeof(val);
! 120: if (sysctlbyname ("machdep.tsc_freq", &val, &valsize, NULL, 0) != 0
! 121: || valsize != sizeof(val))
! 122: {
! 123: valsize = sizeof(val);
! 124: if (sysctlbyname ("machdep.i586_freq", &val, &valsize, NULL, 0) != 0
! 125: || valsize != sizeof(val))
! 126: return 0;
! 127: }
! 128:
! 129: speed_cycletime = 1.0 / (double) val;
! 130: return 1;
! 131: }
! 132: #endif
! 133:
! 134:
! 135: /* Linux doesn't seem to have any system call to get the CPU frequency, at
! 136: least not in 2.0.x or 2.2.x, so it's necessary to read /proc/cpuinfo.
! 137:
! 138: i386 2.0.36 - "bogomips" is the CPU frequency.
! 139:
! 140: i386 2.2.13 - has both "cpu MHz" and "bogomips", and it's "cpu MHz" which
! 141: is the frequency.
! 142:
! 143: alpha 2.2.5 - "cycle frequency [Hz]" seems to be right, "BogoMIPS" is
! 144: very slightly different. */
! 145:
! 146: int
! 147: speed_cpu_frequency_proc_cpuinfo (void)
! 148: {
! 149: FILE *fp;
! 150: char buf[128];
! 151: double val;
! 152: int ret = 0;
! 153:
! 154: if ((fp = fopen ("/proc/cpuinfo", "r")) != NULL)
! 155: {
! 156: while (fgets (buf, sizeof (buf), fp) != NULL)
! 157: {
! 158: if (sscanf (buf, "cycle frequency [Hz] : %lf est.\n", &val) == 1)
! 159: {
! 160: speed_cycletime = 1.0 / val;
! 161: ret = 1;
! 162: break;
! 163: }
! 164: if (sscanf (buf, "cpu MHz : %lf\n", &val) == 1)
! 165: {
! 166: speed_cycletime = 1e-6 / val;
! 167: ret = 1;
! 168: break;
! 169: }
! 170: if (sscanf (buf, "bogomips : %lf\n", &val) == 1)
! 171: {
! 172: speed_cycletime = 1e-6 / val;
! 173: ret = 1;
! 174: break;
! 175: }
! 176: }
! 177: fclose (fp);
! 178: }
! 179: return ret;
! 180: }
! 181:
! 182:
! 183: /* SunOS /bin/sysinfo prints a line like:
! 184: cpu0 is a "75 MHz TI,TMS390Z55" CPU */
! 185:
! 186: #if HAVE_POPEN
! 187: int
! 188: speed_cpu_frequency_sunos_sysinfo (void)
! 189: {
! 190: FILE *fp;
! 191: char buf[128];
! 192: double val;
! 193: int ret = 0;
! 194:
! 195: /* Error messages are sent to /dev/null in case /bin/sysinfo doesn't
! 196: exist. The brackets are necessary for some shells (eg. ash). */
! 197: if ((fp = popen ("(/bin/sysinfo) 2>/dev/null", "r")) != NULL)
! 198: {
! 199: while (fgets (buf, sizeof (buf), fp) != NULL)
! 200: {
! 201: if (sscanf (buf, " cpu0 is a \"%lf MHz", &val) == 1)
! 202: {
! 203: speed_cycletime = 1e-6 / val;
! 204: ret = 1;
! 205: break;
! 206: }
! 207: }
! 208: pclose (fp);
! 209: }
! 210: return ret;
! 211: }
! 212: #endif
! 213:
! 214:
! 215: /* This is for Solaris. "psrinfo" is the command-line interface to
! 216: processor_info(). "prtconf -vp" gives similar information. */
! 217:
! 218: #if HAVE_PROCESSOR_INFO
! 219: #include <sys/unistd.h> /* for _SC_NPROCESSORS_CONF */
! 220: #include <sys/processor.h> /* for processor_info_t */
! 221: int
! 222: speed_cpu_frequency_processor_info (void)
! 223: {
! 224: processor_info_t p;
! 225: int i, n, mhz = 0;
! 226:
! 227: n = sysconf (_SC_NPROCESSORS_CONF);
! 228: for (i = 0; i < n; i++)
! 229: {
! 230: if (processor_info (i, &p) != 0)
! 231: continue;
! 232: if (p.pi_state != P_ONLINE)
! 233: continue;
! 234:
! 235: if (mhz != 0 && p.pi_clock != mhz)
! 236: {
! 237: fprintf (stderr,
! 238: "speed_cpu_frequency_processor_info(): There's more than one CPU and they have different clock speeds\n");
! 239: return 0;
! 240: }
! 241:
! 242: mhz = p.pi_clock;
! 243: }
! 244:
! 245: speed_cycletime = 1.0e-6 / (double) mhz;
! 246: return 1;
! 247: }
! 248: #endif
! 249:
! 250:
! 251: /* Each function returns 1 if it succeeds in setting speed_cycletime, or 0
! 252: if not. */
! 253:
! 254: static const struct {
! 255: int (*fun) _PROTO ((void));
! 256: const char *description;
! 257:
! 258: } speed_cpu_frequency_table[] = {
! 259:
! 260: /* This should be first, so an environment variable can override anything
! 261: the system gives. */
! 262: { speed_cpu_frequency_environment,
! 263: "environment variable GMP_CPU_FREQUENCY (in Hertz)" },
! 264:
! 265: #if HAVE_SYSCTLBYNAME
! 266: { speed_cpu_frequency_sysctlbyname,
! 267: "sysctlbyname() machdep.tsc_freq or machdep.i586_freq" },
! 268: #endif
! 269:
! 270: #if HAVE_PROCESSOR_INFO
! 271: { speed_cpu_frequency_processor_info,
! 272: "processor_info() pi_clock" },
! 273: #endif
! 274:
! 275: { speed_cpu_frequency_proc_cpuinfo,
! 276: "linux kernel /proc/cpuinfo file, cpu MHz or bogomips" },
! 277:
! 278: #if HAVE_POPEN
! 279: { speed_cpu_frequency_sunos_sysinfo,
! 280: "SunOS /bin/sysinfo program cpu0 output" },
! 281: #endif
! 282: };
! 283:
! 284:
! 285: int
! 286: speed_cycletime_init (void)
! 287: {
! 288: int i;
! 289:
! 290: for (i = 0; i < numberof (speed_cpu_frequency_table); i++)
! 291: if ((*speed_cpu_frequency_table[i].fun)())
! 292: return 1;
! 293:
! 294: fprintf (stderr,
! 295: "Cannot determine CPU frequency, need one of the following\n");
! 296: for (i = 0; i < numberof (speed_cpu_frequency_table); i++)
! 297: fprintf (stderr, "\t- %s\n", speed_cpu_frequency_table[i].description);
! 298:
! 299: return 0;
! 300: }
! 301:
! 302:
! 303: /* ---------------------------------------------------------------------- */
! 304: #if SPEED_USE_CYCLECOUNTER
! 305:
! 306: const char *speed_time_string
! 307: = "Time measurements using CPU cycle counter.\n";
! 308:
! 309: /* bigish value because we have a fast timer */
! 310: int speed_precision = 10000;
! 311:
! 312: double speed_unittime;
! 313: double speed_cycletime;
! 314:
! 315: static int speed_time_initialized = 0;
! 316: static unsigned speed_starttime_save[2];
! 317:
! 318: /* Knowing the CPU frequency is mandatory, so cycles can be converted to
! 319: seconds. */
! 320: void
! 321: speed_time_init (void)
! 322: {
! 323: if (speed_time_initialized)
! 324: return;
! 325: speed_time_initialized = 1;
! 326:
! 327: if (!speed_cycletime_init ())
! 328: exit (1);
! 329:
! 330: speed_unittime = speed_cycletime;
! 331: }
! 332:
! 333: void
! 334: speed_starttime (void)
! 335: {
! 336: if (!speed_time_initialized)
! 337: speed_time_init ();
! 338: speed_cyclecounter (speed_starttime_save);
! 339: }
! 340:
! 341: #define M_2POWU ((double) (1L << (BITS_PER_INT-2)) * 4.0)
! 342: #define M_2POW32 4294967296.0
! 343:
! 344: double
! 345: speed_endtime (void)
! 346: {
! 347: unsigned endtime[2], e0;
! 348: double t;
! 349:
! 350: speed_cyclecounter (endtime);
! 351:
! 352: /* This still works even if speed_cyclecounter() puts a value bigger than
! 353: 32-bits in the low word. The start and end values are allowed to
! 354: cancel in uints in case a uint is more than the 53 bits that will
! 355: normally fit in a double. */
! 356: e0 = endtime[0] - speed_starttime_save[0];
! 357: t = e0 - (e0 > endtime[0] ? M_2POWU : 0);
! 358: t += (endtime[1] - speed_starttime_save[1]) * M_2POW32;
! 359:
! 360: return t * speed_unittime;
! 361: }
! 362:
! 363: #endif
! 364:
! 365:
! 366: /* ---------------------------------------------------------------------- */
! 367: #if SPEED_USE_MICROSECOND_GETRUSAGE
! 368: #include <sys/types.h>
! 369: #include <sys/time.h>
! 370: #include <sys/resource.h>
! 371:
! 372: const char *speed_time_string
! 373: = "Time measurements using microsecond accurate getrusage.\n";
! 374:
! 375: int speed_precision = 1000;
! 376:
! 377: double speed_unittime = 1.0e-6;
! 378: double speed_cycletime = 1.0;
! 379:
! 380: static struct rusage speed_starttime_save;
! 381: static int speed_time_initialized = 0;
! 382:
! 383: void
! 384: speed_time_init (void)
! 385: {
! 386: if (speed_time_initialized)
! 387: return;
! 388: speed_time_initialized = 1;
! 389:
! 390: speed_cycletime_init ();
! 391: }
! 392:
! 393: void
! 394: speed_starttime (void)
! 395: {
! 396: if (!speed_time_initialized)
! 397: speed_time_init ();
! 398:
! 399: getrusage (0, &speed_starttime_save);
! 400: }
! 401:
! 402: double
! 403: speed_endtime (void)
! 404: {
! 405: struct rusage r;
! 406:
! 407: getrusage (0, &r);
! 408: return TIMEVAL_SECS (&r.ru_utime)
! 409: - TIMEVAL_SECS (&speed_starttime_save.ru_utime);
! 410: }
! 411: #endif
! 412:
! 413:
! 414: /* ---------------------------------------------------------------------- */
! 415: #if SPEED_USE_MICROSECOND_GETTIMEOFDAY
! 416: /* This method is for systems with a microsecond accurate gettimeofday().
! 417:
! 418: A dummy timezone parameter is always given to gettimeofday(), in case it
! 419: doesn't allow NULL. */
! 420:
! 421: #include <sys/time.h>
! 422:
! 423: const char *speed_time_string
! 424: = "Time measurements using microsecond accurate gettimeofday.\n";
! 425:
! 426: /* highish value because we have an accurate timer */
! 427: int speed_precision = 1000;
! 428:
! 429: double speed_unittime = 1.0e-6;
! 430: double speed_cycletime = 1.0;
! 431:
! 432: static struct timeval speed_starttime_save;
! 433: static int speed_time_initialized = 0;
! 434:
! 435: void
! 436: speed_time_init (void)
! 437: {
! 438: if (speed_time_initialized)
! 439: return;
! 440: speed_time_initialized = 1;
! 441:
! 442: speed_cycletime_init ();
! 443: }
! 444:
! 445: void
! 446: speed_starttime (void)
! 447: {
! 448: struct timezone tz;
! 449: if (!speed_time_initialized)
! 450: speed_time_init ();
! 451:
! 452: gettimeofday (&speed_starttime_save, &tz);
! 453: }
! 454:
! 455: double
! 456: speed_endtime (void)
! 457: {
! 458: struct timeval t;
! 459: struct timezone tz;
! 460:
! 461: gettimeofday (&t, &tz);
! 462: return TIMEVAL_SECS (&t) - TIMEVAL_SECS (&speed_starttime_save);
! 463: }
! 464:
! 465: #endif
! 466:
! 467:
! 468: /* ---------------------------------------------------------------------- */
! 469: #if SPEED_USE_TMS_UTIME
! 470: /* You're in trouble if you have to use this method. Speed measurments and
! 471: threshold tuning are going to take a long time. */
! 472:
! 473: #if STDC_HEADERS
! 474: #include <errno.h> /* for errno */
! 475: #include <string.h> /* for strerror */
! 476: #endif
! 477: #if HAVE_UNISTD_H
! 478: #include <unistd.h> /* for sysconf */
! 479: #endif
! 480: #include <sys/times.h> /* for times */
! 481:
! 482: const char *speed_time_string
! 483: = "Time measurements using tms_utime.\n";
! 484:
! 485:
! 486: /* lowish default value so we don't take days and days to do tuning */
! 487: int speed_precision = 200;
! 488:
! 489: double speed_unittime;
! 490: double speed_cycletime = 1.0;
! 491:
! 492: static struct tms speed_starttime_save;
! 493: static int speed_time_initialized = 0;
! 494:
! 495: void
! 496: speed_time_init (void)
! 497: {
! 498: long clk_tck;
! 499:
! 500: if (speed_time_initialized)
! 501: return;
! 502: speed_time_initialized = 1;
! 503:
! 504: speed_cycletime_init ();
! 505:
! 506: #if HAVE_SYSCONF
! 507: clk_tck = sysconf (_SC_CLK_TCK);
! 508: if (clk_tck == -1L)
! 509: {
! 510: fprintf (stderr, "sysconf(_SC_CLK_TCK) not available: %s\n",
! 511: strerror(errno));
! 512: fprintf (stderr, "\tusing CLK_TCK instead\n");
! 513: clk_tck = CLK_TCK;
! 514: }
! 515: #else
! 516: clk_tck = CLK_TCK;
! 517: #endif
! 518:
! 519: speed_unittime = 1.0 / (double) clk_tck;
! 520: }
! 521:
! 522: /* Burn up CPU until a times() tms_utime tick boundary.
! 523: Doing so lets you know a measurement has started on a tick boundary,
! 524: effectively halving the uncertainty in the measurement.
! 525: *t1 gets the start times() values the caller should use. */
! 526: void
! 527: times_utime_boundary (struct tms *t1)
! 528: {
! 529: struct tms t2;
! 530: times (&t2);
! 531: do
! 532: times (t1);
! 533: while (t1->tms_utime == t2.tms_utime);
! 534: }
! 535:
! 536: void
! 537: speed_starttime (void)
! 538: {
! 539: if (!speed_time_initialized)
! 540: speed_time_init ();
! 541: times_utime_boundary (&speed_starttime_save);
! 542: }
! 543:
! 544: double
! 545: speed_endtime (void)
! 546: {
! 547: struct tms t;
! 548: times (&t);
! 549: return (t.tms_utime - speed_starttime_save.tms_utime) * speed_unittime;
! 550: }
! 551:
! 552: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to time.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / tune