/* Header for speed and threshold things.

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/.  */

#ifndef __SPEED_H__

#define __SPEED_H__

/* Pad ptr,oldsize with zero limbs (at the most significant end) to make it

   newsize long. */

#define MPN_ZERO_EXTEND(ptr, oldsize, newsize)		\

  do {							\

    ASSERT ((newsize) >= (oldsize));			\

    MPN_ZERO ((ptr)+(oldsize), (newsize)-(oldsize));	\

  } while (0)

/* A mask of the least significant n bits.  Note 1<<32 doesn't give zero on

   x86 family CPUs, hence the separate case for GMP_LIMB_BITS. */

#define MP_LIMB_T_LOWBITMASK(n)	\

  ((n) == GMP_LIMB_BITS ? MP_LIMB_T_MAX : ((mp_limb_t) 1 << (n)) - 1)

/* align must be a power of 2 here, usually CACHE_LINE_SIZE is a good choice */

#define TMP_ALLOC_ALIGNED(bytes, align)	\

  align_pointer (TMP_ALLOC ((bytes) + (align)-1), (align))

#define TMP_ALLOC_LIMBS_ALIGNED(limbs, align)	\

  ((mp_ptr) TMP_ALLOC_ALIGNED ((limbs)*sizeof(mp_limb_t), align))

/* CACHE_LINE_SIZE is our default alignment for speed operands, and the

   limit on what s->align_xp etc and then request for off-alignment.  Maybe

   this should be an option of some sort, but in any case here are some line

   sizes,

       bytes

	 32   pentium

	 64   athlon

	 64   itanium-2 L1

	128   itanium-2 L2

*/

#define CACHE_LINE_SIZE   64 /* bytes */

#define SPEED_TMP_ALLOC_ADJUST_MASK  (CACHE_LINE_SIZE/GMP_LIMB_BYTES - 1)

/* Set ptr to a TMP_ALLOC block of the given limbs, with the given limb

   alignment.  */

#define SPEED_TMP_ALLOC_LIMBS(ptr, limbs, align)			\

  do {									\

    mp_ptr     __ptr;							\

    mp_size_t  __ptr_align, __ptr_add;					\

									\

    ASSERT ((CACHE_LINE_SIZE % GMP_LIMB_BYTES) == 0);		\

    __ptr = TMP_ALLOC_LIMBS ((limbs) + SPEED_TMP_ALLOC_ADJUST_MASK);	\

    __ptr_align = (__ptr - (mp_ptr) NULL);				\

    __ptr_add = ((align) - __ptr_align) & SPEED_TMP_ALLOC_ADJUST_MASK;	\

    (ptr) = __ptr + __ptr_add;						\

  } while (0)

/* This is the size for s->xp_block and s->yp_block, used in certain

   routines that want to run across many different data values and use

   s->size for a different purpose, eg. SPEED_ROUTINE_MPN_GCD_1.

   512 means 2kbytes of data for each of xp_block and yp_block, making 4k

   total, which should fit easily in any L1 data cache. */

#define SPEED_BLOCK_SIZE   512 /* limbs */

extern double  speed_unittime;

extern double  speed_cycletime;

extern int     speed_precision;

extern char    speed_time_string[];

void speed_time_init (void);

void speed_cycletime_fail (const char *str);

void speed_cycletime_init (void);

void speed_cycletime_need_cycles (void);

void speed_cycletime_need_seconds (void);

void speed_starttime (void);

double speed_endtime (void);

struct speed_params {

  unsigned   reps;	/* how many times to run the routine */

  mp_ptr     xp;	/* first argument */

  mp_ptr     yp;	/* second argument */

  mp_size_t  size;	/* size of both arguments */

  mp_limb_t  r;		/* user supplied parameter */

  mp_size_t  align_xp;	/* alignment of xp */

  mp_size_t  align_yp;	/* alignment of yp */

  mp_size_t  align_wp;	/* intended alignment of wp */

  mp_size_t  align_wp2; /* intended alignment of wp2 */

  mp_ptr     xp_block;	/* first special SPEED_BLOCK_SIZE block */

  mp_ptr     yp_block;	/* second special SPEED_BLOCK_SIZE block */

  double     time_divisor; /* optionally set by the speed routine */

  /* used by the cache priming things */

  int	     cache;

  unsigned   src_num, dst_num;

  struct {

    mp_ptr    ptr;

    mp_size_t size;

  } src[5], dst[4];

};

typedef double (*speed_function_t) (struct speed_params *);

double speed_measure (speed_function_t fun, struct speed_params *);

/* Prototypes for speed measuring routines */

double speed_back_to_back (struct speed_params *);

double speed_count_leading_zeros (struct speed_params *);

double speed_count_trailing_zeros (struct speed_params *);

double speed_find_a (struct speed_params *);

double speed_gmp_allocate_free (struct speed_params *);

double speed_gmp_allocate_reallocate_free (struct speed_params *);

double speed_invert_limb (struct speed_params *);

double speed_malloc_free (struct speed_params *);

double speed_malloc_realloc_free (struct speed_params *);

