Annotation of OpenXM_contrib/gmp/tune/speed.c, Revision 1.1
1.1 ! maekawa 1: /* Speed measuring program. */
! 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: /* Usage message is in the code below, run with no arguments to print it.
! 25: See README for interesting applications.
! 26:
! 27: To add a new routine foo(), create a speed_foo() function in the style of
! 28: the existing ones and add an entry in the routine[] array. Put FLAG_R if
! 29: speed_foo() wants an "r" parameter.
! 30:
! 31: The routines don't have help messages or descriptions, but most have
! 32: suggestive names. See the source code for full details.
! 33:
! 34: */
! 35:
! 36: #include "config.h"
! 37:
! 38: #if HAVE_GETOPT_H
! 39: #include <getopt.h> /* for getopt_long() */
! 40: #endif
! 41: #include <limits.h>
! 42: #include <stdio.h>
! 43: #include <stdlib.h>
! 44: #include <string.h>
! 45: #include <unistd.h> /* for getpid() */
! 46: #include <sys/time.h> /* for struct timeval for sys/resource.h */
! 47: #include <sys/resource.h> /* for getrusage() */
! 48:
! 49: #include "gmp.h"
! 50: #include "gmp-impl.h"
! 51:
! 52: #include "speed.h"
! 53:
! 54: #if !HAVE_DECL_OPTARG
! 55: extern char *optarg;
! 56: extern int optind, opterr;
! 57: #endif
! 58:
! 59: #if !HAVE_STRTOUL
! 60: #define strtoul(p,e,b) (unsigned long) strtol(p,e,b)
! 61: #endif
! 62:
! 63: #ifdef SPEED_EXTRA_PROTOS
! 64: SPEED_EXTRA_PROTOS
! 65: #endif
! 66:
! 67:
! 68: #define MPN_FILL(ptr, size, n) \
! 69: do { \
! 70: mp_size_t i; \
! 71: for (i = 0; i < size; i++) \
! 72: ptr[i] = n; \
! 73: } while (0)
! 74:
! 75: #define CMP_ABSOLUTE 1
! 76: #define CMP_RATIO 2
! 77: #define CMP_DIFFERENCE 3
! 78: #define CMP_DIFFPREV 4
! 79: int option_cmp = CMP_ABSOLUTE;
! 80:
! 81: #define UNIT_SECONDS 1
! 82: #define UNIT_CYCLES 2
! 83: #define UNIT_CYCLESPERLIMB 3
! 84: int option_unit = UNIT_SECONDS;
! 85:
! 86: #define DATA_RANDOM 1
! 87: #define DATA_RANDOM2 2
! 88: #define DATA_ZEROS 3
! 89: #define DATA_FFS 4
! 90: #define DATA_2FD 5
! 91: int option_data = DATA_RANDOM;
! 92:
! 93: int option_square = 0;
! 94: double option_factor = 0.0;
! 95: mp_size_t option_step = 1;
! 96: int option_gnuplot = 0;
! 97: char *option_gnuplot_basename;
! 98: struct size_array_t {
! 99: mp_size_t start, end;
! 100: } *size_array = NULL;
! 101: mp_size_t size_num = 0;
! 102: mp_size_t size_allocnum = 0;
! 103: int option_resource_usage = 0;
! 104: long option_seed = 123456789;
! 105:
! 106: struct speed_params sp;
! 107:
! 108: #define COLUMN_WIDTH 13 /* for the free-form output */
! 109:
! 110: #define FLAG_R (1<<0)
! 111: #define FLAG_R_OPTIONAL (1<<1)
! 112: #define FLAG_RSIZE (1<<2)
! 113:
! 114: const struct routine_t {
! 115: /* constants */
! 116: const char *name;
! 117: speed_function_t fun;
! 118: int flag;
! 119:
! 120: } routine[] = {
! 121:
! 122: { "noop", speed_noop },
! 123: { "noop_wxs", speed_noop_wxs },
! 124: { "noop_wxys", speed_noop_wxys },
! 125:
! 126: { "mpn_add_n", speed_mpn_add_n },
! 127: { "mpn_sub_n", speed_mpn_sub_n },
! 128: { "mpn_add_n_self", speed_mpn_add_n_self },
! 129: { "mpn_add_n_inplace", speed_mpn_add_n_inplace },
! 130:
! 131: { "mpn_addmul_1", speed_mpn_addmul_1, FLAG_R },
! 132: { "mpn_submul_1", speed_mpn_submul_1, FLAG_R },
! 133: { "mpn_mul_1", speed_mpn_mul_1, FLAG_R },
! 134:
! 135: { "mpn_divrem_1", speed_mpn_divrem_1, FLAG_R },
! 136: { "mpn_divrem_1f", speed_mpn_divrem_1f, FLAG_R },
! 137: #if HAVE_NATIVE_mpn_divrem_1c
! 138: { "mpn_divrem_1c", speed_mpn_divrem_1c, FLAG_R },
! 139: { "mpn_divrem_1cf", speed_mpn_divrem_1cf,FLAG_R },
! 140: #endif
! 141: { "mpn_mod_1", speed_mpn_mod_1, FLAG_R },
! 142: #if HAVE_NATIVE_mpn_mod_1c
! 143: { "mpn_mod_1c", speed_mpn_mod_1c, FLAG_R },
! 144: #endif
! 145:
! 146: { "mpn_divrem_2", speed_mpn_divrem_2, },
! 147: { "mpn_divexact_by3", speed_mpn_divexact_by3 },
! 148:
! 149: { "mpn_bz_divrem_n", speed_mpn_bz_divrem_n },
! 150: { "mpn_bz_divrem_sb", speed_mpn_bz_divrem_sb },
! 151: { "mpn_bz_tdiv_qr", speed_mpn_bz_tdiv_qr },
! 152:
! 153: { "mpn_lshift", speed_mpn_lshift, FLAG_R },
! 154: { "mpn_rshift", speed_mpn_rshift, FLAG_R },
! 155:
! 156: { "mpn_and_n", speed_mpn_and_n },
! 157: { "mpn_andn_n", speed_mpn_andn_n },
! 158: { "mpn_nand_n", speed_mpn_nand_n },
! 159: { "mpn_ior_n", speed_mpn_ior_n },
! 160: { "mpn_iorn_n", speed_mpn_iorn_n },
! 161: { "mpn_nior_n", speed_mpn_nior_n },
! 162: { "mpn_xor_n", speed_mpn_xor_n },
! 163: { "mpn_xnor_n", speed_mpn_xnor_n },
! 164:
! 165: { "mpn_popcount", speed_mpn_popcount },
! 166: { "mpn_hamdist", speed_mpn_hamdist },
! 167:
! 168: { "mpn_gcdext", speed_mpn_gcdext },
! 169: { "mpn_gcd", speed_mpn_gcd },
! 170: { "mpn_gcd_1", speed_mpn_gcd_1, FLAG_R_OPTIONAL },
! 171:
! 172: { "mpn_jacobi_base", speed_mpn_jacobi_base },
! 173:
! 174: { "mpn_mul_basecase", speed_mpn_mul_basecase, FLAG_R_OPTIONAL },
! 175: { "mpn_sqr_basecase", speed_mpn_sqr_basecase },
! 176:
! 177: { "mpn_mul_n", speed_mpn_mul_n },
! 178: { "mpn_sqr_n", speed_mpn_sqr_n },
! 179:
! 180: { "mpn_kara_mul_n", speed_mpn_kara_mul_n },
! 181: { "mpn_kara_sqr_n", speed_mpn_kara_sqr_n },
! 182: { "mpn_toom3_mul_n", speed_mpn_toom3_mul_n },
! 183: { "mpn_toom3_sqr_n", speed_mpn_toom3_sqr_n },
! 184: { "mpn_mul_fft_full", speed_mpn_mul_fft_full },
! 185: { "mpn_mul_fft_full_sqr", speed_mpn_mul_fft_full_sqr },
! 186:
! 187: { "mpn_mul_fft", speed_mpn_mul_fft, FLAG_R_OPTIONAL },
! 188: { "mpn_mul_fft_sqr", speed_mpn_mul_fft_sqr, FLAG_R_OPTIONAL },
! 189:
! 190: { "mpz_add", speed_mpz_add },
! 191: { "mpz_bin_uiui", speed_mpz_bin_uiui, FLAG_R_OPTIONAL },
! 192: { "mpz_fac_ui", speed_mpz_fac_ui },
! 193: { "mpz_fib_ui", speed_mpz_fib_ui },
! 194: { "mpz_powm", speed_mpz_powm },
! 195:
! 196: { "MPN_COPY", speed_MPN_COPY },
! 197: { "MPN_COPY_INCR", speed_MPN_COPY_INCR },
! 198: { "MPN_COPY_DECR", speed_MPN_COPY_DECR },
! 199: { "memcpy", speed_memcpy },
! 200:
! 201: { "modlimb_invert", speed_modlimb_invert },
! 202:
! 203: { "malloc_free", speed_malloc_free },
! 204: { "malloc_realloc_free", speed_malloc_realloc_free },
! 205: { "mp_allocate_free", speed_mp_allocate_free },
! 206: { "mp_allocate_reallocate_free", speed_mp_allocate_reallocate_free },
! 207: { "mpz_init_clear", speed_mpz_init_clear },
! 208: { "mpq_init_clear", speed_mpq_init_clear },
! 209: { "mpf_init_clear", speed_mpf_init_clear },
! 210: { "mpz_init_realloc_clear", speed_mpz_init_realloc_clear },
! 211:
! 212: { "umul_ppmm", speed_umul_ppmm, FLAG_R_OPTIONAL },
! 213: #if HAVE_NATIVE_mpn_umul_ppmm
! 214: { "mpn_umul_ppmm", speed_mpn_umul_ppmm, FLAG_R_OPTIONAL },
! 215: #endif
! 216:
! 217: { "udiv_qrnnd", speed_udiv_qrnnd, FLAG_R_OPTIONAL },
! 218: { "udiv_qrnnd_preinv", speed_udiv_qrnnd_preinv, FLAG_R_OPTIONAL },
! 219: { "udiv_qrnnd_preinv2norm", speed_udiv_qrnnd_preinv2norm, FLAG_R_OPTIONAL },
! 220: #if HAVE_NATIVE_mpn_udiv_qrnnd
! 221: { "mpn_udiv_qrnnd", speed_mpn_udiv_qrnnd, FLAG_R_OPTIONAL },
! 222: #endif
! 223:
! 224: #ifdef SPEED_EXTRA_ROUTINES
! 225: SPEED_EXTRA_ROUTINES
! 226: #endif
! 227: };
! 228:
! 229:
! 230: struct choice_t {
! 231: const struct routine_t *p;
! 232: int r;
! 233: double time;
! 234: int no_time;
! 235: double prev_time;
! 236: const char *name;
! 237: };
! 238: struct choice_t *choice;
! 239: int num_choices = 0;
! 240:
! 241:
! 242: void
! 243: data_fill (mp_ptr ptr, mp_size_t size)
! 244: {
! 245: switch (option_data) {
! 246: case DATA_RANDOM:
! 247: mpn_random (ptr, size);
! 248: break;
! 249: case DATA_RANDOM2:
! 250: mpn_random2 (ptr, size);
! 251: break;
! 252: case DATA_ZEROS:
! 253: MPN_ZERO (ptr, size);
! 254: break;
! 255: case DATA_FFS:
! 256: MPN_FILL (ptr, size, MP_LIMB_T_MAX);
! 257: break;
! 258: case DATA_2FD:
! 259: MPN_FILL (ptr, size, MP_LIMB_T_MAX);
! 260: ptr[0] -= 2;
! 261: break;
! 262: default:
! 263: abort();
! 264: /*NOTREACHED*/
! 265: }
! 266: }
! 267:
! 268: /* The code here handling the various combinations of output options isn't
! 269: too attractive, but it works and is fairly clean. */
! 270:
! 271: #define SIZE_TO_DIVISOR(n) \
! 272: (option_square == 1 ? (n)*(n) \
! 273: : option_square == 2 ? (n)*((n)+1)/2 \
! 274: : (n))
! 275:
! 276: void
! 277: run_one (FILE *fp, struct speed_params *s, mp_size_t prev_size)
! 278: {
! 279: const char *first_open_fastest, *first_open_notfastest, *first_close;
! 280: int i, fastest;
! 281: double fastest_time;
! 282: TMP_DECL (marker);
! 283:
! 284: TMP_MARK (marker);
! 285: sp.xp = SPEED_TMP_ALLOC_LIMBS (s->size, s->align_xp);
! 286: sp.yp = SPEED_TMP_ALLOC_LIMBS (s->size, s->align_yp);
! 287:
! 288: data_fill (s->xp, s->size);
! 289: data_fill (s->yp, s->size);
! 290:
! 291: if (prev_size == -1 && option_cmp == CMP_DIFFPREV)
! 292: {
! 293: first_open_fastest = "(#";
! 294: first_open_notfastest = " (";
! 295: first_close = ")";
! 296: }
! 297: else
! 298: {
! 299: first_open_fastest = "#";
! 300: first_open_notfastest = " ";
! 301: first_close = "";
! 302: }
! 303:
! 304: fastest = -1;
! 305: fastest_time = -1.0;
! 306: for (i = 0; i < num_choices; i++)
! 307: {
! 308: s->r = choice[i].r;
! 309: choice[i].time = speed_measure (choice[i].p->fun, s);
! 310: choice[i].no_time = (choice[i].time == -1.0);
! 311:
! 312:
! 313: /* Apply the effect of CMP_DIFFPREV, but the new choice[i].prev_time
! 314: is before any differences. */
! 315: {
! 316: double t;
! 317: t = choice[i].time;
! 318: if (t != -1.0 && option_cmp == CMP_DIFFPREV && prev_size != -1)
! 319: {
! 320: if (choice[i].prev_time == -1.0)
! 321: choice[i].no_time = 1;
! 322: else
! 323: choice[i].time = choice[i].time - choice[i].prev_time;
! 324: }
! 325: choice[i].prev_time = t;
! 326: }
! 327:
! 328: if (choice[i].no_time)
! 329: continue;
! 330:
! 331: /* Look for the fastest after CMP_DIFFPREV has been applied, but
! 332: before CMP_RATIO or CMP_DIFFERENCE. There's only a fastest shown
! 333: if there's more than one routine. */
! 334: if (num_choices > 1 && (fastest == -1 || choice[i].time < fastest_time))
! 335: {
! 336: fastest = i;
! 337: fastest_time = choice[i].time;
! 338: }
! 339:
! 340: if (option_cmp == CMP_DIFFPREV)
! 341: {
! 342: /* Conversion for UNIT_CYCLESPERLIMB differs in CMP_DIFFPREV. */
! 343: if (option_unit == UNIT_CYCLES)
! 344: choice[i].time /= speed_cycletime;
! 345: else if (option_unit == UNIT_CYCLESPERLIMB)
! 346: {
! 347: if (prev_size == -1)
! 348: choice[i].time /= speed_cycletime;
! 349: else
! 350: choice[i].time /= (speed_cycletime
! 351: * (SIZE_TO_DIVISOR(s->size)
! 352: - SIZE_TO_DIVISOR(prev_size)));
! 353: }
! 354: }
! 355: else
! 356: {
! 357: if (option_unit == UNIT_CYCLES)
! 358: choice[i].time /= speed_cycletime;
! 359: else if (option_unit == UNIT_CYCLESPERLIMB)
! 360: choice[i].time /= (speed_cycletime * SIZE_TO_DIVISOR(s->size));
! 361:
! 362: if (option_cmp == CMP_RATIO && i > 0)
! 363: {
! 364: /* A ratio isn't affected by the units chosen. */
! 365: if (choice[0].no_time || choice[0].time == 0.0)
! 366: choice[i].no_time = 1;
! 367: else
! 368: choice[i].time /= choice[0].time;
! 369: }
! 370: else if (option_cmp == CMP_DIFFERENCE && i > 0)
! 371: {
! 372: if (choice[0].no_time)
! 373: {
! 374: choice[i].no_time = 1;
! 375: continue;
! 376: }
! 377: choice[i].time -= choice[0].time;
! 378: }
! 379: }
! 380: }
! 381:
! 382: if (option_gnuplot)
! 383: {
! 384: /* In CMP_DIFFPREV, don't print anything for the first size, start
! 385: with the second where an actual difference is available.
! 386:
! 387: In CMP_RATIO, print the first column as 1.0.
! 388:
! 389: The 9 decimals printed is much more than the expected precision of
! 390: the measurements actually. */
! 391:
! 392: if (! (option_cmp == CMP_DIFFPREV && prev_size == -1))
! 393: {
! 394: fprintf (fp, "%-6ld ", s->size);
! 395: for (i = 0; i < num_choices; i++)
! 396: fprintf (fp, " %.9e",
! 397: choice[i].no_time ? 0.0
! 398: : (option_cmp == CMP_RATIO && i == 0) ? 1.0
! 399: : choice[i].time);
! 400: fprintf (fp, "\n");
! 401: }
! 402: }
! 403: else
! 404: {
! 405: fprintf (fp, "%-6ld ", s->size);
! 406: for (i = 0; i < num_choices; i++)
! 407: {
! 408: char buf[128];
! 409: int decimals;
! 410:
! 411: if (choice[i].no_time)
! 412: decimals = 0, choice[i].time = 0.0;
! 413: else if (option_unit == UNIT_CYCLESPERLIMB
! 414: || (option_cmp == CMP_RATIO && i > 0))
! 415: decimals = 4;
! 416: else if (option_unit == UNIT_CYCLES)
! 417: decimals = 2;
! 418: else
! 419: decimals = 9;
! 420:
! 421: sprintf (buf, "%s%.*f%s",
! 422: i == fastest ? first_open_fastest : first_open_notfastest,
! 423: decimals, choice[i].time, first_close);
! 424: fprintf (fp, " %*s", COLUMN_WIDTH, buf);
! 425: }
! 426: fprintf (fp, "\n");
! 427: }
! 428:
! 429: TMP_FREE (marker);
! 430: }
! 431:
! 432: void
! 433: run_all (FILE *fp)
! 434: {
! 435: mp_size_t prev_size;
! 436: int i;
! 437: TMP_DECL (marker);
! 438:
! 439: TMP_MARK (marker);
! 440: sp.xp_block = SPEED_TMP_ALLOC_LIMBS (SPEED_BLOCK_SIZE, sp.align_xp);
! 441: sp.yp_block = SPEED_TMP_ALLOC_LIMBS (SPEED_BLOCK_SIZE, sp.align_yp);
! 442:
! 443: data_fill (sp.xp_block, SPEED_BLOCK_SIZE);
! 444: data_fill (sp.yp_block, SPEED_BLOCK_SIZE);
! 445:
! 446: for (i = 0; i < size_num; i++)
! 447: {
! 448: sp.size = size_array[i].start;
! 449: prev_size = -1;
! 450: for (;;)
! 451: {
! 452: mp_size_t step;
! 453:
! 454: if (option_data == DATA_2FD && sp.size >= 2)
! 455: sp.xp[sp.size-1] = 2;
! 456:
! 457: run_one (fp, &sp, prev_size);
! 458: prev_size = sp.size;
! 459:
! 460: if (option_data == DATA_2FD && sp.size >= 2)
! 461: sp.xp[sp.size-1] = MP_LIMB_T_MAX;
! 462:
! 463: if (option_factor != 0.0)
! 464: {
! 465: step = (mp_size_t) (sp.size * option_factor - sp.size);
! 466: if (step < 1)
! 467: step = 1;
! 468: }
! 469: else
! 470: step = 1;
! 471: if (step < option_step)
! 472: step = option_step;
! 473:
! 474: sp.size += step;
! 475: if (sp.size > size_array[i].end)
! 476: break;
! 477: }
! 478: }
! 479:
! 480: TMP_FREE (marker);
! 481: }
! 482:
! 483:
! 484: FILE *
! 485: fopen_for_write (const char *filename)
! 486: {
! 487: FILE *fp;
! 488: if ((fp = fopen (filename, "w")) == NULL)
! 489: {
! 490: fprintf (stderr, "Cannot create %s\n", filename);
! 491: exit(1);
! 492: }
! 493: return fp;
! 494: }
! 495:
! 496: void
! 497: fclose_written (FILE *fp, const char *filename)
! 498: {
! 499: int err;
! 500:
! 501: err = ferror (fp);
! 502: err |= fclose (fp);
! 503:
! 504: if (err)
! 505: {
! 506: fprintf (stderr, "Error writing %s\n", filename);
! 507: exit(1);
! 508: }
! 509: }
! 510:
! 511:
! 512: void
! 513: run_gnuplot (void)
! 514: {
! 515: char *plot_filename;
! 516: char *data_filename;
! 517: FILE *fp;
! 518: int i;
! 519:
! 520: plot_filename = (char *) (*_mp_allocate_func)
! 521: (strlen (option_gnuplot_basename) + 20);
! 522: data_filename = (char *) (*_mp_allocate_func)
! 523: (strlen (option_gnuplot_basename) + 20);
! 524:
! 525: sprintf (plot_filename, "%s.gnuplot", option_gnuplot_basename);
! 526: sprintf (data_filename, "%s.data", option_gnuplot_basename);
! 527:
! 528: fp = fopen_for_write (plot_filename);
! 529:
! 530: /* Putting the key at the top left is usually good, and you can change it
! 531: interactively if it's not. */
! 532: fprintf (fp, "set key left\n");
! 533:
! 534: /* designed to make it possible to see crossovers easily */
! 535: fprintf (fp, "set data style linespoints\n");
! 536:
! 537: fprintf (fp, "plot ");
! 538: for (i = 0; i < num_choices; i++)
! 539: {
! 540: fprintf (fp, " \"%s\" using 1:%d", data_filename, i+2);
! 541: fprintf (fp, " title \"%s\"", choice[i].name);
! 542:
! 543: if (i != num_choices-1)
! 544: fprintf (fp, ", \\");
! 545: fprintf (fp, "\n");
! 546: }
! 547:
! 548: fprintf (fp, "load \"-\"\n");
! 549: fclose_written (fp, plot_filename);
! 550:
! 551: fp = fopen_for_write (data_filename);
! 552:
! 553: /* Unbuffered so you can see where the program was up to if it crashes or
! 554: you kill it. */
! 555: setbuf (fp, NULL);
! 556:
! 557: run_all (fp);
! 558: fclose_written (fp, data_filename);
! 559: }
! 560:
! 561:
! 562: /* Return a long with n many one bits (starting from the least significant) */
! 563: #define LONG_ONES(n) \
! 564: ((n) == BITS_PER_LONGINT ? -1L : (n) == 0 ? 0L : (1L << (n)) - 1)
! 565:
! 566: long
! 567: r_string (const char *s)
! 568: {
! 569: const char *s_orig = s;
! 570: long n;
! 571:
! 572: if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
! 573: n = strtoul (s+2, (char **) &s, 16);
! 574: else
! 575: n = strtol (s, (char **) &s, 10);
! 576:
! 577: if (strcmp (s, "bits") == 0)
! 578: {
! 579: mp_limb_t l;
! 580: if (n > BITS_PER_LONGINT)
! 581: {
! 582: fprintf (stderr, "%ld bit parameter invalid (max %d bits)\n",
! 583: n, BITS_PER_LONGINT);
! 584: exit (1);
! 585: }
! 586: mpn_random (&l, 1);
! 587: return (l | (1 << (n-1))) & LONG_ONES(n);
! 588: }
! 589: else if (strcmp (s, "ones") == 0)
! 590: {
! 591: if (n > BITS_PER_LONGINT)
! 592: {
! 593: fprintf (stderr, "%ld bit parameter invalid (max %d bits)\n",
! 594: n, BITS_PER_LONGINT);
! 595: exit (1);
! 596: }
! 597: return LONG_ONES (n);
! 598: }
! 599: else if (*s != '\0')
! 600: {
! 601: fprintf (stderr, "invalid r parameter: %s\n", s_orig);
! 602: exit (1);
! 603: }
! 604:
! 605: return n;
! 606: }
! 607:
! 608:
! 609: void
! 610: routine_find (struct choice_t *c, const char *s)
! 611: {
! 612: int i;
! 613: size_t nlen;
! 614:
! 615: for (i = 0; i < numberof (routine); i++)
! 616: {
! 617: nlen = strlen (routine[i].name);
! 618: if (memcmp (s, routine[i].name, nlen) != 0)
! 619: continue;
! 620:
! 621: if (s[nlen] == '.')
! 622: {
! 623: /* match, with a .r parameter */
! 624:
! 625: if (! (routine[i].flag & (FLAG_R|FLAG_R_OPTIONAL)))
! 626: {
! 627: fprintf (stderr, "Choice %s bad: doesn't take a \".<r>\" paramater\n", s);
! 628: exit (1);
! 629: }
! 630:
! 631: c->p = &routine[i];
! 632: c->r = r_string (s + nlen + 1);
! 633: c->name = s;
! 634: return;
! 635: }
! 636:
! 637: if (s[nlen] == '\0')
! 638: {
! 639: /* match, with no parameter */
! 640:
! 641: if (routine[i].flag & FLAG_R)
! 642: {
! 643: fprintf (stderr, "Choice %s bad: needs a \".<r>\" paramater\n", s);
! 644: exit (1);
! 645: }
! 646:
! 647: c->p = &routine[i];
! 648: c->r = 0;
! 649: c->name = s;
! 650: return;
! 651: }
! 652: }
! 653:
! 654: fprintf (stderr, "Choice %s unrecognised\n", s);
! 655: exit (1);
! 656: }
! 657:
! 658:
! 659: void
! 660: usage (void)
! 661: {
! 662: int i;
! 663:
! 664: printf ("\
! 665: Usage: speed [-options] -s size <routine>...\n\
! 666: Measure the speed of some routines.\n\
! 667: Times are in seconds, accuracy is shown.\n\
! 668: \n\
! 669: -p num set precision as number of time units each routine must run\n\
! 670: -s size[-end][,size[-end]]... sizes to measure\n\
! 671: single sizes or ranges, sep with comma or use multiple -s\n\
! 672: -t step step through sizes by given amount\n\
! 673: -f factor step through sizes by given factor (eg. 1.05)\n\
! 674: -r show times as ratios of the first routine\n\
! 675: -d show times as difference from the first routine\n\
! 676: -D show times as difference from previous size shown\n\
! 677: -c show times in CPU cycles\n\
! 678: -C show times in cycles per limb\n\
! 679: -u print resource usage (memory) at end\n\
! 680: -P name output plot files \"name.gnuplot\" and \"name.data\"\n\
! 681: -a <type> use given data: random(default), random2, zeros, ffs\n\
! 682: -x, -y, -w, -W <align> specify data alignments, sources and dests\n\
! 683: -o addrs print addresses of data blocks\n\
! 684: \n\
! 685: If both -t and -f are used, it means step by the factor or the step, whichever\n\
! 686: is greater.\n\
! 687: If both -C and -D are used, it means cycles per however many limbs between a\n\
! 688: size and the previous size.\n\
! 689: \n\
! 690: After running with -P, plots can be viewed with Gnuplot or Quickplot.\n\
! 691: \"gnuplot name.gnuplot\" (use \"set logscale xy; replot\" at the prompt for\n\
! 692: a log/log plot).\n\
! 693: \"quickplot -s name.data\" (has interactive zooming, and note -s is important\n\
! 694: when viewing more than one routine, it means same axis scales for all data).\n\
! 695: \n\
! 696: The available routines are as follows.\n\
! 697: \n\
! 698: ");
! 699:
! 700: for (i = 0; i < numberof (routine); i++)
! 701: {
! 702: if (routine[i].flag & FLAG_R)
! 703: printf ("\t%s.r\n", routine[i].name);
! 704: else if (routine[i].flag & FLAG_R_OPTIONAL)
! 705: printf ("\t%s (optional .r)\n", routine[i].name);
! 706: else
! 707: printf ("\t%s\n", routine[i].name);
! 708: }
! 709:
! 710: printf ("\n\
! 711: Routines with a \".r\" need an extra parameter, for example mpn_lshift.6\n\
! 712: r should be in decimal, or use 0xN for hexadecimal.\n\
! 713: Special forms for r are Nbits for a random N bit number, and Nones for N one\n\
! 714: bits.\n\
! 715: \n\
! 716: Times for sizes out of the range accepted by a routine are shown as 0.\n\
! 717: The fastest routine at each size is marked with a # (free form output only).\n\
! 718: \n\
! 719: %s\
! 720: \n\
! 721: Gnuplot home page http://www.cs.dartmouth.edu/gnuplot_info.html\n\
! 722: Quickplot home page http://www.kachinatech.com/~quickplot\n\
! 723: ", speed_time_string);
! 724: }
! 725:
! 726: int
! 727: main (int argc, char *argv[])
! 728: {
! 729: #define OPTION_ALIGN 1000
! 730: #if HAVE_GETOPT_LONG
! 731: static const struct option longopts[] = {
! 732: { "align", required_argument, NULL, OPTION_ALIGN },
! 733: { "align-x", required_argument, NULL, 'x' },
! 734: { "align-y", required_argument, NULL, 'y' },
! 735: { "align-w", required_argument, NULL, 'w' },
! 736: { "align-w2", required_argument, NULL, 'W' },
! 737: { "data", required_argument, NULL, 'a' },
! 738: { "cycles", no_argument, NULL, 'c' },
! 739: { "cycles-per-limb", no_argument, NULL, 'C' },
! 740: { "diff", no_argument, NULL, 'd' },
! 741: { "diff-prev", no_argument, NULL, 'D' },
! 742: { "difference", no_argument, NULL, 'd' },
! 743: { "difference-prev", no_argument, NULL, 'D' },
! 744: { "factor", required_argument, NULL, 'f' },
! 745: { "plot", no_argument, NULL, 'P' },
! 746: { "precision", required_argument, NULL, 'p' },
! 747: { "ratio", no_argument, NULL, 'r' },
! 748: { "randomize", no_argument, NULL, 'R' },
! 749: { "sizes", required_argument, NULL, 's' },
! 750: { "step", required_argument, NULL, 't' },
! 751: { "resources", required_argument, NULL, 'u' },
! 752: { "uncached", no_argument, NULL, 'z' },
! 753: { NULL }
! 754: };
! 755: #endif
! 756:
! 757: int i;
! 758: int opt;
! 759:
! 760: /* Unbuffered so output goes straight out when directed to a pipe or file
! 761: and isn't lost if you kill the program half way. */
! 762: setbuf (stdout, NULL);
! 763:
! 764: #define OPTSTRING "a:CcDdEFf:o:p:P:rRs:t:ux:y:w:W:z"
! 765: #if HAVE_GETOPT_LONG
! 766: while ((opt = getopt_long(argc, argv, OPTSTRING, longopts, NULL))
! 767: != EOF)
! 768: #else
! 769: while ((opt = getopt(argc, argv, OPTSTRING)) != EOF)
! 770: #endif
! 771: {
! 772: switch (opt) {
! 773: case 'a':
! 774: if (strcmp (optarg, "random") == 0) option_data = DATA_RANDOM;
! 775: else if (strcmp (optarg, "random2") == 0) option_data = DATA_RANDOM2;
! 776: else if (strcmp (optarg, "zeros") == 0) option_data = DATA_ZEROS;
! 777: else if (strcmp (optarg, "ffs") == 0) option_data = DATA_FFS;
! 778: else if (strcmp (optarg, "2fd") == 0) option_data = DATA_2FD;
! 779: else
! 780: {
! 781: fprintf (stderr, "unrecognised data option: %s\n", optarg);
! 782: exit (1);
! 783: }
! 784: break;
! 785: case 'C':
! 786: if (option_unit != UNIT_SECONDS) goto bad_unit;
! 787: option_unit = UNIT_CYCLESPERLIMB;
! 788: break;
! 789: case 'c':
! 790: if (option_unit != UNIT_SECONDS)
! 791: {
! 792: bad_unit:
! 793: fprintf (stderr, "cannot use more than one of -c, -C\n");
! 794: exit (1);
! 795: }
! 796: option_unit = UNIT_CYCLES;
! 797: break;
! 798: case 'D':
! 799: if (option_cmp != CMP_ABSOLUTE) goto bad_cmp;
! 800: option_cmp = CMP_DIFFPREV;
! 801: break;
! 802: case 'd':
! 803: if (option_cmp != CMP_ABSOLUTE)
! 804: {
! 805: bad_cmp:
! 806: fprintf (stderr, "cannot use more than one of -d, -D, -r\n");
! 807: exit (1);
! 808: }
! 809: option_cmp = CMP_DIFFERENCE;
! 810: break;
! 811: case 'E':
! 812: option_square = 1;
! 813: break;
! 814: case 'F':
! 815: option_square = 2;
! 816: break;
! 817: case 'f':
! 818: option_factor = atof (optarg);
! 819: if (option_factor <= 1.0)
! 820: {
! 821: fprintf (stderr, "-f factor must be > 1.0\n");
! 822: exit (1);
! 823: }
! 824: break;
! 825: case 'o':
! 826: speed_option_set (optarg);
! 827: break;
! 828: case 'P':
! 829: option_gnuplot = 1;
! 830: option_gnuplot_basename = optarg;
! 831: break;
! 832: case 'p':
! 833: speed_precision = atoi (optarg);
! 834: break;
! 835: case 'R':
! 836: option_seed = time (NULL);
! 837: break;
! 838: case 'r':
! 839: if (option_cmp != CMP_ABSOLUTE)
! 840: goto bad_cmp;
! 841: option_cmp = CMP_RATIO;
! 842: break;
! 843: case 's':
! 844: {
! 845: char *s;
! 846: for (s = strtok (optarg, ","); s != NULL; s = strtok (NULL, ","))
! 847: {
! 848: if (size_num == size_allocnum)
! 849: {
! 850: size_array = (struct size_array_t *)
! 851: _mp_allocate_or_reallocate
! 852: (size_array,
! 853: size_allocnum * sizeof(size_array[0]),
! 854: (size_allocnum+10) * sizeof(size_array[0]));
! 855: size_allocnum += 10;
! 856: }
! 857: if (sscanf (s, "%ld-%ld",
! 858: &size_array[size_num].start,
! 859: &size_array[size_num].end) != 2)
! 860: {
! 861: size_array[size_num].start = size_array[size_num].end
! 862: = atol (s);
! 863: }
! 864:
! 865: if (size_array[size_num].start < 1
! 866: || size_array[size_num].end < 1
! 867: || size_array[size_num].start > size_array[size_num].end)
! 868: {
! 869: fprintf (stderr, "invalid size parameter: %s\n", s);
! 870: exit (1);
! 871: }
! 872:
! 873: size_num++;
! 874: }
! 875: }
! 876: break;
! 877: case 't':
! 878: option_step = atol (optarg);
! 879: if (option_step < 1)
! 880: {
! 881: fprintf (stderr, "-t step must be >= 1\n");
! 882: exit (1);
! 883: }
! 884: break;
! 885: case 'u':
! 886: option_resource_usage = 1;
! 887: break;
! 888: case 'z':
! 889: sp.cache = 1;
! 890: break;
! 891: case OPTION_ALIGN:
! 892: abort();
! 893: case 'x':
! 894: sp.align_xp = atol (optarg);
! 895: break;
! 896: case 'y':
! 897: sp.align_yp = atol (optarg);
! 898: break;
! 899: case 'w':
! 900: sp.align_wp = atol (optarg);
! 901: break;
! 902: case 'W':
! 903: sp.align_wp2 = atol (optarg);
! 904: break;
! 905: case '?':
! 906: exit(1);
! 907: }
! 908: }
! 909:
! 910: if (optind >= argc)
! 911: {
! 912: usage ();
! 913: exit (1);
! 914: }
! 915:
! 916: if (size_num == 0)
! 917: {
! 918: fprintf (stderr, "-s <size> must be specified\n");
! 919: exit (1);
! 920: }
! 921:
! 922: srand (option_seed);
! 923: srandom (option_seed);
! 924: srand48 (option_seed);
! 925:
! 926: choice = (struct choice_t *) (*_mp_allocate_func)
! 927: ((argc - optind) * sizeof(choice[0]));
! 928: for ( ; optind < argc; optind++)
! 929: {
! 930: struct choice_t c;
! 931: routine_find (&c, argv[optind]);
! 932: choice[num_choices] = c;
! 933: num_choices++;
! 934: }
! 935:
! 936: if ((option_cmp == CMP_RATIO || option_cmp == CMP_DIFFERENCE) &&
! 937: num_choices < 2)
! 938: {
! 939: fprintf (stderr, "WARNING, -d or -r does nothing when only one routine requested\n");
! 940: }
! 941:
! 942: speed_time_init ();
! 943:
! 944: if ((option_unit == UNIT_CYCLES || option_unit == UNIT_CYCLESPERLIMB)
! 945: && speed_cycletime == 1.0)
! 946: {
! 947: fprintf (stderr, "Times in cycles requested, but CPU frequency unknown.\n");
! 948: fprintf (stderr, "Use environment variable GMP_CPU_FREQUENCY in Hertz, eg. 450e6\n");
! 949: exit (1);
! 950: }
! 951:
! 952: if (option_gnuplot)
! 953: {
! 954: run_gnuplot ();
! 955: }
! 956: else
! 957: {
! 958: if (option_unit == UNIT_SECONDS)
! 959: printf ("overhead %.9f secs", speed_measure (speed_noop, NULL));
! 960: else
! 961: printf ("overhead %.2f cycles",
! 962: speed_measure (speed_noop, NULL) / speed_cycletime);
! 963: printf (", precision %d units of %.2e secs, cycle %.1e\n",
! 964: speed_precision, speed_unittime, speed_cycletime);
! 965:
! 966: printf (" ");
! 967: for (i = 0; i < num_choices; i++)
! 968: printf (" %*s", COLUMN_WIDTH, choice[i].name);
! 969: printf ("\n");
! 970:
! 971: run_all (stdout);
! 972: }
! 973:
! 974: if (option_resource_usage)
! 975: {
! 976: #if defined(linux)
! 977: /* This is Linux kernel specific. */
! 978: char buf[128];
! 979: sprintf (buf, "cat /proc/%d/status", getpid());
! 980: system (buf);
! 981:
! 982: #else
! 983: /* This doesn't give data sizes on Linux 2.0.36, only utime. */
! 984: struct rusage r;
! 985: if (getrusage (RUSAGE_SELF, &r) != 0)
! 986: perror ("getrusage");
! 987: else
! 988: printf ("utime %ld.%06ld data %ld stack %ld maxresident %ld\n",
! 989: r.ru_utime.tv_sec, r.ru_utime.tv_usec,
! 990: r.ru_idrss, r.ru_isrss, r.ru_ixrss);
! 991: #endif
! 992: }
! 993:
! 994: return 0;
! 995: }
! 996:
! 997:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to speed.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / tune