开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 数学计算 > 查看源码
speed.c
资源名称：gmp-5.0.1.tar.gz　[点击查看]
上传用户：qaz666999
上传日期：2022-08-06
资源大小：2570k
文件大小：39k
源码类别：

数学计算

开发平台：

Unix_Linux

speed.c：源码内容
  1. /* Speed measuring program.
  3. Copyright 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2008, 2009, 2010 Free
  4. Software Foundation, Inc.
  6. This file is part of the GNU MP Library.
  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 3 of the License, or (at your
  11. option) any later version.
  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.
  18. You should have received a copy of the GNU Lesser General Public License
  19. along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.  */
  21. /* Usage message is in the code below, run with no arguments to print it.
  22.    See README for interesting applications.
  24.    To add a new routine foo(), create a speed_foo() function in the style of
  25.    the existing ones and add an entry in the routine[] array.  Put FLAG_R if
  26.    speed_foo() wants an "r" parameter.
  28.    The routines don't have help messages or descriptions, but most have
  29.    suggestive names.  See the source code for full details.
  31. */
  33. #include "config.h"
  35. #include <limits.h>
  36. #include <stdio.h>
  37. #include <stdlib.h>
  38. #include <string.h>
  40. #if HAVE_UNISTD_H
  41. #include <unistd.h>  /* for getpid, R_OK */
  42. #endif
  44. #if TIME_WITH_SYS_TIME
  45. # include <sys/time.h>  /* for struct timeval */
  46. # include <time.h>
  47. #else
  48. # if HAVE_SYS_TIME_H
  49. #  include <sys/time.h>
  50. # else
  51. #  include <time.h>
  52. # endif
  53. #endif
  55. #if HAVE_SYS_RESOURCE_H
  56. #include <sys/resource.h>  /* for getrusage() */
  57. #endif
  60. #include "gmp.h"
  61. #include "gmp-impl.h"
  62. #include "longlong.h"  /* for the benefit of speed-many.c */
  63. #include "tests.h"
  64. #include "speed.h"
  67. #if !HAVE_DECL_OPTARG
  68. extern char *optarg;
  69. extern int optind, opterr;
  70. #endif
  72. #if !HAVE_STRTOUL
  73. #define strtoul(p,e,b)  (unsigned long) strtol(p,e,b)
  74. #endif
  76. #ifdef SPEED_EXTRA_PROTOS
  77. SPEED_EXTRA_PROTOS
  78. #endif
  79. #ifdef SPEED_EXTRA_PROTOS2
  80. SPEED_EXTRA_PROTOS2
  81. #endif
  84. #define MPN_FILL(ptr, size, n)          
  85.   do {                                  
  86.     mp_size_t __i;                      
  87.     ASSERT ((size) >= 0);               
  88.     for (__i = 0; __i < (size); __i++)  
  89.       (ptr)[__i] = (n);                 
  90.   } while (0)
  93. #if GMP_LIMB_BITS == 32
  94. #define GMP_NUMB_0xAA  (CNST_LIMB(0xAAAAAAAA) & GMP_NUMB_MASK)
  95. #endif
  96. #if GMP_LIMB_BITS == 64
  97. #define GMP_NUMB_0xAA  (CNST_LIMB(0xAAAAAAAAAAAAAAAA) & GMP_NUMB_MASK)
  98. #endif
  101. #define CMP_ABSOLUTE     1
  102. #define CMP_RATIO        2
  103. #define CMP_DIFFERENCE   3
  104. #define CMP_DIFFPREV     4
  105. int  option_cmp = CMP_ABSOLUTE;
  107. #define UNIT_SECONDS        1
  108. #define UNIT_CYCLES         2
  109. #define UNIT_CYCLESPERLIMB  3
  110. int  option_unit = UNIT_SECONDS;
  112. #define DATA_RANDOM   1
  113. #define DATA_RANDOM2  2
  114. #define DATA_ZEROS    3
  115. #define DATA_AAS      4
  116. #define DATA_FFS      5
  117. #define DATA_2FD      6
  118. int  option_data = DATA_RANDOM;
  120. int        option_square = 0;
  121. double     option_factor = 0.0;
  122. mp_size_t  option_step = 1;
  123. int        option_gnuplot = 0;
  124. char      *option_gnuplot_basename;
  125. struct size_array_t {
  126.   mp_size_t start, end;
  127. } *size_array = NULL;
  128. mp_size_t  size_num = 0;
  129. mp_size_t  size_allocnum = 0;
  130. int        option_resource_usage = 0;
  131. long       option_seed = 123456789;
  133. struct speed_params  sp;
  135. #define COLUMN_WIDTH  13  /* for the free-form output */
  137. #define FLAG_R            (1<<0)  /* require ".r" */
  138. #define FLAG_R_OPTIONAL   (1<<1)  /* optional ".r" */
  139. #define FLAG_RSIZE        (1<<2)
  140. #define FLAG_NODATA       (1<<3)  /* don't alloc xp, yp */
  142. const struct routine_t {
  143.   /* constants */
  144.   const char        *name;
  145.   speed_function_t  fun;
  146.   int               flag;
  147. } routine[] = {
  149.   { "noop",              speed_noop                 },
  150.   { "noop_wxs",          speed_noop_wxs             },
  151.   { "noop_wxys",         speed_noop_wxys            },
  153.   { "mpn_add_n",         speed_mpn_add_n,     FLAG_R_OPTIONAL },
  154.   { "mpn_sub_n",         speed_mpn_sub_n,     FLAG_R_OPTIONAL },
  156. #if HAVE_NATIVE_mpn_add_n_sub_n
  157.   { "mpn_add_n_sub_n",      speed_mpn_add_n_sub_n,     FLAG_R_OPTIONAL },
  158. #endif
  160.   { "mpn_addmul_1",      speed_mpn_addmul_1,  FLAG_R },
  161.   { "mpn_submul_1",      speed_mpn_submul_1,  FLAG_R },
  162. #if HAVE_NATIVE_mpn_addmul_2
  163.   { "mpn_addmul_2",      speed_mpn_addmul_2,  FLAG_R_OPTIONAL },
  164. #endif
  165. #if HAVE_NATIVE_mpn_addmul_3
  166.   { "mpn_addmul_3",      speed_mpn_addmul_3,  FLAG_R_OPTIONAL },
  167. #endif
  168. #if HAVE_NATIVE_mpn_addmul_4
  169.   { "mpn_addmul_4",      speed_mpn_addmul_4,  FLAG_R_OPTIONAL },
  170. #endif
  171. #if HAVE_NATIVE_mpn_addmul_5
  172.   { "mpn_addmul_5",      speed_mpn_addmul_5,  FLAG_R_OPTIONAL },
  173. #endif
  174. #if HAVE_NATIVE_mpn_addmul_6
  175.   { "mpn_addmul_6",      speed_mpn_addmul_6,  FLAG_R_OPTIONAL },
  176. #endif
  177. #if HAVE_NATIVE_mpn_addmul_7
  178.   { "mpn_addmul_7",      speed_mpn_addmul_7,  FLAG_R_OPTIONAL },
  179. #endif
  180. #if HAVE_NATIVE_mpn_addmul_8
  181.   { "mpn_addmul_8",      speed_mpn_addmul_8,  FLAG_R_OPTIONAL },
  182. #endif
  183.   { "mpn_mul_1",         speed_mpn_mul_1,     FLAG_R },
  184.   { "mpn_mul_1_inplace", speed_mpn_mul_1_inplace, FLAG_R },
  185. #if HAVE_NATIVE_mpn_mul_2
  186.   { "mpn_mul_2",         speed_mpn_mul_2,     FLAG_R_OPTIONAL },
  187. #endif
  188. #if HAVE_NATIVE_mpn_mul_3
  189.   { "mpn_mul_3",         speed_mpn_mul_3,     FLAG_R_OPTIONAL },
  190. #endif
  191. #if HAVE_NATIVE_mpn_mul_4
  192.   { "mpn_mul_4",         speed_mpn_mul_4,     FLAG_R_OPTIONAL },
  193. #endif
  195.   { "mpn_divrem_1",      speed_mpn_divrem_1,  FLAG_R },
  196.   { "mpn_divrem_1f",     speed_mpn_divrem_1f, FLAG_R },
  197. #if HAVE_NATIVE_mpn_divrem_1c
  198.   { "mpn_divrem_1c",     speed_mpn_divrem_1c, FLAG_R },
  199.   { "mpn_divrem_1cf",    speed_mpn_divrem_1cf,FLAG_R },
  200. #endif
  201.   { "mpn_mod_1",         speed_mpn_mod_1,     FLAG_R_OPTIONAL },
  202. #if HAVE_NATIVE_mpn_mod_1c
  203.   { "mpn_mod_1c",        speed_mpn_mod_1c,    FLAG_R_OPTIONAL },
  204. #endif
  205.   { "mpn_preinv_divrem_1",  speed_mpn_preinv_divrem_1,  FLAG_R },
  206.   { "mpn_preinv_divrem_1f", speed_mpn_preinv_divrem_1f, FLAG_R },
  207.   { "mpn_preinv_mod_1",  speed_mpn_preinv_mod_1, FLAG_R },
  209.   { "mpn_mod_1_1",       speed_mpn_mod_1_1,       FLAG_R_OPTIONAL },
  210.   { "mpn_mod_1s_2",      speed_mpn_mod_1_2,       FLAG_R_OPTIONAL },
  211.   { "mpn_mod_1s_3",      speed_mpn_mod_1_3,       FLAG_R_OPTIONAL },
  212.   { "mpn_mod_1s_4",      speed_mpn_mod_1_4,       FLAG_R_OPTIONAL },
  214.   { "mpn_divrem_1_div",  speed_mpn_divrem_1_div,  FLAG_R },
  215.   { "mpn_divrem_1_inv",  speed_mpn_divrem_1_inv,  FLAG_R },
  216.   { "mpn_divrem_1f_div", speed_mpn_divrem_1f_div, FLAG_R },
  217.   { "mpn_divrem_1f_inv", speed_mpn_divrem_1f_inv, FLAG_R },
  218.   { "mpn_mod_1_div",     speed_mpn_mod_1_div,     FLAG_R },
  219.   { "mpn_mod_1_inv",     speed_mpn_mod_1_inv,     FLAG_R },
  221.   { "mpn_divrem_2",      speed_mpn_divrem_2,        },
  222.   { "mpn_divrem_2_div",  speed_mpn_divrem_2_div,    },
  223.   { "mpn_divrem_2_inv",  speed_mpn_divrem_2_inv,    },
  225.   { "mpn_divexact_1",    speed_mpn_divexact_1,    FLAG_R },
  226.   { "mpn_divexact_by3",  speed_mpn_divexact_by3          },
  228.   { "mpn_bdiv_q_1",      speed_mpn_bdiv_q_1,      FLAG_R_OPTIONAL },
  229.   { "mpn_pi1_bdiv_q_1",  speed_mpn_pi1_bdiv_q_1,  FLAG_R_OPTIONAL },
  230.   { "mpn_bdiv_dbm1c",    speed_mpn_bdiv_dbm1c,    FLAG_R_OPTIONAL },
  232. #if HAVE_NATIVE_mpn_modexact_1_odd
  233.   { "mpn_modexact_1_odd",  speed_mpn_modexact_1_odd,  FLAG_R },
  234. #endif
  235.   { "mpn_modexact_1c_odd", speed_mpn_modexact_1c_odd, FLAG_R },
  237. #if GMP_NUMB_BITS % 4 == 0
  238.   { "mpn_mod_34lsub1",   speed_mpn_mod_34lsub1 },
  239. #endif
  241.   { "mpn_lshift",        speed_mpn_lshift, FLAG_R   },
  242.   { "mpn_lshiftc",       speed_mpn_lshiftc, FLAG_R   },
  243.   { "mpn_rshift",        speed_mpn_rshift, FLAG_R   },
  245.   { "mpn_and_n",         speed_mpn_and_n,  FLAG_R_OPTIONAL },
  246.   { "mpn_andn_n",        speed_mpn_andn_n, FLAG_R_OPTIONAL },
  247.   { "mpn_nand_n",        speed_mpn_nand_n, FLAG_R_OPTIONAL },
  248.   { "mpn_ior_n",         speed_mpn_ior_n,  FLAG_R_OPTIONAL },
  249.   { "mpn_iorn_n",        speed_mpn_iorn_n, FLAG_R_OPTIONAL },
  250.   { "mpn_nior_n",        speed_mpn_nior_n, FLAG_R_OPTIONAL },
  251.   { "mpn_xor_n",         speed_mpn_xor_n,  FLAG_R_OPTIONAL },
  252.   { "mpn_xnor_n",        speed_mpn_xnor_n, FLAG_R_OPTIONAL },
  253.   { "mpn_com",           speed_mpn_com              },
  255.   { "mpn_popcount",      speed_mpn_popcount         },
  256.   { "mpn_hamdist",       speed_mpn_hamdist          },
  258.   { "mpn_matrix22_mul",  speed_mpn_matrix22_mul     },
  260.   { "mpn_hgcd",          speed_mpn_hgcd             },
  261.   { "mpn_hgcd_lehmer",   speed_mpn_hgcd_lehmer      },
  263.   { "mpn_gcd_1",         speed_mpn_gcd_1,  FLAG_R_OPTIONAL },
  264.   { "mpn_gcd_1N",        speed_mpn_gcd_1N, FLAG_R_OPTIONAL },
  266.   { "mpn_gcd",           speed_mpn_gcd                    },
  267. #if 0
  268.   { "mpn_gcd_binary",    speed_mpn_gcd_binary             },
  269.   { "mpn_gcd_accel",     speed_mpn_gcd_accel              },
  270.   { "find_a",            speed_find_a,        FLAG_NODATA },
  271. #endif
  273.   { "mpn_gcdext",            speed_mpn_gcdext            },
  274.   { "mpn_gcdext_single",     speed_mpn_gcdext_single     },
  275.   { "mpn_gcdext_double",     speed_mpn_gcdext_double     },
  276.   { "mpn_gcdext_one_single", speed_mpn_gcdext_one_single },
  277.   { "mpn_gcdext_one_double", speed_mpn_gcdext_one_double },
  278. #if 0
  279.   { "mpn_gcdext_lehmer",     speed_mpn_gcdext_lehmer     },
  280. #endif
  281.   { "mpz_jacobi",        speed_mpz_jacobi           },
  282.   { "mpn_jacobi_base",   speed_mpn_jacobi_base      },
  283.   { "mpn_jacobi_base_1", speed_mpn_jacobi_base_1    },
  284.   { "mpn_jacobi_base_2", speed_mpn_jacobi_base_2    },
  285.   { "mpn_jacobi_base_3", speed_mpn_jacobi_base_3    },
  287.   { "mpn_mul",           speed_mpn_mul,         FLAG_R_OPTIONAL },
  288.   { "mpn_mul_basecase",  speed_mpn_mul_basecase,FLAG_R_OPTIONAL },
  289.   { "mpn_sqr_basecase",  speed_mpn_sqr_basecase     },
  290. #if HAVE_NATIVE_mpn_sqr_diagonal
  291.   { "mpn_sqr_diagonal",  speed_mpn_sqr_diagonal     },
  292. #endif
  294.   { "mpn_mul_n",         speed_mpn_mul_n            },
  295.   { "mpn_sqr",           speed_mpn_sqr              },
  297.   { "mpn_toom2_sqr",     speed_mpn_toom2_sqr        },
  298.   { "mpn_toom3_sqr",     speed_mpn_toom3_sqr        },
  299.   { "mpn_toom4_sqr",     speed_mpn_toom4_sqr        },
  300.   { "mpn_toom6_sqr",     speed_mpn_toom6_sqr        },
  301.   { "mpn_toom8_sqr",     speed_mpn_toom8_sqr        },
  302.   { "mpn_toom22_mul",    speed_mpn_toom22_mul       },
  303.   { "mpn_toom33_mul",    speed_mpn_toom33_mul       },
  304.   { "mpn_toom44_mul",    speed_mpn_toom44_mul       },
  305.   { "mpn_toom6h_mul",    speed_mpn_toom6h_mul       },
  306.   { "mpn_toom8h_mul",    speed_mpn_toom8h_mul       },
  307.   { "mpn_toom32_mul",    speed_mpn_toom32_mul       },
  308.   { "mpn_toom42_mul",    speed_mpn_toom42_mul       },
  309.   { "mpn_toom43_mul",    speed_mpn_toom43_mul       },
  310.   { "mpn_toom63_mul",    speed_mpn_toom63_mul       },
  311.   { "mpn_nussbaumer_mul",    speed_mpn_nussbaumer_mul    },
  312.   { "mpn_nussbaumer_mul_sqr",speed_mpn_nussbaumer_mul_sqr},
  313. #if WANT_OLD_FFT_FULL
  314.   { "mpn_mul_fft_full",      speed_mpn_mul_fft_full      },
  315.   { "mpn_mul_fft_full_sqr",  speed_mpn_mul_fft_full_sqr  },
  316. #endif
  317.   { "mpn_mul_fft",       speed_mpn_mul_fft,     FLAG_R_OPTIONAL },
  318.   { "mpn_mul_fft_sqr",   speed_mpn_mul_fft_sqr, FLAG_R_OPTIONAL },
  320.   { "mpn_mullo_n",        speed_mpn_mullo_n         },
  321.   { "mpn_mullo_basecase", speed_mpn_mullo_basecase  },
  323.   { "mpn_bc_mulmod_bnm1",      speed_mpn_bc_mulmod_bnm1      },
  324.   { "mpn_mulmod_bnm1",         speed_mpn_mulmod_bnm1         },
  325.   { "mpn_mulmod_bnm1_rounded", speed_mpn_mulmod_bnm1_rounded },
  326.   { "mpn_sqrmod_bnm1",         speed_mpn_sqrmod_bnm1         },
  328.   { "mpn_invert",              speed_mpn_invert              },
  329.   { "mpn_invertappr",          speed_mpn_invertappr          },
  330.   { "mpn_ni_invertappr",       speed_mpn_ni_invertappr       },
  331.   { "mpn_binvert",             speed_mpn_binvert             },
  333.   { "mpn_sbpi1_div_qr",        speed_mpn_sbpi1_div_qr,    FLAG_R_OPTIONAL},
  334.   { "mpn_dcpi1_div_qr",        speed_mpn_dcpi1_div_qr,    FLAG_R_OPTIONAL},
  335.   { "mpn_mu_div_qr",           speed_mpn_mu_div_qr,       FLAG_R_OPTIONAL},
  336.   { "mpn_mupi_div_qr",         speed_mpn_mupi_div_qr,     FLAG_R_OPTIONAL},
  337.   { "mpn_sbpi1_divappr_q",     speed_mpn_sbpi1_divappr_q, FLAG_R_OPTIONAL},
  338.   { "mpn_dcpi1_divappr_q",     speed_mpn_dcpi1_divappr_q, FLAG_R_OPTIONAL},
  340.   { "mpn_sbpi1_bdiv_qr",       speed_mpn_sbpi1_bdiv_qr       },
  341.   { "mpn_dcpi1_bdiv_qr",       speed_mpn_dcpi1_bdiv_qr       },
  342.   { "mpn_sbpi1_bdiv_q",        speed_mpn_sbpi1_bdiv_q        },
  343.   { "mpn_dcpi1_bdiv_q",        speed_mpn_dcpi1_bdiv_q        },
  345.   { "mpn_get_str",          speed_mpn_get_str,     FLAG_R_OPTIONAL },
  346.   { "mpn_set_str",          speed_mpn_set_str,     FLAG_R_OPTIONAL },
  347.   { "mpn_set_str_basecase", speed_mpn_bc_set_str,  FLAG_R_OPTIONAL },
  349.   { "mpn_sqrtrem",       speed_mpn_sqrtrem          },
  350.   { "mpn_rootrem",       speed_mpn_rootrem, FLAG_R  },
  352.   { "mpn_fib2_ui",       speed_mpn_fib2_ui,    FLAG_NODATA },
  353.   { "mpz_fib_ui",        speed_mpz_fib_ui,     FLAG_NODATA },
  354.   { "mpz_fib2_ui",       speed_mpz_fib2_ui,    FLAG_NODATA },
  355.   { "mpz_lucnum_ui",     speed_mpz_lucnum_ui,  FLAG_NODATA },
  356.   { "mpz_lucnum2_ui",    speed_mpz_lucnum2_ui, FLAG_NODATA },
  358.   { "mpz_add",           speed_mpz_add              },
  359.   { "mpz_bin_uiui",      speed_mpz_bin_uiui, FLAG_NODATA | FLAG_R_OPTIONAL },
  360.   { "mpz_fac_ui",        speed_mpz_fac_ui,   FLAG_NODATA   },
  361.   { "mpz_powm",          speed_mpz_powm             },
  362.   { "mpz_powm_mod",      speed_mpz_powm_mod         },
  363.   { "mpz_powm_redc",     speed_mpz_powm_redc        },
  364.   { "mpz_powm_ui",       speed_mpz_powm_ui,  FLAG_R_OPTIONAL },
  366.   { "mpz_mod",           speed_mpz_mod              },
  367.   { "mpn_redc_1",        speed_mpn_redc_1           },
  368.   { "mpn_redc_2",        speed_mpn_redc_2           },
  369.   { "mpn_redc_n",        speed_mpn_redc_n           },
  371.   { "MPN_COPY",          speed_MPN_COPY             },
  372.   { "MPN_COPY_INCR",     speed_MPN_COPY_INCR        },
  373.   { "MPN_COPY_DECR",     speed_MPN_COPY_DECR        },
  374.   { "memcpy",            speed_memcpy               },
  375. #if HAVE_NATIVE_mpn_copyi
  376.   { "mpn_copyi",         speed_mpn_copyi            },
  377. #endif
  378. #if HAVE_NATIVE_mpn_copyd
  379.   { "mpn_copyd",         speed_mpn_copyd            },
  380. #endif
  381. #if HAVE_NATIVE_mpn_addlsh1_n
  382.   { "mpn_addlsh1_n",     speed_mpn_addlsh1_n        },
  383. #endif
  384. #if HAVE_NATIVE_mpn_sublsh1_n
  385.   { "mpn_sublsh1_n",     speed_mpn_sublsh1_n        },
  386. #endif
  387. #if HAVE_NATIVE_mpn_rsblsh1_n
  388.   { "mpn_rsblsh1_n",     speed_mpn_rsblsh1_n        },
  389. #endif
  390. #if HAVE_NATIVE_mpn_addlsh2_n
  391.   { "mpn_addlsh2_n",     speed_mpn_addlsh2_n        },
  392. #endif
  393. #if HAVE_NATIVE_mpn_sublsh2_n
  394.   { "mpn_sublsh2_n",     speed_mpn_sublsh2_n        },
  395. #endif
  396. #if HAVE_NATIVE_mpn_rsblsh2_n
  397.   { "mpn_rsblsh2_n",     speed_mpn_rsblsh2_n        },
  398. #endif
  399. #if HAVE_NATIVE_mpn_rsh1add_n
  400.   { "mpn_rsh1add_n",     speed_mpn_rsh1add_n        },
  401. #endif
  402. #if HAVE_NATIVE_mpn_rsh1sub_n
  403.   { "mpn_rsh1sub_n",     speed_mpn_rsh1sub_n        },
  404. #endif
  406.   { "MPN_ZERO",          speed_MPN_ZERO             },
  408.   { "binvert_limb",       speed_binvert_limb,       FLAG_NODATA },
  409.   { "binvert_limb_mul1",  speed_binvert_limb_mul1,  FLAG_NODATA },
  410.   { "binvert_limb_loop",  speed_binvert_limb_loop,  FLAG_NODATA },
  411.   { "binvert_limb_cond",  speed_binvert_limb_cond,  FLAG_NODATA },
  412.   { "binvert_limb_arith", speed_binvert_limb_arith, FLAG_NODATA },
  414.   { "malloc_free",                  speed_malloc_free                  },
  415.   { "malloc_realloc_free",          speed_malloc_realloc_free          },
  416.   { "gmp_allocate_free",            speed_gmp_allocate_free            },
  417.   { "gmp_allocate_reallocate_free", speed_gmp_allocate_reallocate_free },
  418.   { "mpz_init_clear",               speed_mpz_init_clear               },
  419.   { "mpq_init_clear",               speed_mpq_init_clear               },
  420.   { "mpf_init_clear",               speed_mpf_init_clear               },
  421.   { "mpz_init_realloc_clear",       speed_mpz_init_realloc_clear       },
  423.   { "umul_ppmm",         speed_umul_ppmm,     FLAG_R_OPTIONAL },
  424. #if HAVE_NATIVE_mpn_umul_ppmm
  425.   { "mpn_umul_ppmm",     speed_mpn_umul_ppmm, FLAG_R_OPTIONAL },
  426. #endif
  427. #if HAVE_NATIVE_mpn_umul_ppmm_r
  428.   { "mpn_umul_ppmm_r",   speed_mpn_umul_ppmm_r, FLAG_R_OPTIONAL },
  429. #endif
  431.   { "count_leading_zeros",  speed_count_leading_zeros,  FLAG_NODATA | FLAG_R_OPTIONAL },
  432.   { "count_trailing_zeros", speed_count_trailing_zeros, FLAG_NODATA | FLAG_R_OPTIONAL },
  434.   { "udiv_qrnnd",             speed_udiv_qrnnd,             FLAG_R_OPTIONAL },
  435.   { "udiv_qrnnd_preinv1",     speed_udiv_qrnnd_preinv1,     FLAG_R_OPTIONAL },
  436.   { "udiv_qrnnd_preinv2",     speed_udiv_qrnnd_preinv2,     FLAG_R_OPTIONAL },
  437.   { "udiv_qrnnd_c",           speed_udiv_qrnnd_c,           FLAG_R_OPTIONAL },
  438. #if HAVE_NATIVE_mpn_udiv_qrnnd
  439.   { "mpn_udiv_qrnnd",         speed_mpn_udiv_qrnnd,         FLAG_R_OPTIONAL },
  440. #endif
  441. #if HAVE_NATIVE_mpn_udiv_qrnnd_r
  442.   { "mpn_udiv_qrnnd_r",       speed_mpn_udiv_qrnnd_r,       FLAG_R_OPTIONAL },
  443. #endif
  444.   { "invert_limb",            speed_invert_limb,            FLAG_R_OPTIONAL },
  446.   { "operator_div",           speed_operator_div,           FLAG_R_OPTIONAL },
  447.   { "operator_mod",           speed_operator_mod,           FLAG_R_OPTIONAL },
  449.   { "gmp_randseed",    speed_gmp_randseed,    FLAG_R_OPTIONAL               },
  450.   { "gmp_randseed_ui", speed_gmp_randseed_ui, FLAG_R_OPTIONAL | FLAG_NODATA },
  451.   { "mpz_urandomb",    speed_mpz_urandomb,    FLAG_R_OPTIONAL | FLAG_NODATA },
  453. #ifdef SPEED_EXTRA_ROUTINES
  454.   SPEED_EXTRA_ROUTINES
  455. #endif
  456. #ifdef SPEED_EXTRA_ROUTINES2
  457.   SPEED_EXTRA_ROUTINES2
  458. #endif
  459. };
  462. struct choice_t {
  463.   const struct routine_t  *p;
  464.   mp_limb_t               r;
  465.   double                  scale;
  466.   double                  time;
  467.   int                     no_time;
  468.   double                  prev_time;
  469.   const char              *name;
  470. };
  471. struct choice_t  *choice;
  472. int  num_choices = 0;
  475. void
  476. data_fill (mp_ptr ptr, mp_size_t size)
  477. {
  478.   switch (option_data) {
  479.   case DATA_RANDOM:
  480.     mpn_random (ptr, size);
  481.     break;
  482.   case DATA_RANDOM2:
  483.     mpn_random2 (ptr, size);
  484.     break;
  485.   case DATA_ZEROS:
  486.     MPN_ZERO (ptr, size);
  487.     break;
  488.   case DATA_AAS:
  489.     MPN_FILL (ptr, size, GMP_NUMB_0xAA);
  490.     break;
  491.   case DATA_FFS:
  492.     MPN_FILL (ptr, size, GMP_NUMB_MAX);
  493.     break;
  494.   case DATA_2FD:
  495.     MPN_FILL (ptr, size, GMP_NUMB_MAX);
  496.     ptr[0] -= 2;
  497.     break;
  498.   default:
  499.     abort();
  500.     /*NOTREACHED*/
  501.   }
  502. }
  504. /* The code here handling the various combinations of output options isn't
  505.    too attractive, but it works and is fairly clean.  */
  507. #define SIZE_TO_DIVISOR(n)              
  508.   (option_square == 1 ? (n)*(n)         
  509.   : option_square == 2 ? (n)*((n)+1)/2  
  510.   : (n))
  512. void
  513. run_one (FILE *fp, struct speed_params *s, mp_size_t prev_size)
  514. {
  515.   const char  *first_open_fastest, *first_open_notfastest, *first_close;
  516.   int         i, fastest, want_data;
  517.   double      fastest_time;
  518.   TMP_DECL;
  520.   TMP_MARK;
  522.   /* allocate data, unless all routines are NODATA */
  523.   want_data = 0;
  524.   for (i = 0; i < num_choices; i++)
  525.     want_data |= ((choice[i].p->flag & FLAG_NODATA) == 0);
  527.   if (want_data)
  528.     {
  529.       SPEED_TMP_ALLOC_LIMBS (sp.xp, s->size, s->align_xp);
  530.       SPEED_TMP_ALLOC_LIMBS (sp.yp, s->size, s->align_yp);
  532.       data_fill (s->xp, s->size);
  533.       data_fill (s->yp, s->size);
  534.     }
  535.   else
  536.     {
  537.       sp.xp = NULL;
  538.       sp.yp = NULL;
  539.     }
  541.   if (prev_size == -1 && option_cmp == CMP_DIFFPREV)
  542.     {
  543.       first_open_fastest = "(#";
  544.       first_open_notfastest = " (";
  545.       first_close = ")";
  546.     }
  547.   else
  548.     {
  549.       first_open_fastest = "#";
  550.       first_open_notfastest = " ";
  551.       first_close = "";
  552.     }
  554.   fastest = -1;
  555.   fastest_time = -1.0;
  556.   for (i = 0; i < num_choices; i++)
  557.     {
  558.       s->r = choice[i].r;
  559.       choice[i].time = speed_measure (choice[i].p->fun, s);
  560.       choice[i].no_time = (choice[i].time == -1.0);
  561.       if (! choice[i].no_time)
  562.         choice[i].time *= choice[i].scale;
  564.       /* Apply the effect of CMP_DIFFPREV, but the new choice[i].prev_time
  565.          is before any differences.  */
  566.       {
  567.         double     t;
  568.         t = choice[i].time;
  569.         if (t != -1.0 && option_cmp == CMP_DIFFPREV && prev_size != -1)
  570.           {
  571.             if (choice[i].prev_time == -1.0)
  572.               choice[i].no_time = 1;
  573.             else
  574.               choice[i].time = choice[i].time - choice[i].prev_time;
  575.           }
  576.         choice[i].prev_time = t;
  577.       }
  579.       if (choice[i].no_time)
  580.         continue;
  582.       /* Look for the fastest after CMP_DIFFPREV has been applied, but
  583.          before CMP_RATIO or CMP_DIFFERENCE.  There's only a fastest shown
  584.          if there's more than one routine.  */
  585.       if (num_choices > 1 && (fastest == -1 || choice[i].time < fastest_time))
  586.         {
  587.           fastest = i;
  588.           fastest_time = choice[i].time;
  589.         }
  591.       if (option_cmp == CMP_DIFFPREV)
  592.         {
  593.           /* Conversion for UNIT_CYCLESPERLIMB differs in CMP_DIFFPREV. */
  594.           if (option_unit == UNIT_CYCLES)
  595.             choice[i].time /= speed_cycletime;
  596.           else if (option_unit == UNIT_CYCLESPERLIMB)
  597.             {
  598.               if (prev_size == -1)
  599.                 choice[i].time /= speed_cycletime;
  600.               else
  601.                 choice[i].time /=  (speed_cycletime
  602.                                     * (SIZE_TO_DIVISOR(s->size)
  603.                                        - SIZE_TO_DIVISOR(prev_size)));
  604.             }
  605.         }
  606.       else
  607.         {
  608.           if (option_unit == UNIT_CYCLES)
  609.             choice[i].time /= speed_cycletime;
  610.           else if (option_unit == UNIT_CYCLESPERLIMB)
  611.             choice[i].time /= (speed_cycletime * SIZE_TO_DIVISOR(s->size));
  613.           if (option_cmp == CMP_RATIO && i > 0)
  614.             {
  615.               /* A ratio isn't affected by the units chosen. */
  616.               if (choice[0].no_time || choice[0].time == 0.0)
  617.                 choice[i].no_time = 1;
  618.               else
  619.                 choice[i].time /= choice[0].time;
  620.             }
  621.           else if (option_cmp == CMP_DIFFERENCE && i > 0)
  622.             {
  623.               if (choice[0].no_time)
  624.                 {
  625.                   choice[i].no_time = 1;
  626.                   continue;
  627.                 }
  628.               choice[i].time -= choice[0].time;
  629.             }
  630.         }
  631.     }
  633.   if (option_gnuplot)
  634.     {
  635.       /* In CMP_DIFFPREV, don't print anything for the first size, start
  636.          with the second where an actual difference is available.
  638.          In CMP_RATIO, print the first column as 1.0.
  640.          The 9 decimals printed is much more than the expected precision of
  641.          the measurements actually. */
  643.       if (! (option_cmp == CMP_DIFFPREV && prev_size == -1))
  644.         {
  645.           fprintf (fp, "%-6ld ", s->size);
  646.           for (i = 0; i < num_choices; i++)
  647.             fprintf (fp, "  %.9e",
  648.                      choice[i].no_time ? 0.0
  649.                      : (option_cmp == CMP_RATIO && i == 0) ? 1.0
  650.                      : choice[i].time);
  651.           fprintf (fp, "n");
  652.         }
  653.     }
  654.   else
  655.     {
  656.       fprintf (fp, "%-6ld ", s->size);
  657.       for (i = 0; i < num_choices; i++)
  658.         {
  659.           char  buf[128];
  660.           int   decimals;
  662.           if (choice[i].no_time)
  663.             {
  664.               fprintf (fp, " %*s", COLUMN_WIDTH, "n/a");
  665.             }
  666.           else
  667.             {if (option_unit == UNIT_CYCLESPERLIMB
  668.                  || (option_cmp == CMP_RATIO && i > 0))
  669.                 decimals = 4;
  670.               else if (option_unit == UNIT_CYCLES)
  671.                 decimals = 2;
  672.               else
  673.                 decimals = 9;
  675.               sprintf (buf, "%s%.*f%s",
  676.                        i == fastest ? first_open_fastest : first_open_notfastest,
  677.                        decimals, choice[i].time, first_close);
  678.               fprintf (fp, " %*s", COLUMN_WIDTH, buf);
  679.             }
  680.         }
  681.       fprintf (fp, "n");
  682.     }
  684.   TMP_FREE;
  685. }
  687. void
  688. run_all (FILE *fp)
  689. {
  690.   mp_size_t  prev_size;
  691.   int        i;
  692.   TMP_DECL;
  694.   TMP_MARK;
  695.   SPEED_TMP_ALLOC_LIMBS (sp.xp_block, SPEED_BLOCK_SIZE, sp.align_xp);
  696.   SPEED_TMP_ALLOC_LIMBS (sp.yp_block, SPEED_BLOCK_SIZE, sp.align_yp);
  698.   data_fill (sp.xp_block, SPEED_BLOCK_SIZE);
  699.   data_fill (sp.yp_block, SPEED_BLOCK_SIZE);
  701.   for (i = 0; i < size_num; i++)
  702.     {
  703.       sp.size = size_array[i].start;
  704.       prev_size = -1;
  705.       for (;;)
  706.         {
  707.           mp_size_t  step;
  709.           if (option_data == DATA_2FD && sp.size >= 2)
  710.             sp.xp[sp.size-1] = 2;
  712.           run_one (fp, &sp, prev_size);
  713.           prev_size = sp.size;
  715.           if (option_data == DATA_2FD && sp.size >= 2)
  716.             sp.xp[sp.size-1] = MP_LIMB_T_MAX;
  718.           if (option_factor != 0.0)
  719.             {
  720.               step = (mp_size_t) (sp.size * option_factor - sp.size);
  721.               if (step < 1)
  722.                 step = 1;
  723.             }
  724.           else
  725.             step = 1;
  726.           if (step < option_step)
  727.             step = option_step;
  729.           sp.size += step;
  730.           if (sp.size > size_array[i].end)
  731.             break;
  732.         }
  733.     }
  735.   TMP_FREE;
  736. }
  739. FILE *
  740. fopen_for_write (const char *filename)
  741. {
  742.   FILE  *fp;
  743.   if ((fp = fopen (filename, "w")) == NULL)
  744.     {
  745.       fprintf (stderr, "Cannot create %sn", filename);
  746.       exit(1);
  747.     }
  748.   return fp;
  749. }
  751. void
  752. fclose_written (FILE *fp, const char *filename)
  753. {
  754.   int  err;
  756.   err = ferror (fp);
  757.   err |= fclose (fp);
  759.   if (err)
  760.     {
  761.       fprintf (stderr, "Error writing %sn", filename);
  762.       exit(1);
  763.     }
  764. }
  767. void
  768. run_gnuplot (int argc, char *argv[])
  769. {
  770.   char  *plot_filename;
  771.   char  *data_filename;
  772.   FILE  *fp;
  773.   int   i;
  775.   plot_filename = (char *) (*__gmp_allocate_func)
  776.     (strlen (option_gnuplot_basename) + 20);
  777.   data_filename = (char *) (*__gmp_allocate_func)
  778.     (strlen (option_gnuplot_basename) + 20);
  780.   sprintf (plot_filename, "%s.gnuplot", option_gnuplot_basename);
  781.   sprintf (data_filename, "%s.data",    option_gnuplot_basename);
  783.   fp = fopen_for_write (plot_filename);
  785.   fprintf (fp, "# Generated with:n");
  786.   fprintf (fp, "#");
  787.   for (i = 0; i < argc; i++)
  788.     fprintf (fp, " %s", argv[i]);
  789.   fprintf (fp, "n");
  790.   fprintf (fp, "n");
  792.   fprintf (fp, "resetn");
  794.   /* Putting the key at the top left is usually good, and you can change it
  795.      interactively if it's not. */
  796.   fprintf (fp, "set key leftn");
  798.   /* designed to make it possible to see crossovers easily */
  799.   fprintf (fp, "set data style linesn");
  801.   fprintf (fp, "plot ");
  802.   for (i = 0; i < num_choices; i++)
  803.     {
  804.       fprintf (fp, " "%s" using 1:%d", data_filename, i+2);
  805.       fprintf (fp, " title "%s"", choice[i].name);
  807.       if (i != num_choices-1)
  808.         fprintf (fp, ", \");
  809.       fprintf (fp, "n");
  810.     }
  812.   fprintf (fp, "load "-"n");
  813.   fclose_written (fp, plot_filename);
  815.   fp = fopen_for_write (data_filename);
  817.   /* Unbuffered so you can see where the program was up to if it crashes or
  818.      you kill it. */
  819.   setbuf (fp, NULL);
  821.   run_all (fp);
  822.   fclose_written (fp, data_filename);
  823. }
  826. /* Return a limb with n many one bits (starting from the least significant) */
  828. #define LIMB_ONES(n) 
  829.   ((n) == GMP_LIMB_BITS ? MP_LIMB_T_MAX      
  830.     : (n) == 0 ? CNST_LIMB(0)                   
  831.     : (CNST_LIMB(1) << (n)) - 1)
  833. mp_limb_t
  834. r_string (const char *s)
  835. {
  836.   const char  *s_orig = s;
  837.   long        n;
  839.   if (strcmp (s, "aas") == 0)
  840.     return GMP_NUMB_0xAA;
  842.   {
  843.     mpz_t      z;
  844.     mp_limb_t  l;
  845.     int        set, siz;
  847.     mpz_init (z);
  848.     set = mpz_set_str (z, s, 0);
  849.     siz = SIZ(z);
  850.     l = (siz == 0 ? 0 : siz > 0 ? PTR(z)[0] : -PTR(z)[0]);
  851.     mpz_clear (z);
  852.     if (set == 0)
  853.       {
  854.         if (siz > 1 || siz < -1)
  855.           printf ("Warning, r parameter %s truncated to %d bitsn",
  856.                   s_orig, GMP_LIMB_BITS);
  857.         return l;
  858.       }
  859.   }
  861.   if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
  862.     n = strtoul (s+2, (char **) &s, 16);
  863.   else
  864.     n = strtol (s, (char **) &s, 10);
  866.   if (strcmp (s, "bits") == 0)
  867.     {
  868.       mp_limb_t  l;
  869.       if (n > GMP_LIMB_BITS)
  870.         {
  871.           fprintf (stderr, "%ld bit parameter invalid (max %d bits)n",
  872.                    n, GMP_LIMB_BITS);
  873.           exit (1);
  874.         }
  875.       mpn_random (&l, 1);
  876.       return (l | (CNST_LIMB(1) << (n-1))) & LIMB_ONES(n);
  877.     }
  878.   else  if (strcmp (s, "ones") == 0)
  879.     {
  880.       if (n > GMP_LIMB_BITS)
  881.         {
  882.           fprintf (stderr, "%ld bit parameter invalid (max %d bits)n",
  883.                    n, GMP_LIMB_BITS);
  884.           exit (1);
  885.         }
  886.       return LIMB_ONES (n);
  887.     }
  888.   else if (*s != '')
  889.     {
  890.       fprintf (stderr, "invalid r parameter: %sn", s_orig);
  891.       exit (1);
  892.     }
  894.   return n;
  895. }
  898. void
  899. routine_find (struct choice_t *c, const char *s_orig)
  900. {
  901.   const char  *s;
  902.   int     i;
  903.   size_t  nlen;
  905.   c->name = s_orig;
  906.   s = strchr (s_orig, '*');
  907.   if (s != NULL)
  908.     {
  909.       c->scale = atof(s_orig);
  910.       s++;
  911.     }
  912.   else
  913.     {
  914.       c->scale = 1.0;
  915.       s = s_orig;
  916.     }
  918.   for (i = 0; i < numberof (routine); i++)
  919.     {
  920.       nlen = strlen (routine[i].name);
  921.       if (memcmp (s, routine[i].name, nlen) != 0)
  922.         continue;
  924.       if (s[nlen] == '.')
  925.         {
  926.           /* match, with a .r parameter */
  928.           if (! (routine[i].flag & (FLAG_R|FLAG_R_OPTIONAL)))
  929.             {
  930.               fprintf (stderr,
  931.                        "Choice %s bad: doesn't take a ".<r>" parametern",
  932.                        s_orig);
  933.               exit (1);
  934.             }
  936.           c->p = &routine[i];
  937.           c->r = r_string (s + nlen + 1);
  938.           return;
  939.         }
  941.       if (s[nlen] == '')
  942.         {
  943.           /* match, with no parameter */
  945.           if (routine[i].flag & FLAG_R)
  946.             {
  947.               fprintf (stderr,
  948.                        "Choice %s bad: needs a ".<r>" parametern",
  949.                        s_orig);
  950.               exit (1);
  951.             }
  953.           c->p = &routine[i];
  954.           c->r = 0;
  955.           return;
  956.         }
  957.     }
  959.   fprintf (stderr, "Choice %s unrecognisedn", s_orig);
  960.   exit (1);
  961. }
  964. void
  965. usage (void)
  966. {
  967.   int  i;
  969.   speed_time_init ();
  971.   printf ("Usage: speed [-options] -s size <routine>...n");
  972.   printf ("Measure the speed of some routines.n");
  973.   printf ("Times are in seconds, accuracy is shown.n");
  974.   printf ("n");
  975.   printf ("   -p num     set precision as number of time units each routine must runn");
  976.   printf ("   -s size[-end][,size[-end]]...   sizes to measuren");
  977.   printf ("              single sizes or ranges, sep with comma or use multiple -sn");
  978.   printf ("   -t step    step through sizes by given amountn");
  979.   printf ("   -f factor  step through sizes by given factor (eg. 1.05)n");
  980.   printf ("   -r         show times as ratios of the first routinen");
  981.   printf ("   -d         show times as difference from the first routinen");
  982.   printf ("   -D         show times as difference from previous size shownn");
  983.   printf ("   -c         show times in CPU cyclesn");
  984.   printf ("   -C         show times in cycles per limbn");
  985.   printf ("   -u         print resource usage (memory) at endn");
  986.   printf ("   -P name    output plot files "name.gnuplot" and "name.data"n");
  987.   printf ("   -a <type>  use given data: random(default), random2, zeros, aas, ffs, 2fdn");
  988.   printf ("   -x, -y, -w, -W <align>  specify data alignments, sources and destsn");
  989.   printf ("   -o addrs   print addresses of data blocksn");
  990.   printf ("n");
  991.   printf ("If both -t and -f are used, it means step by the factor or the step, whichevern");
  992.   printf ("is greater.n");
  993.   printf ("If both -C and -D are used, it means cycles per however many limbs between an");
  994.   printf ("size and the previous size.n");
  995.   printf ("n");
  996.   printf ("After running with -P, plots can be viewed with Gnuplot or Quickplot.n");
  997.   printf (""gnuplot name.gnuplot" (use "set logscale xy; replot" at the prompt forn");
  998.   printf ("a log/log plot).n");
  999.   printf (""quickplot -s name.data" (has interactive zooming, and note -s is importantn");
  1000.   printf ("when viewing more than one routine, it means same axis scales for all data).n");
  1001.   printf ("n");
  1002.   printf ("The available routines are as follows.n");
  1003.   printf ("n");
  1005.   for (i = 0; i < numberof (routine); i++)
  1006.     {
  1007.       if (routine[i].flag & FLAG_R)
  1008.         printf ("t%s.rn", routine[i].name);
  1009.       else if (routine[i].flag & FLAG_R_OPTIONAL)
  1010.         printf ("t%s (optional .r)n", routine[i].name);
  1011.       else
  1012.         printf ("t%sn", routine[i].name);
  1013.     }
  1014.   printf ("n");
  1015.   printf ("Routines with a ".r" need an extra parameter, for example mpn_lshift.6n");
  1016.   printf ("r should be in decimal, or use 0xN for hexadecimal.n");
  1017.   printf ("n");
  1018.   printf ("Special forms for r are "<N>bits" for a random N bit number, "<N>ones" forn");
  1019.   printf ("N one bits, or "aas" for 0xAA..AA.n");
  1020.   printf ("n");
  1021.   printf ("Times for sizes out of the range accepted by a routine are shown as 0.n");
  1022.   printf ("The fastest routine at each size is marked with a # (free form output only).n");
  1023.   printf ("n");
  1024.   printf ("%s", speed_time_string);
  1025.   printf ("n");
  1026.   printf ("Gnuplot home page http://www.gnuplot.info/n");
  1027.   printf ("Quickplot home page http://quickplot.sourceforge.net/n");
  1028. }
  1030. void
  1031. check_align_option (const char *name, mp_size_t align)
  1032. {
  1033.   if (align < 0 || align > SPEED_TMP_ALLOC_ADJUST_MASK)
  1034.     {
  1035.       fprintf (stderr, "Alignment request out of range: %s %ldn",
  1036.                name, (long) align);
  1037.       fprintf (stderr, "  should be 0 to %d (limbs), inclusiven",
  1038.                SPEED_TMP_ALLOC_ADJUST_MASK);
  1039.       exit (1);
  1040.     }
  1041. }
  1043. int
  1044. main (int argc, char *argv[])
  1045. {
  1046.   int  i;
  1047.   int  opt;
  1049.   /* Unbuffered so output goes straight out when directed to a pipe or file
  1050.      and isn't lost on killing the program half way.  */
  1051.   setbuf (stdout, NULL);
  1053.   for (;;)
  1054.     {
  1055.       opt = getopt(argc, argv, "a:CcDdEFf:o:p:P:rRs:t:ux:y:w:W:z");
  1056.       if (opt == EOF)
  1057.         break;
  1059.       switch (opt) {
  1060.       case 'a':
  1061.         if (strcmp (optarg, "random") == 0)       option_data = DATA_RANDOM;
  1062.         else if (strcmp (optarg, "random2") == 0) option_data = DATA_RANDOM2;
  1063.         else if (strcmp (optarg, "zeros") == 0)   option_data = DATA_ZEROS;
  1064.         else if (strcmp (optarg, "aas") == 0)     option_data = DATA_AAS;
  1065.         else if (strcmp (optarg, "ffs") == 0)     option_data = DATA_FFS;
  1066.         else if (strcmp (optarg, "2fd") == 0)     option_data = DATA_2FD;
  1067.         else
  1068.           {
  1069.             fprintf (stderr, "unrecognised data option: %sn", optarg);
  1070.             exit (1);
  1071.           }
  1072.         break;
  1073.       case 'C':
  1074.         if (option_unit  != UNIT_SECONDS) goto bad_unit;
  1075.         option_unit = UNIT_CYCLESPERLIMB;
  1076.         break;
  1077.       case 'c':
  1078.         if (option_unit != UNIT_SECONDS)
  1079.           {
  1080.           bad_unit:
  1081.             fprintf (stderr, "cannot use more than one of -c, -Cn");
  1082.             exit (1);
  1083.           }
  1084.         option_unit = UNIT_CYCLES;
  1085.         break;
  1086.       case 'D':
  1087.         if (option_cmp != CMP_ABSOLUTE) goto bad_cmp;
  1088.         option_cmp = CMP_DIFFPREV;
  1089.         break;
  1090.       case 'd':
  1091.         if (option_cmp != CMP_ABSOLUTE)
  1092.           {
  1093.           bad_cmp:
  1094.             fprintf (stderr, "cannot use more than one of -d, -D, -rn");
  1095.             exit (1);
  1096.           }
  1097.         option_cmp = CMP_DIFFERENCE;
  1098.         break;
  1099.       case 'E':
  1100.         option_square = 1;
  1101.         break;
  1102.       case 'F':
  1103.         option_square = 2;
  1104.         break;
  1105.       case 'f':
  1106.         option_factor = atof (optarg);
  1107.         if (option_factor <= 1.0)
  1108.           {
  1109.             fprintf (stderr, "-f factor must be > 1.0n");
  1110.             exit (1);
  1111.           }
  1112.         break;
  1113.       case 'o':
  1114.         speed_option_set (optarg);
  1115.         break;
  1116.       case 'P':
  1117.         option_gnuplot = 1;
  1118.         option_gnuplot_basename = optarg;
  1119.         break;
  1120.       case 'p':
  1121.         speed_precision = atoi (optarg);
  1122.         break;
  1123.       case 'R':
  1124.         option_seed = time (NULL);
  1125.         break;
  1126.       case 'r':
  1127.         if (option_cmp != CMP_ABSOLUTE)
  1128.           goto bad_cmp;
  1129.         option_cmp = CMP_RATIO;
  1130.         break;
  1131.       case 's':
  1132.         {
  1133.           char  *s;
  1134.           for (s = strtok (optarg, ","); s != NULL; s = strtok (NULL, ","))
  1135.             {
  1136.               if (size_num == size_allocnum)
  1137.                 {
  1138.                   size_array = (struct size_array_t *)
  1139.                     __gmp_allocate_or_reallocate
  1140.                     (size_array,
  1141.                      size_allocnum * sizeof(size_array[0]),
  1142.                      (size_allocnum+10) * sizeof(size_array[0]));
  1143.                   size_allocnum += 10;
  1144.                 }
  1145.               if (sscanf (s, "%ld-%ld",
  1146.                           &size_array[size_num].start,
  1147.                           &size_array[size_num].end) != 2)
  1148.                 {
  1149.                   size_array[size_num].start = size_array[size_num].end
  1150.                     = atol (s);
  1151.                 }
  1153.               if (size_array[size_num].start < 0
  1154.                   || size_array[size_num].end < 0
  1155.                   || size_array[size_num].start > size_array[size_num].end)
  1156.                 {
  1157.                   fprintf (stderr, "invalid size parameter: %sn", s);
  1158.                   exit (1);
  1159.                 }
  1161.               size_num++;
  1162.             }
  1163.         }
  1164.         break;
  1165.       case 't':
  1166.         option_step = atol (optarg);
  1167.         if (option_step < 1)
  1168.           {
  1169.             fprintf (stderr, "-t step must be >= 1n");
  1170.             exit (1);
  1171.           }
  1172.         break;
  1173.       case 'u':
  1174.         option_resource_usage = 1;
  1175.         break;
  1176.       case 'z':
  1177.         sp.cache = 1;
  1178.         break;
  1179.       case 'x':
  1180.         sp.align_xp = atol (optarg);
  1181.         check_align_option ("-x", sp.align_xp);
  1182.         break;
  1183.       case 'y':
  1184.         sp.align_yp = atol (optarg);
  1185.         check_align_option ("-y", sp.align_yp);
  1186.         break;
  1187.       case 'w':
  1188.         sp.align_wp = atol (optarg);
  1189.         check_align_option ("-w", sp.align_wp);
  1190.         break;
  1191.       case 'W':
  1192.         sp.align_wp2 = atol (optarg);
  1193.         check_align_option ("-W", sp.align_wp2);
  1194.         break;
  1195.       case '?':
  1196.         exit(1);
  1197.       }
  1198.     }
  1200.   if (optind >= argc)
  1201.     {
  1202.       usage ();
  1203.       exit (1);
  1204.     }
  1206.   if (size_num == 0)
  1207.     {
  1208.       fprintf (stderr, "-s <size> must be specifiedn");
  1209.       exit (1);
  1210.     }
  1212.   gmp_randinit_default (__gmp_rands);
  1213.   __gmp_rands_initialized = 1;
  1214.   gmp_randseed_ui (__gmp_rands, option_seed);
  1216.   choice = (struct choice_t *) (*__gmp_allocate_func)
  1217.     ((argc - optind) * sizeof(choice[0]));
  1218.   for ( ; optind < argc; optind++)
  1219.     {
  1220.       struct choice_t  c;
  1221.       routine_find (&c, argv[optind]);
  1222.       choice[num_choices] = c;
  1223.       num_choices++;
  1224.     }
  1226.   if ((option_cmp == CMP_RATIO || option_cmp == CMP_DIFFERENCE) &&
  1227.       num_choices < 2)
  1228.     {
  1229.       fprintf (stderr, "WARNING, -d or -r does nothing when only one routine requestedn");
  1230.     }
  1232.   speed_time_init ();
  1233.   if (option_unit == UNIT_CYCLES || option_unit == UNIT_CYCLESPERLIMB)
  1234.     speed_cycletime_need_cycles ();
  1235.   else
  1236.     speed_cycletime_need_seconds ();
  1238.   if (option_gnuplot)
  1239.     {
  1240.       run_gnuplot (argc, argv);
  1241.     }
  1242.   else
  1243.     {
  1244.       if (option_unit == UNIT_SECONDS)
  1245.         printf ("overhead %.9f secs", speed_measure (speed_noop, NULL));
  1246.       else
  1247.         printf ("overhead %.2f cycles",
  1248.                 speed_measure (speed_noop, NULL) / speed_cycletime);
  1249.       printf (", precision %d units of %.2e secs",
  1250.               speed_precision, speed_unittime);
  1252.       if (speed_cycletime == 1.0 || speed_cycletime == 0.0)
  1253.         printf (", CPU freq unknownn");
  1254.       else
  1255.         printf (", CPU freq %.2f MHzn", 1e-6/speed_cycletime);
  1257.       printf ("       ");
  1258.       for (i = 0; i < num_choices; i++)
  1259.         printf (" %*s", COLUMN_WIDTH, choice[i].name);
  1260.       printf ("n");
  1262.       run_all (stdout);
  1263.     }
  1265.   if (option_resource_usage)
  1266.     {
  1267. #if HAVE_GETRUSAGE
  1268.       {
  1269.         /* This doesn't give data sizes on linux 2.0.x, only utime. */
  1270.         struct rusage  r;
  1271.         if (getrusage (RUSAGE_SELF, &r) != 0)
  1272.           perror ("getrusage");
  1273.         else
  1274.           printf ("getrusage(): utime %ld.%06ld data %ld stack %ld maxresident %ldn",
  1275.                   r.ru_utime.tv_sec, r.ru_utime.tv_usec,
  1276.                   r.ru_idrss, r.ru_isrss, r.ru_ixrss);
  1277.       }
  1278. #else
  1279.       printf ("getrusage() not availablen");
  1280. #endif
  1282.       /* Linux kernel. */
  1283.       {
  1284.         char  buf[128];
  1285.         sprintf (buf, "/proc/%d/status", getpid());
  1286.         if (access (buf, R_OK) == 0)
  1287.           {
  1288.             sprintf (buf, "cat /proc/%d/status", getpid());
  1289.             system (buf);
  1290.           }
  1292.       }
  1293.     }
  1295.   return 0;
  1296. }