double speed_memcpy (struct speed_params *);

double speed_binvert_limb (struct speed_params *);

double speed_binvert_limb_mul1 (struct speed_params *);

double speed_binvert_limb_loop (struct speed_params *);

double speed_binvert_limb_cond (struct speed_params *);

double speed_binvert_limb_arith (struct speed_params *);

double speed_mpf_init_clear (struct speed_params *);

double speed_mpn_add_n (struct speed_params *);

double speed_mpn_add_1 (struct speed_params *);

double speed_mpn_add_1_inplace (struct speed_params *);

double speed_mpn_add_err1_n (struct speed_params *);

double speed_mpn_add_err2_n (struct speed_params *);

double speed_mpn_add_err3_n (struct speed_params *);

double speed_mpn_addlsh_n (struct speed_params *);

double speed_mpn_addlsh1_n (struct speed_params *);

double speed_mpn_addlsh2_n (struct speed_params *);

double speed_mpn_addlsh_n_ip1 (struct speed_params *);

double speed_mpn_addlsh1_n_ip1 (struct speed_params *);

double speed_mpn_addlsh2_n_ip1 (struct speed_params *);

double speed_mpn_addlsh_n_ip2 (struct speed_params *);

double speed_mpn_addlsh1_n_ip2 (struct speed_params *);

double speed_mpn_addlsh2_n_ip2 (struct speed_params *);

double speed_mpn_add_n_sub_n (struct speed_params *);

double speed_mpn_and_n (struct speed_params *);

double speed_mpn_andn_n (struct speed_params *);

double speed_mpn_addmul_1 (struct speed_params *);

double speed_mpn_addmul_2 (struct speed_params *);

double speed_mpn_addmul_3 (struct speed_params *);

double speed_mpn_addmul_4 (struct speed_params *);

double speed_mpn_addmul_5 (struct speed_params *);

double speed_mpn_addmul_6 (struct speed_params *);

double speed_mpn_addmul_7 (struct speed_params *);

double speed_mpn_addmul_8 (struct speed_params *);

double speed_mpn_cnd_add_n (struct speed_params *);

double speed_mpn_cnd_sub_n (struct speed_params *);

double speed_mpn_com (struct speed_params *);

double speed_mpn_neg (struct speed_params *);

double speed_mpn_copyd (struct speed_params *);

double speed_mpn_copyi (struct speed_params *);

double speed_MPN_COPY (struct speed_params *);

double speed_MPN_COPY_DECR (struct speed_params *);

double speed_MPN_COPY_INCR (struct speed_params *);

double speed_mpn_sec_tabselect (struct speed_params *);

double speed_mpn_divexact_1 (struct speed_params *);

double speed_mpn_divexact_by3 (struct speed_params *);

double speed_mpn_bdiv_q_1 (struct speed_params *);

double speed_mpn_pi1_bdiv_q_1 (struct speed_params *);

double speed_mpn_bdiv_dbm1c (struct speed_params *);

double speed_mpn_divrem_1 (struct speed_params *);

double speed_mpn_divrem_1f (struct speed_params *);

double speed_mpn_divrem_1c (struct speed_params *);

double speed_mpn_divrem_1cf (struct speed_params *);

double speed_mpn_divrem_1_div (struct speed_params *);

double speed_mpn_divrem_1f_div (struct speed_params *);

double speed_mpn_divrem_1_inv (struct speed_params *);

double speed_mpn_divrem_1f_inv (struct speed_params *);

double speed_mpn_divrem_2 (struct speed_params *);

double speed_mpn_divrem_2_div (struct speed_params *);

double speed_mpn_divrem_2_inv (struct speed_params *);

double speed_mpn_div_qr_1n_pi1 (struct speed_params *);

double speed_mpn_div_qr_1n_pi1_1 (struct speed_params *);

double speed_mpn_div_qr_1n_pi1_2 (struct speed_params *);

double speed_mpn_div_qr_1 (struct speed_params *);

double speed_mpn_div_qr_2n (struct speed_params *);

double speed_mpn_div_qr_2u (struct speed_params *);

double speed_mpn_fib2_ui (struct speed_params *);

double speed_mpn_matrix22_mul (struct speed_params *);

double speed_mpn_hgcd (struct speed_params *);

double speed_mpn_hgcd_lehmer (struct speed_params *);

double speed_mpn_hgcd_appr (struct speed_params *);

double speed_mpn_hgcd_appr_lehmer (struct speed_params *);

double speed_mpn_hgcd_reduce (struct speed_params *);

double speed_mpn_hgcd_reduce_1 (struct speed_params *);

double speed_mpn_hgcd_reduce_2 (struct speed_params *);

double speed_mpn_gcd (struct speed_params *);

double speed_mpn_gcd_1 (struct speed_params *);

double speed_mpn_gcd_1N (struct speed_params *);

double speed_mpn_gcdext (struct speed_params *);

double speed_mpn_gcdext_double (struct speed_params *);

double speed_mpn_gcdext_one_double (struct speed_params *);

