/* Speed measuring program.

Copyright 1999-2003, 2005, 2006, 2008-2015 Free Software Foundation, Inc.

This file is part of the GNU MP Library.

The GNU MP Library is free software; you can redistribute it and/or modify

it under the terms of either:

  * the GNU Lesser General Public License as published by the Free

    Software Foundation; either version 3 of the License, or (at your

    option) any later version.

or

  * the GNU General Public License as published by the Free Software

    Foundation; either version 2 of the License, or (at your option) any

    later version.

or both in parallel, as here.

The GNU MP Library is distributed in the hope that it will be useful, but

WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received copies of the GNU General Public License and the

GNU Lesser General Public License along with the GNU MP Library.  If not,

see https://www.gnu.org/licenses/.  */

/* Usage message is in the code below, run with no arguments to print it.

   See README for interesting applications.

   To add a new routine foo(), create a speed_foo() function in the style of

   the existing ones and add an entry in the routine[] array.  Put FLAG_R if

   speed_foo() wants an "r" parameter.

   The routines don't have help messages or descriptions, but most have

   suggestive names.  See the source code for full details.

*/

#include "config.h"

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#if HAVE_UNISTD_H

#include <unistd.h>  /* for getpid, R_OK */

#endif

#if TIME_WITH_SYS_TIME

# include <sys/time.h>  /* for struct timeval */

# include <time.h>

#else

# if HAVE_SYS_TIME_H

#  include <sys/time.h>

# else

#  include <time.h>

# endif

#endif

#if HAVE_SYS_RESOURCE_H

#include <sys/resource.h>  /* for getrusage() */

#endif

#include "gmp.h"

#include "gmp-impl.h"

#include "longlong.h"  /* for the benefit of speed-many.c */

#include "tests.h"

#include "speed.h"

#if !HAVE_DECL_OPTARG

extern char *optarg;

extern int optind, opterr;

#endif

#if !HAVE_STRTOUL

#define strtoul(p,e,b)  (unsigned long) strtol(p,e,b)

#endif

#ifdef SPEED_EXTRA_PROTOS

SPEED_EXTRA_PROTOS

#endif

#ifdef SPEED_EXTRA_PROTOS2

SPEED_EXTRA_PROTOS2

#endif

#if GMP_LIMB_BITS == 32

#define GMP_NUMB_0xAA  (CNST_LIMB(0xAAAAAAAA) & GMP_NUMB_MASK)

#endif

#if GMP_LIMB_BITS == 64

#define GMP_NUMB_0xAA  (CNST_LIMB(0xAAAAAAAAAAAAAAAA) & GMP_NUMB_MASK)

#endif

#define CMP_ABSOLUTE     1

#define CMP_RATIO        2

#define CMP_DIFFERENCE   3

#define CMP_DIFFPREV     4

int  option_cmp = CMP_ABSOLUTE;

#define UNIT_SECONDS        1

#define UNIT_CYCLES         2

#define UNIT_CYCLESPERLIMB  3

int  option_unit = UNIT_SECONDS;

#define DATA_RANDOM   1

#define DATA_RANDOM2  2

#define DATA_ZEROS    3

#define DATA_AAS      4

#define DATA_FFS      5

#define DATA_2FD      6

int  option_data = DATA_RANDOM;

int        option_square = 0;

double     option_factor = 0.0;

mp_size_t  option_step = 1;

int        option_gnuplot = 0;

char      *option_gnuplot_basename;

struct size_array_t {

  mp_size_t start, end;

} *size_array = NULL;

mp_size_t  size_num = 0;

mp_size_t  size_allocnum = 0;

int        option_resource_usage = 0;

long       option_seed = 123456789;

struct speed_params  sp;

#define COLUMN_WIDTH  13  /* for the free-form output */

#define FLAG_R            (1<<0)  /* require ".r" */

#define FLAG_R_OPTIONAL   (1<<1)  /* optional ".r" */

#define FLAG_RSIZE        (1<<2)

#define FLAG_NODATA       (1<<3)  /* don't alloc xp, yp */