double speed_mpn_gcdext_one_single (struct speed_params *);

double speed_mpn_gcdext_single (struct speed_params *);

double speed_mpn_get_str (struct speed_params *);

double speed_mpn_hamdist (struct speed_params *);

double speed_mpn_ior_n (struct speed_params *);

double speed_mpn_iorn_n (struct speed_params *);

double speed_mpn_jacobi_base (struct speed_params *);

double speed_mpn_jacobi_base_1 (struct speed_params *);

double speed_mpn_jacobi_base_2 (struct speed_params *);

double speed_mpn_jacobi_base_3 (struct speed_params *);

double speed_mpn_jacobi_base_4 (struct speed_params *);

double speed_mpn_lshift (struct speed_params *);

double speed_mpn_lshiftc (struct speed_params *);

double speed_mpn_mod_1 (struct speed_params *);

double speed_mpn_mod_1c (struct speed_params *);

double speed_mpn_mod_1_div (struct speed_params *);

double speed_mpn_mod_1_inv (struct speed_params *);

double speed_mpn_mod_1_1 (struct speed_params *);

double speed_mpn_mod_1_1_1 (struct speed_params *);

double speed_mpn_mod_1_1_2 (struct speed_params *);

double speed_mpn_mod_1_2 (struct speed_params *);

double speed_mpn_mod_1_3 (struct speed_params *);

double speed_mpn_mod_1_4 (struct speed_params *);

double speed_mpn_mod_34lsub1 (struct speed_params *);

double speed_mpn_modexact_1_odd (struct speed_params *);

double speed_mpn_modexact_1c_odd (struct speed_params *);

double speed_mpn_mul_1 (struct speed_params *);

double speed_mpn_mul_1_inplace (struct speed_params *);

double speed_mpn_mul_2 (struct speed_params *);

double speed_mpn_mul_3 (struct speed_params *);

double speed_mpn_mul_4 (struct speed_params *);

double speed_mpn_mul_5 (struct speed_params *);

double speed_mpn_mul_6 (struct speed_params *);

double speed_mpn_mul (struct speed_params *);

double speed_mpn_mul_basecase (struct speed_params *);

double speed_mpn_mulmid (struct speed_params *);

double speed_mpn_mulmid_basecase (struct speed_params *);

double speed_mpn_mul_fft (struct speed_params *);

double speed_mpn_mul_fft_sqr (struct speed_params *);

double speed_mpn_fft_mul (struct speed_params *);

double speed_mpn_fft_sqr (struct speed_params *);

#if WANT_OLD_FFT_FULL

double speed_mpn_mul_fft_full (struct speed_params *);

double speed_mpn_mul_fft_full_sqr (struct speed_params *);

#endif

double speed_mpn_nussbaumer_mul (struct speed_params *);

double speed_mpn_nussbaumer_mul_sqr (struct speed_params *);

double speed_mpn_mul_n (struct speed_params *);

double speed_mpn_mul_n_sqr (struct speed_params *);

double speed_mpn_mulmid_n (struct speed_params *);

double speed_mpn_sqrlo (struct speed_params *);

double speed_mpn_sqrlo_basecase (struct speed_params *);

double speed_mpn_mullo_n (struct speed_params *);

double speed_mpn_mullo_basecase (struct speed_params *);

double speed_mpn_nand_n (struct speed_params *);

double speed_mpn_nior_n (struct speed_params *);

double speed_mpn_popcount (struct speed_params *);

double speed_mpn_preinv_divrem_1 (struct speed_params *);

double speed_mpn_preinv_divrem_1f (struct speed_params *);

double speed_mpn_preinv_mod_1 (struct speed_params *);

double speed_mpn_sbpi1_div_qr (struct speed_params *);

double speed_mpn_dcpi1_div_qr (struct speed_params *);

double speed_mpn_sbpi1_divappr_q (struct speed_params *);

double speed_mpn_dcpi1_divappr_q (struct speed_params *);

double speed_mpn_mu_div_qr (struct speed_params *);

double speed_mpn_mu_divappr_q (struct speed_params *);

double speed_mpn_mupi_div_qr (struct speed_params *);

double speed_mpn_mu_div_q (struct speed_params *);

double speed_mpn_sbpi1_bdiv_qr (struct speed_params *);

double speed_mpn_dcpi1_bdiv_qr (struct speed_params *);

double speed_mpn_sbpi1_bdiv_q (struct speed_params *);

double speed_mpn_dcpi1_bdiv_q (struct speed_params *);

double speed_mpn_mu_bdiv_q (struct speed_params *);

double speed_mpn_mu_bdiv_qr (struct speed_params *);

double speed_mpn_broot (struct speed_params *);

double speed_mpn_broot_invm1 (struct speed_params *);

double speed_mpn_brootinv (struct speed_params *);

double speed_mpn_invert (struct speed_params *);

double speed_mpn_invertappr (struct speed_params *);

double speed_mpn_ni_invertappr (struct speed_params *);

double speed_mpn_sec_invert (struct speed_params *s);

double speed_mpn_binvert (struct speed_params *);

double speed_mpn_redc_1 (struct speed_params *);

double speed_mpn_redc_2 (struct speed_params *);

double speed_mpn_redc_n (struct speed_params *);

double speed_mpn_rsblsh_n (struct speed_params *);

double speed_mpn_rsblsh1_n (struct speed_params *);

double speed_mpn_rsblsh2_n (struct speed_params *);

double speed_mpn_rsh1add_n (struct speed_params *);

double speed_mpn_rsh1sub_n (struct speed_params *);

double speed_mpn_rshift (struct speed_params *);

double speed_mpn_sb_divrem_m3 (struct speed_params *);

double speed_mpn_sb_divrem_m3_div (struct speed_params *);

double speed_mpn_sb_divrem_m3_inv (struct speed_params *);

double speed_mpn_set_str (struct speed_params *);

double speed_mpn_bc_set_str (struct speed_params *);

double speed_mpn_dc_set_str (struct speed_params *);

double speed_mpn_set_str_pre (struct speed_params *);

double speed_mpn_sqr_basecase (struct speed_params *);

double speed_mpn_sqr_diag_addlsh1 (struct speed_params *);

double speed_mpn_sqr_diagonal (struct speed_params *);

double speed_mpn_sqr (struct speed_params *);

double speed_mpn_sqrtrem (struct speed_params *);

double speed_mpn_rootrem (struct speed_params *);

double speed_mpn_sqrt (struct speed_params *);

double speed_mpn_root (struct speed_params *);

double speed_mpn_sub_n (struct speed_params *);

double speed_mpn_sub_1 (struct speed_params *);

double speed_mpn_sub_1_inplace (struct speed_params *);

double speed_mpn_sub_err1_n (struct speed_params *);

double speed_mpn_sub_err2_n (struct speed_params *);

double speed_mpn_sub_err3_n (struct speed_params *);

double speed_mpn_sublsh_n (struct speed_params *);

double speed_mpn_sublsh1_n (struct speed_params *);

double speed_mpn_sublsh2_n (struct speed_params *);

double speed_mpn_sublsh_n_ip1 (struct speed_params *);

double speed_mpn_sublsh1_n_ip1 (struct speed_params *);

double speed_mpn_sublsh2_n_ip1 (struct speed_params *);

double speed_mpn_submul_1 (struct speed_params *);

double speed_mpn_toom2_sqr (struct speed_params *);

double speed_mpn_toom3_sqr (struct speed_params *);

double speed_mpn_toom4_sqr (struct speed_params *);

double speed_mpn_toom6_sqr (struct speed_params *);

double speed_mpn_toom8_sqr (struct speed_params *);

double speed_mpn_toom22_mul (struct speed_params *);

double speed_mpn_toom33_mul (struct speed_params *);

double speed_mpn_toom44_mul (struct speed_params *);

double speed_mpn_toom6h_mul (struct speed_params *);

double speed_mpn_toom8h_mul (struct speed_params *);

double speed_mpn_toom32_mul (struct speed_params *);

double speed_mpn_toom42_mul (struct speed_params *);

double speed_mpn_toom43_mul (struct speed_params *);

double speed_mpn_toom63_mul (struct speed_params *);

double speed_mpn_toom32_for_toom43_mul (struct speed_params *);

double speed_mpn_toom43_for_toom32_mul (struct speed_params *);

double speed_mpn_toom32_for_toom53_mul (struct speed_params *);

double speed_mpn_toom53_for_toom32_mul (struct speed_params *);

double speed_mpn_toom42_for_toom53_mul (struct speed_params *);

double speed_mpn_toom53_for_toom42_mul (struct speed_params *);

double speed_mpn_toom43_for_toom54_mul (struct speed_params *);

double speed_mpn_toom54_for_toom43_mul (struct speed_params *);

double speed_mpn_toom42_mulmid (struct speed_params *);

double speed_mpn_mulmod_bnm1 (struct speed_params *);

double speed_mpn_bc_mulmod_bnm1 (struct speed_params *);

double speed_mpn_mulmod_bnm1_rounded (struct speed_params *);

double speed_mpn_sqrmod_bnm1 (struct speed_params *);

double speed_mpn_udiv_qrnnd (struct speed_params *);

double speed_mpn_udiv_qrnnd_r (struct speed_params *);

double speed_mpn_umul_ppmm (struct speed_params *);

double speed_mpn_umul_ppmm_r (struct speed_params *);

double speed_mpn_xnor_n (struct speed_params *);

double speed_mpn_xor_n (struct speed_params *);

double speed_MPN_ZERO (struct speed_params *);

double speed_mpq_init_clear (struct speed_params *);

double speed_mpz_add (struct speed_params *);

double speed_mpz_bin_uiui (struct speed_params *);

double speed_mpz_bin_ui (struct speed_params *);

double speed_mpz_fac_ui (struct speed_params *);

double speed_mpz_2fac_ui (struct speed_params *);

double speed_mpz_fib_ui (struct speed_params *);

double speed_mpz_fib2_ui (struct speed_params *);

double speed_mpz_init_clear (struct speed_params *);