const struct routine_t {

  /* constants */

  const char        *name;

  speed_function_t  fun;

  int               flag;

} routine[] = {

  { "noop",              speed_noop                 },

  { "noop_wxs",          speed_noop_wxs             },

  { "noop_wxys",         speed_noop_wxys            },

  { "mpn_add_n",         speed_mpn_add_n,     FLAG_R_OPTIONAL },

  { "mpn_sub_n",         speed_mpn_sub_n,     FLAG_R_OPTIONAL },

  { "mpn_add_1",         speed_mpn_add_1,     FLAG_R },

  { "mpn_add_1_inplace", speed_mpn_add_1_inplace, FLAG_R },

  { "mpn_sub_1",         speed_mpn_sub_1,     FLAG_R },

  { "mpn_sub_1_inplace", speed_mpn_sub_1_inplace, FLAG_R },

  { "mpn_add_err1_n",    speed_mpn_add_err1_n    },

  { "mpn_add_err2_n",    speed_mpn_add_err2_n    },

  { "mpn_add_err3_n",    speed_mpn_add_err3_n    },

  { "mpn_sub_err1_n",    speed_mpn_sub_err1_n    },

  { "mpn_sub_err2_n",    speed_mpn_sub_err2_n    },

  { "mpn_sub_err3_n",    speed_mpn_sub_err3_n    },

#if HAVE_NATIVE_mpn_add_n_sub_n

  { "mpn_add_n_sub_n",      speed_mpn_add_n_sub_n,     FLAG_R_OPTIONAL },

#endif

  { "mpn_addmul_1",      speed_mpn_addmul_1,  FLAG_R },

  { "mpn_submul_1",      speed_mpn_submul_1,  FLAG_R },

#if HAVE_NATIVE_mpn_addmul_2

  { "mpn_addmul_2",      speed_mpn_addmul_2,  FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_addmul_3

  { "mpn_addmul_3",      speed_mpn_addmul_3,  FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_addmul_4

  { "mpn_addmul_4",      speed_mpn_addmul_4,  FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_addmul_5

  { "mpn_addmul_5",      speed_mpn_addmul_5,  FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_addmul_6

  { "mpn_addmul_6",      speed_mpn_addmul_6,  FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_addmul_7

  { "mpn_addmul_7",      speed_mpn_addmul_7,  FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_addmul_8

  { "mpn_addmul_8",      speed_mpn_addmul_8,  FLAG_R_OPTIONAL },

#endif

  { "mpn_mul_1",         speed_mpn_mul_1,     FLAG_R },

  { "mpn_mul_1_inplace", speed_mpn_mul_1_inplace, FLAG_R },

#if HAVE_NATIVE_mpn_mul_2

  { "mpn_mul_2",         speed_mpn_mul_2,     FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_mul_3

  { "mpn_mul_3",         speed_mpn_mul_3,     FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_mul_4

  { "mpn_mul_4",         speed_mpn_mul_4,     FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_mul_5

  { "mpn_mul_5",         speed_mpn_mul_5,     FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_mul_6

  { "mpn_mul_6",         speed_mpn_mul_6,     FLAG_R_OPTIONAL },

#endif

  { "mpn_divrem_1",      speed_mpn_divrem_1,  FLAG_R },

  { "mpn_divrem_1f",     speed_mpn_divrem_1f, FLAG_R },

#if HAVE_NATIVE_mpn_divrem_1c

  { "mpn_divrem_1c",     speed_mpn_divrem_1c, FLAG_R },

  { "mpn_divrem_1cf",    speed_mpn_divrem_1cf,FLAG_R },

#endif

  { "mpn_mod_1",         speed_mpn_mod_1,     FLAG_R },

#if HAVE_NATIVE_mpn_mod_1c

  { "mpn_mod_1c",        speed_mpn_mod_1c,    FLAG_R },

#endif

  { "mpn_preinv_divrem_1",  speed_mpn_preinv_divrem_1,  FLAG_R },

  { "mpn_preinv_divrem_1f", speed_mpn_preinv_divrem_1f, FLAG_R },

  { "mpn_preinv_mod_1",  speed_mpn_preinv_mod_1, FLAG_R },

  { "mpn_mod_1_1",       speed_mpn_mod_1_1,       FLAG_R },

  { "mpn_mod_1_1_1",     speed_mpn_mod_1_1_1,     FLAG_R },

  { "mpn_mod_1_1_2",     speed_mpn_mod_1_1_2,     FLAG_R },

  { "mpn_mod_1s_2",      speed_mpn_mod_1_2,       FLAG_R },

  { "mpn_mod_1s_3",      speed_mpn_mod_1_3,       FLAG_R },

  { "mpn_mod_1s_4",      speed_mpn_mod_1_4,       FLAG_R },

  { "mpn_divrem_1_div",  speed_mpn_divrem_1_div,  FLAG_R },

  { "mpn_divrem_1_inv",  speed_mpn_divrem_1_inv,  FLAG_R },

  { "mpn_divrem_1f_div", speed_mpn_divrem_1f_div, FLAG_R },

  { "mpn_divrem_1f_inv", speed_mpn_divrem_1f_inv, FLAG_R },

  { "mpn_mod_1_div",     speed_mpn_mod_1_div,     FLAG_R },

  { "mpn_mod_1_inv",     speed_mpn_mod_1_inv,     FLAG_R },

  { "mpn_divrem_2",      speed_mpn_divrem_2,        },

  { "mpn_divrem_2_div",  speed_mpn_divrem_2_div,    },

  { "mpn_divrem_2_inv",  speed_mpn_divrem_2_inv,    },

  { "mpn_div_qr_1n_pi1", speed_mpn_div_qr_1n_pi1, FLAG_R  },

  { "mpn_div_qr_1n_pi1_1",speed_mpn_div_qr_1n_pi1_1, FLAG_R  },

  { "mpn_div_qr_1n_pi1_2",speed_mpn_div_qr_1n_pi1_2, FLAG_R  },

  { "mpn_div_qr_1",      speed_mpn_div_qr_1,      FLAG_R },

  { "mpn_div_qr_2n",     speed_mpn_div_qr_2n,       },

  { "mpn_div_qr_2u",     speed_mpn_div_qr_2u,       },

  { "mpn_divexact_1",    speed_mpn_divexact_1,    FLAG_R },

  { "mpn_divexact_by3",  speed_mpn_divexact_by3          },

  { "mpn_bdiv_q_1",      speed_mpn_bdiv_q_1,      FLAG_R },

  { "mpn_pi1_bdiv_q_1",  speed_mpn_pi1_bdiv_q_1,  FLAG_R_OPTIONAL },

  { "mpn_bdiv_dbm1c",    speed_mpn_bdiv_dbm1c,    FLAG_R_OPTIONAL },

#if HAVE_NATIVE_mpn_modexact_1_odd

  { "mpn_modexact_1_odd",  speed_mpn_modexact_1_odd,  FLAG_R },

#endif

  { "mpn_modexact_1c_odd", speed_mpn_modexact_1c_odd, FLAG_R },

#if GMP_NUMB_BITS % 4 == 0

  { "mpn_mod_34lsub1",   speed_mpn_mod_34lsub1 },

#endif

  { "mpn_lshift",        speed_mpn_lshift, FLAG_R   },

  { "mpn_lshiftc",       speed_mpn_lshiftc, FLAG_R   },

  { "mpn_rshift",        speed_mpn_rshift, FLAG_R   },

  { "mpn_and_n",         speed_mpn_and_n,  FLAG_R_OPTIONAL },

  { "mpn_andn_n",        speed_mpn_andn_n, FLAG_R_OPTIONAL },

  { "mpn_nand_n",        speed_mpn_nand_n, FLAG_R_OPTIONAL },

  { "mpn_ior_n",         speed_mpn_ior_n,  FLAG_R_OPTIONAL },

  { "mpn_iorn_n",        speed_mpn_iorn_n, FLAG_R_OPTIONAL },

  { "mpn_nior_n",        speed_mpn_nior_n, FLAG_R_OPTIONAL },

  { "mpn_xor_n",         speed_mpn_xor_n,  FLAG_R_OPTIONAL },

  { "mpn_xnor_n",        speed_mpn_xnor_n, FLAG_R_OPTIONAL },

  { "mpn_com",           speed_mpn_com              },

  { "mpn_neg",           speed_mpn_neg              },

  { "mpn_popcount",      speed_mpn_popcount         },

  { "mpn_hamdist",       speed_mpn_hamdist          },

  { "mpn_matrix22_mul",  speed_mpn_matrix22_mul     },

  { "mpn_hgcd",          speed_mpn_hgcd             },

  { "mpn_hgcd_lehmer",   speed_mpn_hgcd_lehmer      },

  { "mpn_hgcd_appr",     speed_mpn_hgcd_appr        },

  { "mpn_hgcd_appr_lehmer", speed_mpn_hgcd_appr_lehmer },

  { "mpn_hgcd_reduce",   speed_mpn_hgcd_reduce      },

  { "mpn_hgcd_reduce_1", speed_mpn_hgcd_reduce_1    },

  { "mpn_hgcd_reduce_2", speed_mpn_hgcd_reduce_2    },

  { "mpn_gcd_1",         speed_mpn_gcd_1,  FLAG_R_OPTIONAL },

  { "mpn_gcd_1N",        speed_mpn_gcd_1N, FLAG_R_OPTIONAL },

  { "mpn_gcd",           speed_mpn_gcd                    },

  { "mpn_gcdext",            speed_mpn_gcdext            },

  { "mpn_gcdext_single",     speed_mpn_gcdext_single     },

  { "mpn_gcdext_double",     speed_mpn_gcdext_double     },

  { "mpn_gcdext_one_single", speed_mpn_gcdext_one_single },

  { "mpn_gcdext_one_double", speed_mpn_gcdext_one_double },

#if 0

  { "mpn_gcdext_lehmer",     speed_mpn_gcdext_lehmer     },

#endif

  { "mpz_jacobi",        speed_mpz_jacobi           },

  { "mpn_jacobi_base",   speed_mpn_jacobi_base      },

  { "mpn_jacobi_base_1", speed_mpn_jacobi_base_1    },

  { "mpn_jacobi_base_2", speed_mpn_jacobi_base_2    },

  { "mpn_jacobi_base_3", speed_mpn_jacobi_base_3    },

  { "mpn_jacobi_base_4", speed_mpn_jacobi_base_4    },

  { "mpn_mul",           speed_mpn_mul,         FLAG_R_OPTIONAL },

  { "mpn_mul_basecase",  speed_mpn_mul_basecase,FLAG_R_OPTIONAL },

  { "mpn_sqr_basecase",  speed_mpn_sqr_basecase     },

#if HAVE_NATIVE_mpn_sqr_diagonal

  { "mpn_sqr_diagonal",  speed_mpn_sqr_diagonal     },

#endif

#if HAVE_NATIVE_mpn_sqr_diag_addlsh1

  { "mpn_sqr_diag_addlsh1", speed_mpn_sqr_diag_addlsh1 },

#endif

  { "mpn_mul_n",         speed_mpn_mul_n            },

  { "mpn_sqr",           speed_mpn_sqr              },

  { "mpn_toom2_sqr",     speed_mpn_toom2_sqr        },

  { "mpn_toom3_sqr",     speed_mpn_toom3_sqr        },

  { "mpn_toom4_sqr",     speed_mpn_toom4_sqr        },

  { "mpn_toom6_sqr",     speed_mpn_toom6_sqr        },

  { "mpn_toom8_sqr",     speed_mpn_toom8_sqr        },

  { "mpn_toom22_mul",    speed_mpn_toom22_mul       },

  { "mpn_toom33_mul",    speed_mpn_toom33_mul       },

  { "mpn_toom44_mul",    speed_mpn_toom44_mul       },

  { "mpn_toom6h_mul",    speed_mpn_toom6h_mul       },

  { "mpn_toom8h_mul",    speed_mpn_toom8h_mul       },

  { "mpn_toom32_mul",    speed_mpn_toom32_mul       },

  { "mpn_toom42_mul",    speed_mpn_toom42_mul       },

  { "mpn_toom43_mul",    speed_mpn_toom43_mul       },

  { "mpn_toom63_mul",    speed_mpn_toom63_mul       },

  { "mpn_nussbaumer_mul",    speed_mpn_nussbaumer_mul    },

  { "mpn_nussbaumer_mul_sqr",speed_mpn_nussbaumer_mul_sqr},

#if WANT_OLD_FFT_FULL

  { "mpn_mul_fft_full",      speed_mpn_mul_fft_full      },

  { "mpn_mul_fft_full_sqr",  speed_mpn_mul_fft_full_sqr  },

#endif

  { "mpn_mul_fft",       speed_mpn_mul_fft,     FLAG_R_OPTIONAL },

  { "mpn_mul_fft_sqr",   speed_mpn_mul_fft_sqr, FLAG_R_OPTIONAL },

  { "mpn_sqrlo",          speed_mpn_sqrlo           },

  { "mpn_sqrlo_basecase", speed_mpn_sqrlo_basecase  },

  { "mpn_mullo_n",        speed_mpn_mullo_n         },

  { "mpn_mullo_basecase", speed_mpn_mullo_basecase  },

  { "mpn_mulmid_basecase",  speed_mpn_mulmid_basecase, FLAG_R_OPTIONAL },

  { "mpn_toom42_mulmid",    speed_mpn_toom42_mulmid },

  { "mpn_mulmid_n",         speed_mpn_mulmid_n },

  { "mpn_mulmid",           speed_mpn_mulmid, FLAG_R_OPTIONAL },

  { "mpn_bc_mulmod_bnm1",      speed_mpn_bc_mulmod_bnm1      },

  { "mpn_mulmod_bnm1",         speed_mpn_mulmod_bnm1         },

  { "mpn_mulmod_bnm1_rounded", speed_mpn_mulmod_bnm1_rounded },

  { "mpn_sqrmod_bnm1",         speed_mpn_sqrmod_bnm1         },

  { "mpn_invert",              speed_mpn_invert              },

  { "mpn_invertappr",          speed_mpn_invertappr          },

  { "mpn_ni_invertappr",       speed_mpn_ni_invertappr       },

  { "mpn_binvert",             speed_mpn_binvert             },

  { "mpn_sec_invert",          speed_mpn_sec_invert          },

  { "mpn_sbpi1_div_qr",        speed_mpn_sbpi1_div_qr,    FLAG_R_OPTIONAL},

  { "mpn_dcpi1_div_qr",        speed_mpn_dcpi1_div_qr,    FLAG_R_OPTIONAL},

  { "mpn_mu_div_qr",           speed_mpn_mu_div_qr,       FLAG_R_OPTIONAL},

  { "mpn_mupi_div_qr",         speed_mpn_mupi_div_qr,     FLAG_R_OPTIONAL},

  { "mpn_sbpi1_divappr_q",     speed_mpn_sbpi1_divappr_q, FLAG_R_OPTIONAL},

  { "mpn_dcpi1_divappr_q",     speed_mpn_dcpi1_divappr_q, FLAG_R_OPTIONAL},

  { "mpn_sbpi1_bdiv_qr",       speed_mpn_sbpi1_bdiv_qr       },

  { "mpn_dcpi1_bdiv_qr",       speed_mpn_dcpi1_bdiv_qr       },

  { "mpn_sbpi1_bdiv_q",        speed_mpn_sbpi1_bdiv_q        },

  { "mpn_dcpi1_bdiv_q",        speed_mpn_dcpi1_bdiv_q        },

  { "mpn_broot",               speed_mpn_broot,    FLAG_R },

  { "mpn_broot_invm1",         speed_mpn_broot_invm1, FLAG_R },

  { "mpn_brootinv",            speed_mpn_brootinv, FLAG_R },

  { "mpn_get_str",          speed_mpn_get_str,     FLAG_R_OPTIONAL },

  { "mpn_set_str",          speed_mpn_set_str,     FLAG_R_OPTIONAL },

  { "mpn_set_str_basecase", speed_mpn_bc_set_str,  FLAG_R_OPTIONAL },

  { "mpn_sqrtrem",       speed_mpn_sqrtrem          },

  { "mpn_rootrem",       speed_mpn_rootrem, FLAG_R  },

  { "mpn_sqrt",          speed_mpn_sqrt             },

  { "mpn_root",          speed_mpn_root, FLAG_R     },

  { "mpn_fib2_ui",       speed_mpn_fib2_ui,    FLAG_NODATA },

  { "mpz_fib_ui",        speed_mpz_fib_ui,     FLAG_NODATA },

  { "mpz_fib2_ui",       speed_mpz_fib2_ui,    FLAG_NODATA },

  { "mpz_lucnum_ui",     speed_mpz_lucnum_ui,  FLAG_NODATA },

  { "mpz_lucnum2_ui",    speed_mpz_lucnum2_ui, FLAG_NODATA },

  { "mpz_add",           speed_mpz_add              },

  { "mpz_bin_uiui",      speed_mpz_bin_uiui, FLAG_NODATA | FLAG_R_OPTIONAL },

  { "mpz_bin_ui",        speed_mpz_bin_ui,   FLAG_NODATA | FLAG_R_OPTIONAL },

  { "mpz_fac_ui",        speed_mpz_fac_ui,   FLAG_NODATA   },

  { "mpz_2fac_ui",       speed_mpz_2fac_ui,  FLAG_NODATA   },

  { "mpz_powm",          speed_mpz_powm             },

  { "mpz_powm_mod",      speed_mpz_powm_mod         },

  { "mpz_powm_redc",     speed_mpz_powm_redc        },

  { "mpz_powm_sec",      speed_mpz_powm_sec        },

  { "mpz_powm_ui",       speed_mpz_powm_ui,  FLAG_R_OPTIONAL },

  { "mpz_mod",           speed_mpz_mod              },

  { "mpn_redc_1",        speed_mpn_redc_1           },

  { "mpn_redc_2",        speed_mpn_redc_2           },

  { "mpn_redc_n",        speed_mpn_redc_n           },

  { "MPN_COPY",          speed_MPN_COPY             },

  { "MPN_COPY_INCR",     speed_MPN_COPY_INCR        },

  { "MPN_COPY_DECR",     speed_MPN_COPY_DECR        },

  { "memcpy",            speed_memcpy               },

#if HAVE_NATIVE_mpn_copyi

  { "mpn_copyi",         speed_mpn_copyi            },

#endif

#if HAVE_NATIVE_mpn_copyd

  { "mpn_copyd",         speed_mpn_copyd            },

#endif

  { "mpn_sec_tabselect", speed_mpn_sec_tabselect, FLAG_R_OPTIONAL },

#if HAVE_NATIVE_mpn_addlsh1_n == 1

  { "mpn_addlsh1_n",     speed_mpn_addlsh1_n, FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_sublsh1_n == 1

  { "mpn_sublsh1_n",     speed_mpn_sublsh1_n, FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_addlsh1_n_ip1

  { "mpn_addlsh1_n_ip1", speed_mpn_addlsh1_n_ip1    },

#endif

#if HAVE_NATIVE_mpn_addlsh1_n_ip2

  { "mpn_addlsh1_n_ip2", speed_mpn_addlsh1_n_ip2    },

#endif

#if HAVE_NATIVE_mpn_sublsh1_n_ip1

  { "mpn_sublsh1_n_ip1", speed_mpn_sublsh1_n_ip1    },

#endif

#if HAVE_NATIVE_mpn_rsblsh1_n == 1

  { "mpn_rsblsh1_n",     speed_mpn_rsblsh1_n, FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_addlsh2_n == 1

  { "mpn_addlsh2_n",     speed_mpn_addlsh2_n, FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_sublsh2_n == 1

  { "mpn_sublsh2_n",     speed_mpn_sublsh2_n, FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_addlsh2_n_ip1

  { "mpn_addlsh2_n_ip1", speed_mpn_addlsh2_n_ip1    },

#endif

#if HAVE_NATIVE_mpn_addlsh2_n_ip2

  { "mpn_addlsh2_n_ip2", speed_mpn_addlsh2_n_ip2    },

#endif

#if HAVE_NATIVE_mpn_sublsh2_n_ip1

  { "mpn_sublsh2_n_ip1", speed_mpn_sublsh2_n_ip1    },

#endif

#if HAVE_NATIVE_mpn_rsblsh2_n == 1

  { "mpn_rsblsh2_n",     speed_mpn_rsblsh2_n, FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_addlsh_n

  { "mpn_addlsh_n",     speed_mpn_addlsh_n, FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_sublsh_n

  { "mpn_sublsh_n",     speed_mpn_sublsh_n, FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_addlsh_n_ip1

  { "mpn_addlsh_n_ip1", speed_mpn_addlsh_n_ip1    },

#endif

#if HAVE_NATIVE_mpn_addlsh_n_ip2

  { "mpn_addlsh_n_ip2", speed_mpn_addlsh_n_ip2    },

#endif

#if HAVE_NATIVE_mpn_sublsh_n_ip1

  { "mpn_sublsh_n_ip1", speed_mpn_sublsh_n_ip1    },

#endif

#if HAVE_NATIVE_mpn_rsblsh_n

  { "mpn_rsblsh_n",     speed_mpn_rsblsh_n, FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_rsh1add_n

  { "mpn_rsh1add_n",     speed_mpn_rsh1add_n, FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_rsh1sub_n

  { "mpn_rsh1sub_n",     speed_mpn_rsh1sub_n, FLAG_R_OPTIONAL },

#endif

  { "mpn_cnd_add_n",     speed_mpn_cnd_add_n, FLAG_R_OPTIONAL },

  { "mpn_cnd_sub_n",     speed_mpn_cnd_sub_n, FLAG_R_OPTIONAL },

  { "MPN_ZERO",          speed_MPN_ZERO             },

  { "binvert_limb",       speed_binvert_limb,       FLAG_NODATA },

  { "binvert_limb_mul1",  speed_binvert_limb_mul1,  FLAG_NODATA },

  { "binvert_limb_loop",  speed_binvert_limb_loop,  FLAG_NODATA },

  { "binvert_limb_cond",  speed_binvert_limb_cond,  FLAG_NODATA },

  { "binvert_limb_arith", speed_binvert_limb_arith, FLAG_NODATA },

  { "malloc_free",                  speed_malloc_free                  },

  { "malloc_realloc_free",          speed_malloc_realloc_free          },

  { "gmp_allocate_free",            speed_gmp_allocate_free            },

  { "gmp_allocate_reallocate_free", speed_gmp_allocate_reallocate_free },

  { "mpz_init_clear",               speed_mpz_init_clear               },

  { "mpq_init_clear",               speed_mpq_init_clear               },

  { "mpf_init_clear",               speed_mpf_init_clear               },

  { "mpz_init_realloc_clear",       speed_mpz_init_realloc_clear       },

  { "umul_ppmm",         speed_umul_ppmm,     FLAG_R_OPTIONAL },

#if HAVE_NATIVE_mpn_umul_ppmm

  { "mpn_umul_ppmm",     speed_mpn_umul_ppmm, FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_umul_ppmm_r

  { "mpn_umul_ppmm_r",   speed_mpn_umul_ppmm_r, FLAG_R_OPTIONAL },

#endif

  { "count_leading_zeros",  speed_count_leading_zeros,  FLAG_NODATA | FLAG_R_OPTIONAL },

  { "count_trailing_zeros", speed_count_trailing_zeros, FLAG_NODATA | FLAG_R_OPTIONAL },

  { "udiv_qrnnd",             speed_udiv_qrnnd,             FLAG_R_OPTIONAL },

  { "udiv_qrnnd_c",           speed_udiv_qrnnd_c,           FLAG_R_OPTIONAL },

#if HAVE_NATIVE_mpn_udiv_qrnnd

  { "mpn_udiv_qrnnd",         speed_mpn_udiv_qrnnd,         FLAG_R_OPTIONAL },

#endif

#if HAVE_NATIVE_mpn_udiv_qrnnd_r

  { "mpn_udiv_qrnnd_r",       speed_mpn_udiv_qrnnd_r,       FLAG_R_OPTIONAL },

#endif

  { "invert_limb",            speed_invert_limb,            FLAG_R_OPTIONAL },

  { "operator_div",           speed_operator_div,           FLAG_R_OPTIONAL },

  { "operator_mod",           speed_operator_mod,           FLAG_R_OPTIONAL },

  { "gmp_randseed",    speed_gmp_randseed,    FLAG_R_OPTIONAL               },

  { "gmp_randseed_ui", speed_gmp_randseed_ui, FLAG_R_OPTIONAL | FLAG_NODATA },

  { "mpz_urandomb",    speed_mpz_urandomb,    FLAG_R_OPTIONAL | FLAG_NODATA },

#ifdef SPEED_EXTRA_ROUTINES

  SPEED_EXTRA_ROUTINES

#endif

#ifdef SPEED_EXTRA_ROUTINES2

  SPEED_EXTRA_ROUTINES2

#endif

};

struct choice_t {

  const struct routine_t  *p;

  mp_limb_t               r;

  double                  scale;

  double                  time;

  int                     no_time;

  double                  prev_time;

  const char              *name;

};

struct choice_t  *choice;

int  num_choices = 0;

void

data_fill (mp_ptr ptr, mp_size_t size)

{

  switch (option_data) {

  case DATA_RANDOM:

    mpn_random (ptr, size);

    break;

  case DATA_RANDOM2:

    mpn_random2 (ptr, size);

    break;

  case DATA_ZEROS:

    MPN_ZERO (ptr, size);

    break;

  case DATA_AAS:

    MPN_FILL (ptr, size, GMP_NUMB_0xAA);

    break;

  case DATA_FFS:

    MPN_FILL (ptr, size, GMP_NUMB_MAX);

    break;

  case DATA_2FD:

    MPN_FILL (ptr, size, GMP_NUMB_MAX);

    ptr[0] -= 2;

    break;

  default:

    abort();

    /*NOTREACHED*/

  }

}

/* The code here handling the various combinations of output options isn't

   too attractive, but it works and is fairly clean.  */

#define SIZE_TO_DIVISOR(n)              \

  (option_square == 1 ? (n)*(n)         \

  : option_square == 2 ? (n)*((n)+1)/2  \

  : (n))

void

run_one (FILE *fp, struct speed_params *s, mp_size_t prev_size)

{

  const char  *first_open_fastest, *first_open_notfastest, *first_close;

  int         i, fastest, want_data;

  double      fastest_time;

  TMP_DECL;

  TMP_MARK;

  /* allocate data, unless all routines are NODATA */

  want_data = 0;

  for (i = 0; i < num_choices; i++)

    want_data |= ((choice[i].p->flag & FLAG_NODATA) == 0);

  if (want_data)

    {

      SPEED_TMP_ALLOC_LIMBS (sp.xp, s->size, s->align_xp);

      SPEED_TMP_ALLOC_LIMBS (sp.yp, s->size, s->align_yp);

      data_fill (s->xp, s->size);

      data_fill (s->yp, s->size);

    }

  else

    {

      sp.xp = NULL;

      sp.yp = NULL;

    }

  if (prev_size == -1 && option_cmp == CMP_DIFFPREV)

    {

      first_open_fastest = "(#";

      first_open_notfastest = " (";

      first_close = ")";

    }

  else

    {

      first_open_fastest = "#";

      first_open_notfastest = " ";

      first_close = "";

    }

  fastest = -1;

  fastest_time = -1.0;

  for (i = 0; i < num_choices; i++)

    {

      s->r = choice[i].r;

      choice[i].time = speed_measure (choice[i].p->fun, s);

      choice[i].no_time = (choice[i].time == -1.0);

      if (! choice[i].no_time)

        choice[i].time *= choice[i].scale;

      /* Apply the effect of CMP_DIFFPREV, but the new choice[i].prev_time

         is before any differences.  */

      {

        double     t;

        t = choice[i].time;

        if (t != -1.0 && option_cmp == CMP_DIFFPREV && prev_size != -1)

          {

            if (choice[i].prev_time == -1.0)

              choice[i].no_time = 1;

            else

              choice[i].time = choice[i].time - choice[i].prev_time;

          }

        choice[i].prev_time = t;

      }

      if (choice[i].no_time)

        continue;

      /* Look for the fastest after CMP_DIFFPREV has been applied, but

         before CMP_RATIO or CMP_DIFFERENCE.  There's only a fastest shown

         if there's more than one routine.  */

      if (num_choices > 1 && (fastest == -1 || choice[i].time < fastest_time))

        {

          fastest = i;

          fastest_time = choice[i].time;

        }

      if (option_cmp == CMP_DIFFPREV)

        {

          /* Conversion for UNIT_CYCLESPERLIMB differs in CMP_DIFFPREV. */

          if (option_unit == UNIT_CYCLES)

            choice[i].time /= speed_cycletime;

          else if (option_unit == UNIT_CYCLESPERLIMB)

            {

              if (prev_size == -1)

                choice[i].time /= speed_cycletime;

              else

                choice[i].time /=  (speed_cycletime

                                    * (SIZE_TO_DIVISOR(s->size)

                                       - SIZE_TO_DIVISOR(prev_size)));

            }

        }

      else

        {

          if (option_unit == UNIT_CYCLES)

            choice[i].time /= speed_cycletime;

          else if (option_unit == UNIT_CYCLESPERLIMB)

            choice[i].time /= (speed_cycletime * SIZE_TO_DIVISOR(s->size));

          if (option_cmp == CMP_RATIO && i > 0)

            {

              /* A ratio isn't affected by the units chosen. */

              if (choice[0].no_time || choice[0].time == 0.0)

                choice[i].no_time = 1;

              else

                choice[i].time /= choice[0].time;

            }

          else if (option_cmp == CMP_DIFFERENCE && i > 0)

            {

              if (choice[0].no_time)

                {

                  choice[i].no_time = 1;

                  continue;

                }

              choice[i].time -= choice[0].time;

            }

        }

    }

  if (option_gnuplot)

    {

      /* In CMP_DIFFPREV, don't print anything for the first size, start

         with the second where an actual difference is available.

         In CMP_RATIO, print the first column as 1.0.

         The 9 decimals printed is much more than the expected precision of

         the measurements actually. */

      if (! (option_cmp == CMP_DIFFPREV && prev_size == -1))

        {

          fprintf (fp, "%-6ld ", s->size);

          for (i = 0; i < num_choices; i++)

            fprintf (fp, "  %.9e",

                     choice[i].no_time ? 0.0

                     : (option_cmp == CMP_RATIO && i == 0) ? 1.0

                     : choice[i].time);

          fprintf (fp, "\n");

        }

    }

  else

    {

      fprintf (fp, "%-6ld ", s->size);

      for (i = 0; i < num_choices; i++)

        {

          char  buf[128];

          int   decimals;

          if (choice[i].no_time)

            {

              fprintf (fp, " %*s", COLUMN_WIDTH, "n/a");

            }

          else

            {if (option_unit == UNIT_CYCLESPERLIMB

                 || (option_cmp == CMP_RATIO && i > 0))

                decimals = 4;

              else if (option_unit == UNIT_CYCLES)

                decimals = 2;

              else

                decimals = 9;

              sprintf (buf, "%s%.*f%s",

                       i == fastest ? first_open_fastest : first_open_notfastest,

                       decimals, choice[i].time, first_close);

              fprintf (fp, " %*s", COLUMN_WIDTH, buf);

            }

        }

      fprintf (fp, "\n");

    }

  TMP_FREE;

}

void

run_all (FILE *fp)

{

  mp_size_t  prev_size;

  int        i;

  TMP_DECL;

  TMP_MARK;

  SPEED_TMP_ALLOC_LIMBS (sp.xp_block, SPEED_BLOCK_SIZE, sp.align_xp);

  SPEED_TMP_ALLOC_LIMBS (sp.yp_block, SPEED_BLOCK_SIZE, sp.align_yp);

  data_fill (sp.xp_block, SPEED_BLOCK_SIZE);

  data_fill (sp.yp_block, SPEED_BLOCK_SIZE);

  for (i = 0; i < size_num; i++)

    {

      sp.size = size_array[i].start;

      prev_size = -1;

      for (;;)

        {

          mp_size_t  step;

          if (option_data == DATA_2FD && sp.size >= 2)

            sp.xp[sp.size-1] = 2;

          run_one (fp, &sp, prev_size);

          prev_size = sp.size;

          if (option_data == DATA_2FD && sp.size >= 2)

            sp.xp[sp.size-1] = MP_LIMB_T_MAX;

          if (option_factor != 0.0)

            {

              step = (mp_size_t) (sp.size * option_factor - sp.size);

              if (step < 1)

                step = 1;

            }

          else

            step = 1;

          if (step < option_step)

            step = option_step;

          sp.size += step;

          if (sp.size > size_array[i].end)

            break;

        }

    }

  TMP_FREE;

}

FILE *

fopen_for_write (const char *filename)

{

  FILE  *fp;

  if ((fp = fopen (filename, "w")) == NULL)

    {

      fprintf (stderr, "Cannot create %s\n", filename);

      exit(1);

    }

  return fp;

}

void

fclose_written (FILE *fp, const char *filename)

{

  int  err;

  err = ferror (fp);

  err |= fclose (fp);

  if (err)

    {

      fprintf (stderr, "Error writing %s\n", filename);

      exit(1);

    }

}

void

run_gnuplot (int argc, char *argv[])

{

  char  *plot_filename;

  char  *data_filename;

  FILE  *fp;

  int   i;

  plot_filename = (char *) (*__gmp_allocate_func)

    (strlen (option_gnuplot_basename) + 20);

  data_filename = (char *) (*__gmp_allocate_func)

    (strlen (option_gnuplot_basename) + 20);

  sprintf (plot_filename, "%s.gnuplot", option_gnuplot_basename);

  sprintf (data_filename, "%s.data",    option_gnuplot_basename);

  fp = fopen_for_write (plot_filename);

  fprintf (fp, "# Generated with:\n");

  fprintf (fp, "#");

  for (i = 0; i < argc; i++)

    fprintf (fp, " %s", argv[i]);

  fprintf (fp, "\n");

  fprintf (fp, "\n");