double speed_mpz_init_realloc_clear (struct speed_params *);

double speed_mpz_jacobi (struct speed_params *);

double speed_mpz_lucnum_ui (struct speed_params *);

double speed_mpz_lucnum2_ui (struct speed_params *);

double speed_mpz_mod (struct speed_params *);

double speed_mpz_powm (struct speed_params *);

double speed_mpz_powm_mod (struct speed_params *);

double speed_mpz_powm_redc (struct speed_params *);

double speed_mpz_powm_sec (struct speed_params *);

double speed_mpz_powm_ui (struct speed_params *);

double speed_mpz_urandomb (struct speed_params *);

double speed_gmp_randseed (struct speed_params *);

double speed_gmp_randseed_ui (struct speed_params *);

double speed_noop (struct speed_params *);

double speed_noop_wxs (struct speed_params *);

double speed_noop_wxys (struct speed_params *);

double speed_operator_div (struct speed_params *);

double speed_operator_mod (struct speed_params *);

double speed_udiv_qrnnd (struct speed_params *);

double speed_udiv_qrnnd_preinv1 (struct speed_params *);

double speed_udiv_qrnnd_preinv2 (struct speed_params *);

double speed_udiv_qrnnd_preinv3 (struct speed_params *);

double speed_udiv_qrnnd_c (struct speed_params *);

double speed_umul_ppmm (struct speed_params *);

/* Prototypes for other routines */

#if defined (__cplusplus)

extern "C" {

#endif

/* low 32-bits in p[0], high 32-bits in p[1] */

void speed_cyclecounter (unsigned p[2]);

#if defined (__cplusplus)

}

#endif

void mftb_function (unsigned p[2]);

double speed_cyclecounter_diff (const unsigned [2], const unsigned [2]);

int gettimeofday_microseconds_p (void);

int getrusage_microseconds_p (void);

int cycles_works_p (void);

long clk_tck (void);

double freq_measure (const char *, double (*)(void));

int double_cmp_ptr (const double *, const double *);

void pentium_wbinvd (void);

typedef int (*qsort_function_t) (const void *, const void *);

void noop (void);

void noop_1 (mp_limb_t);

void noop_wxs (mp_ptr, mp_srcptr, mp_size_t);

void noop_wxys (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);

void mpn_cache_fill (mp_srcptr, mp_size_t);

void mpn_cache_fill_dummy (mp_limb_t);

void speed_cache_fill (struct speed_params *);

void speed_operand_src (struct speed_params *, mp_ptr, mp_size_t);

void speed_operand_dst (struct speed_params *, mp_ptr, mp_size_t);

extern int  speed_option_addrs;

extern int  speed_option_verbose;

extern int  speed_option_cycles_broken;

void speed_option_set (const char *);

mp_limb_t mpn_div_qr_1n_pi1_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t, mp_limb_t, mp_limb_t);

mp_limb_t mpn_div_qr_1n_pi1_2 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t, mp_limb_t, mp_limb_t);

mp_limb_t mpn_divrem_1_div (mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_limb_t);

mp_limb_t mpn_divrem_1_inv (mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_limb_t);

mp_limb_t mpn_divrem_2_div (mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr);

mp_limb_t mpn_divrem_2_inv (mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr);

int mpn_jacobi_base_1 (mp_limb_t, mp_limb_t, int);

int mpn_jacobi_base_2 (mp_limb_t, mp_limb_t, int);

int mpn_jacobi_base_3 (mp_limb_t, mp_limb_t, int);

int mpn_jacobi_base_4 (mp_limb_t, mp_limb_t, int);

mp_limb_t mpn_mod_1_div (mp_srcptr, mp_size_t, mp_limb_t);

mp_limb_t mpn_mod_1_inv (mp_srcptr, mp_size_t, mp_limb_t);

mp_limb_t mpn_mod_1_1p_1 (mp_srcptr, mp_size_t, mp_limb_t, const mp_limb_t [4]);

mp_limb_t mpn_mod_1_1p_2 (mp_srcptr, mp_size_t, mp_limb_t, const mp_limb_t [4]);

void mpn_mod_1_1p_cps_1 (mp_limb_t [4], mp_limb_t);

void mpn_mod_1_1p_cps_2 (mp_limb_t [4], mp_limb_t);

mp_size_t mpn_gcdext_one_double (mp_ptr, mp_ptr, mp_size_t *, mp_ptr, mp_size_t, mp_ptr, mp_size_t);

mp_size_t mpn_gcdext_one_single (mp_ptr, mp_ptr, mp_size_t *, mp_ptr, mp_size_t, mp_ptr, mp_size_t);

mp_size_t mpn_gcdext_single (mp_ptr, mp_ptr, mp_size_t *, mp_ptr, mp_size_t, mp_ptr, mp_size_t);

mp_size_t mpn_gcdext_double (mp_ptr, mp_ptr, mp_size_t *, mp_ptr, mp_size_t, mp_ptr, mp_size_t);

mp_size_t mpn_hgcd_lehmer (mp_ptr, mp_ptr, mp_size_t, struct hgcd_matrix *, mp_ptr);

mp_size_t mpn_hgcd_lehmer_itch (mp_size_t);

mp_size_t mpn_hgcd_appr_lehmer (mp_ptr, mp_ptr, mp_size_t, struct hgcd_matrix *, mp_ptr);

mp_size_t mpn_hgcd_appr_lehmer_itch (mp_size_t);

mp_size_t mpn_hgcd_reduce_1 (struct hgcd_matrix *, mp_ptr, mp_ptr, mp_size_t, mp_size_t, mp_ptr);

mp_size_t mpn_hgcd_reduce_1_itch (mp_size_t, mp_size_t);

mp_size_t mpn_hgcd_reduce_2 (struct hgcd_matrix *, mp_ptr, mp_ptr, mp_size_t, mp_size_t, mp_ptr);

mp_size_t mpn_hgcd_reduce_2_itch (mp_size_t, mp_size_t);

mp_limb_t mpn_sb_divrem_mn_div (mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t);

mp_limb_t mpn_sb_divrem_mn_inv (mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t);

mp_size_t mpn_set_str_basecase (mp_ptr, const unsigned char *, size_t, int);

void mpn_pre_set_str (mp_ptr, unsigned char *, size_t, powers_t *, mp_ptr);

void mpz_powm_mod (mpz_ptr, mpz_srcptr, mpz_srcptr, mpz_srcptr);

void mpz_powm_redc (mpz_ptr, mpz_srcptr, mpz_srcptr, mpz_srcptr);

int speed_routine_count_zeros_setup (struct speed_params *, mp_ptr, int, int);

/* "get" is called repeatedly until it ticks over, just in case on a fast

   processor it takes less than a microsecond, though this is probably

   unlikely if it's a system call.

   speed_cyclecounter is called on the same side of the "get" for the start

   and end measurements.  It doesn't matter how long it takes from the "get"

   sample to the cycles sample, since that period will cancel out in the

   difference calculation (assuming it's the same each time).

   Letting the test run for more than a process time slice is probably only

   going to reduce accuracy, especially for getrusage when the cycle counter

   is real time, or for gettimeofday if the cycle counter is in fact process

   time.  Use CLK_TCK/2 as a reasonable stop.

   It'd be desirable to be quite accurate here.  The default speed_precision

   for a cycle counter is 10000 cycles, so to mix that with getrusage or

   gettimeofday the frequency should be at least that accurate.  But running

   measurements for 10000 microseconds (or more) is too long.  Be satisfied

   with just a half clock tick (5000 microseconds usually).  */

#define FREQ_MEASURE_ONE(name, type, get, getc, sec, usec)		\

  do {									\

    type      st1, st, et1, et;						\

    unsigned  sc[2], ec[2];						\

    long      dt, half_tick;						\

    double    dc, cyc;							\

									\

    half_tick = (1000000L / clk_tck()) / 2;				\

									\

    get (st1);								\

    do {								\

      get (st);								\

    } while (usec(st) == usec(st1) && sec(st) == sec(st1));		\

									\

    getc (sc);								\

									\

    for (;;)								\

      {									\

	get (et1);							\

	do {								\

	  get (et);							\

	} while (usec(et) == usec(et1) && sec(et) == sec(et1));		\

									\

	getc (ec);							\

									\

	dc = speed_cyclecounter_diff (ec, sc);				\

									\

	/* allow secs to cancel before multiplying */			\

	dt = sec(et) - sec(st);						\

	dt = dt * 1000000L + (usec(et) - usec(st));			\

									\

	if (dt >= half_tick)						\

	  break;							\

      }									\

									\

    cyc = dt * 1e-6 / dc;						\

									\

    if (speed_option_verbose >= 2)					\

      printf ("freq_measure_%s_one() dc=%.6g dt=%ld cyc=%.6g\n",	\

	      name, dc, dt, cyc);					\

									\

    return dt * 1e-6 / dc;						\

									\

  } while (0)

/* The measuring routines use these big macros to save duplication for

   similar forms.  They also get used for some automatically generated

   measuring of new implementations of functions.

   Having something like SPEED_ROUTINE_BINARY_N as a subroutine accepting a

   function pointer is considered undesirable since it's not the way a

   normal application will be calling, and some processors might do

   different things with an indirect call, like not branch predicting, or

   doing a full pipe flush.  At least some of the "functions" measured are

   actually macros too.

   The net effect is to bloat the object code, possibly in a big way, but

   only what's being measured is being run, so that doesn't matter.

   The loop forms don't try to cope with __GMP_ATTRIBUTE_PURE or

   ATTRIBUTE_CONST on the called functions.  Adding a cast to a non-pure

   function pointer doesn't work in gcc 3.2.  Using an actual non-pure

   function pointer variable works, but stands a real risk of a

   non-optimizing compiler generating unnecessary overheads in the call.

   Currently the best idea is not to use those attributes for a timing

   program build.  __GMP_NO_ATTRIBUTE_CONST_PURE will tell gmp.h and

   gmp-impl.h to omit them from routines there.  */

#define SPEED_RESTRICT_COND(cond)   if (!(cond)) return -1.0;

/* For mpn_copy or similar. */

#define SPEED_ROUTINE_MPN_COPY_CALL(call)				\

  {									\

    mp_ptr    wp;							\

    unsigned  i;							\

    double    t;							\

    TMP_DECL;								\

									\

    SPEED_RESTRICT_COND (s->size >= 0);					\

									\

    TMP_MARK;								\

    SPEED_TMP_ALLOC_LIMBS (wp, s->size, s->align_wp);			\

									\

    speed_operand_src (s, s->xp, s->size);				\

    speed_operand_dst (s, wp, s->size);					\

    speed_cache_fill (s);						\

									\

    speed_starttime ();							\

    i = s->reps;							\

    do									\

      call;								\

    while (--i != 0);							\

    t = speed_endtime ();						\

									\

    TMP_FREE;								\

    return t;								\

  }

#define SPEED_ROUTINE_MPN_COPY(function)				\

  SPEED_ROUTINE_MPN_COPY_CALL (function (wp, s->xp, s->size))

#define SPEED_ROUTINE_MPN_TABSELECT(function)				\

  {									\

    mp_ptr    xp, wp;							\

    unsigned  i;							\

    double    t;							\

    TMP_DECL;								\

									\

    SPEED_RESTRICT_COND (s->size >= 0);					\

									\

    if (s->r == 0)							\

      s->r = s->size;	/* default to a quadratic shape */		\

									\

    TMP_MARK;								\

    SPEED_TMP_ALLOC_LIMBS (xp, s->size * s->r, s->align_xp);		\

    SPEED_TMP_ALLOC_LIMBS (wp, s->size, s->align_wp);			\

									\

    speed_operand_src (s, xp, s->size * s->r);				\

    speed_operand_dst (s, wp, s->size);					\

    speed_cache_fill (s);						\

									\

    speed_starttime ();							\

    i = s->reps;							\

    do									\

      function (wp, xp, s->size, s->r, (s->r) / 2);			\

    while (--i != 0);							\

    t = speed_endtime () / s->r;					\

									\

    TMP_FREE;								\

    return t;								\

  }

#define SPEED_ROUTINE_MPN_COPYC(function)				\

  {									\

    mp_ptr    wp;							\

    unsigned  i;							\

    double    t;							\

    TMP_DECL;								\

									\

    SPEED_RESTRICT_COND (s->size >= 0);					\

									\

    TMP_MARK;								\

    SPEED_TMP_ALLOC_LIMBS (wp, s->size, s->align_wp);			\

									\

    speed_operand_src (s, s->xp, s->size);				\

    speed_operand_dst (s, wp, s->size);					\

    speed_cache_fill (s);						\

									\

    speed_starttime ();							\

    i = s->reps;							\

    do									\

      function (wp, s->xp, s->size, 0);					\

    while (--i != 0);							\

    t = speed_endtime ();						\

									\

    TMP_FREE;								\

    return t;								\

  }

/* s->size is still in limbs, and it's limbs which are copied, but

   "function" takes a size in bytes not limbs.  */

#define SPEED_ROUTINE_MPN_COPY_BYTES(function)				\

  {									\

    mp_ptr    wp;							\

    unsigned  i;							\

    double    t;							\

    TMP_DECL;								\

									\

    SPEED_RESTRICT_COND (s->size >= 0);					\

									\

    TMP_MARK;								\

    SPEED_TMP_ALLOC_LIMBS (wp, s->size, s->align_wp);			\

									\

    speed_operand_src (s, s->xp, s->size);				\

    speed_operand_dst (s, wp, s->size);					\

    speed_cache_fill (s);						\

									\

    speed_starttime ();							\

    i = s->reps;							\

    do									\

      function (wp, s->xp, s->size * GMP_LIMB_BYTES);		\

    while (--i != 0);							\

    t = speed_endtime ();						\

									\

    TMP_FREE;								\

    return t;								\

  }

/* For mpn_add_n, mpn_sub_n, or similar. */

#define SPEED_ROUTINE_MPN_BINARY_N_CALL(call)				\

  {									\

    mp_ptr     wp;							\

    mp_ptr     xp, yp;							\

    unsigned   i;							\

    double     t;							\

    TMP_DECL;								\

									\

    SPEED_RESTRICT_COND (s->size >= 1);					\

									\

    TMP_MARK;								\

    SPEED_TMP_ALLOC_LIMBS (wp, s->size, s->align_wp);			\

									\

    xp = s->xp;								\

    yp = s->yp;								\

									\

    if (s->r == 0)	;						\

    else if (s->r == 1) { xp = wp;	    }				\

    else if (s->r == 2) {	   yp = wp; }				\

    else if (s->r == 3) { xp = wp; yp = wp; }				\

    else if (s->r == 4) {     yp = xp;	    }				\

    else		{						\

      TMP_FREE;								\

      return -1.0;							\

    }									\

									\

    /* initialize wp if operand overlap */				\

    if (xp == wp || yp == wp)						\

      MPN_COPY (wp, s->xp, s->size);					\

									\

    speed_operand_src (s, xp, s->size);					\

    speed_operand_src (s, yp, s->size);					\

    speed_operand_dst (s, wp, s->size);					\

    speed_cache_fill (s);						\

									\

    speed_starttime ();							\

    i = s->reps;							\

    do									\

      call;								\

    while (--i != 0);							\

    t = speed_endtime ();						\

									\

    TMP_FREE;								\

    return t;								\

  }

/* For mpn_aors_errK_n, where 1 <= K <= 3. */

#define SPEED_ROUTINE_MPN_BINARY_ERR_N_CALL(call, K)			\

  {									\

    mp_ptr     wp;							\

    mp_ptr     xp, yp;							\

    mp_ptr     zp[K];							\

    mp_limb_t  ep[2*K];							\

    unsigned   i;							\

    double     t;							\

    TMP_DECL;								\

									\

    SPEED_RESTRICT_COND (s->size >= 1);					\

									\

    TMP_MARK;								\

    SPEED_TMP_ALLOC_LIMBS (wp, s->size, s->align_wp);			\

									\

    /* (don't have a mechanism to specify zp alignments) */		\

    for (i = 0; i < K; i++)						\

      SPEED_TMP_ALLOC_LIMBS (zp[i], s->size, 0);			\

									\

    xp = s->xp;								\

    yp = s->yp;								\

									\

    if (s->r == 0)	;						\

    else if (s->r == 1) { xp = wp;	    }				\

    else if (s->r == 2) {	   yp = wp; }				\

    else if (s->r == 3) { xp = wp; yp = wp; }				\

    else if (s->r == 4) {     yp = xp;	    }				\

    else		{						\

      TMP_FREE;								\

      return -1.0;							\

    }									\

									\

    /* initialize wp if operand overlap */				\

    if (xp == wp || yp == wp)						\

      MPN_COPY (wp, s->xp, s->size);					\

									\

    speed_operand_src (s, xp, s->size);					\

    speed_operand_src (s, yp, s->size);					\

    for (i = 0; i < K; i++)						\

      speed_operand_src (s, zp[i], s->size);				\

    speed_operand_dst (s, wp, s->size);					\

    speed_cache_fill (s);						\

									\

    speed_starttime ();							\

    i = s->reps;							\

    do									\

      call;								\

    while (--i != 0);							\

    t = speed_endtime ();						\

									\

    TMP_FREE;								\

    return t;								\

  }

#define SPEED_ROUTINE_MPN_BINARY_ERR1_N(function)			\

  SPEED_ROUTINE_MPN_BINARY_ERR_N_CALL ((*function) (wp, xp, yp, ep, zp[0], s->size, 0), 1)

#define SPEED_ROUTINE_MPN_BINARY_ERR2_N(function)			\

  SPEED_ROUTINE_MPN_BINARY_ERR_N_CALL ((*function) (wp, xp, yp, ep, zp[0], zp[1], s->size, 0), 2)

#define SPEED_ROUTINE_MPN_BINARY_ERR3_N(function)			\

  SPEED_ROUTINE_MPN_BINARY_ERR_N_CALL ((*function) (wp, xp, yp, ep, zp[0], zp[1], zp[2], s->size, 0), 3)

/* For mpn_add_n, mpn_sub_n, or similar. */

#define SPEED_ROUTINE_MPN_ADDSUB_N_CALL(call)				\

  {									\

    mp_ptr     ap, sp;							\

    mp_ptr     xp, yp;							\

    unsigned   i;							\

    double     t;							\

    TMP_DECL;								\

									\

    SPEED_RESTRICT_COND (s->size >= 1);					\

									\

    TMP_MARK;								\

    SPEED_TMP_ALLOC_LIMBS (ap, s->size, s->align_wp);			\

    SPEED_TMP_ALLOC_LIMBS (sp, s->size, s->align_wp);			\

									\

    xp = s->xp;								\

    yp = s->yp;								\

									\

    if ((s->r & 1) != 0) { xp = ap; }					\

    if ((s->r & 2) != 0) { yp = ap; }					\

    if ((s->r & 4) != 0) { xp = sp; }					\

    if ((s->r & 8) != 0) { yp = sp; }					\

    if ((s->r & 3) == 3  ||  (s->r & 12) == 12)				\

      {									\

	TMP_FREE;							\

	return -1.0;							\

      }									\

									\

    /* initialize ap if operand overlap */				\

    if (xp == ap || yp == ap)						\

      MPN_COPY (ap, s->xp, s->size);					\

    /* initialize sp if operand overlap */				\

    if (xp == sp || yp == sp)						\

      MPN_COPY (sp, s->xp, s->size);					\

									\

    speed_operand_src (s, xp, s->size);					\

    speed_operand_src (s, yp, s->size);					\

    speed_operand_dst (s, ap, s->size);					\

    speed_operand_dst (s, sp, s->size);					\

    speed_cache_fill (s);						\

									\

    speed_starttime ();							\