/* Shared speed subroutines.

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

#define __GMP_NO_ATTRIBUTE_CONST_PURE

#include <errno.h>

#include <fcntl.h>

#include <math.h>

#include <stdio.h>

#include <stdlib.h> /* for qsort */

#include <string.h>

#include <unistd.h>

#if 0

#include <sys/ioctl.h>

#endif

#include "gmp.h"

#include "gmp-impl.h"

#include "longlong.h"

#include "tests.h"

#include "speed.h"

int   speed_option_addrs = 0;

int   speed_option_verbose = 0;

int   speed_option_cycles_broken = 0;

/* Provide __clz_tab even if it's not required, for the benefit of new code

   being tested with many.pl. */

#ifndef COUNT_LEADING_ZEROS_NEED_CLZ_TAB

#define COUNT_LEADING_ZEROS_NEED_CLZ_TAB

#include "mp_clz_tab.c"

#undef COUNT_LEADING_ZEROS_NEED_CLZ_TAB

#endif

void

pentium_wbinvd(void)

{

#if 0

  {

    static int  fd = -2;

    if (fd == -2)

      {

	fd = open ("/dev/wbinvd", O_RDWR);

	if (fd == -1)

	  perror ("open /dev/wbinvd");

      }

    if (fd != -1)

      ioctl (fd, 0, 0);

  }

#endif

#if 0

#define WBINVDSIZE  1024*1024*2

  {

    static char  *p = NULL;

    int   i, sum;

    if (p == NULL)

      p = malloc (WBINVDSIZE);

#if 0

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

      p[i] = i & 0xFF;

#endif

    sum = 0;

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

      sum += p[i];

    mpn_cache_fill_dummy (sum);

  }

#endif

}

int

double_cmp_ptr (const double *p, const double *q)

{

  if (*p > *q)  return 1;

  if (*p < *q)  return -1;

  return 0;

}

/* Measure the speed of a given routine.

   The routine is run with enough repetitions to make it take at least

   speed_precision * speed_unittime.  This aims to minimize the effects of a

   limited accuracy time base and the overhead of the measuring itself.

   Measurements are made looking for 4 results within TOLERANCE of each

   other (or 3 for routines taking longer than 2 seconds).  This aims to get

   an accurate reading even if some runs are bloated by interrupts or task

   switches or whatever.

   The given (*fun)() is expected to run its function "s->reps" many times

   and return the total elapsed time measured using speed_starttime() and

   speed_endtime().  If the function doesn't support the given s->size or

   s->r, -1.0 should be returned.  See the various base routines below.  */

double

speed_measure (double (*fun) (struct speed_params *s), struct speed_params *s)

{

#define TOLERANCE    1.01  /* 1% */

  const int max_zeros = 10;

  struct speed_params  s_dummy;

  int     i, j, e;

  double  t[30];

  double  t_unsorted[30];

  double  reps_d;

  int     zeros = 0;

  /* Use dummy parameters if caller doesn't provide any.  Only a few special

     "fun"s will cope with this, speed_noop() is one.  */

  if (s == NULL)

    {

      memset (&s_dummy, '\0', sizeof (s_dummy));

      s = &s_dummy;

    }

  s->reps = 1;

  s->time_divisor = 1.0;

  for (i = 0; i < numberof (t); i++)

    {

      for (;;)

	{

	  s->src_num = 0;

	  s->dst_num = 0;

	  t[i] = (*fun) (s);

	  if (speed_option_verbose >= 3)

	    gmp_printf("size=%ld reps=%u r=%Md attempt=%d  %.9f\n",

		       (long) s->size, s->reps, s->r, i, t[i]);

	  if (t[i] == 0.0)

	    {

	      zeros++;

	      if (zeros > max_zeros)

		{

		  fprintf (stderr, "Fatal error: too many (%d) failed measurements (0.0)\n", zeros);

		  abort ();

		}

	     if (s->reps < 10000)

	       s->reps *= 2;

	      continue;

	    }

	  if (t[i] == -1.0)

	    return -1.0;

	  if (t[i] >= speed_unittime * speed_precision)

	    break;

	  /* go to a value of reps to make t[i] >= precision */

	  reps_d = ceil (1.1 * s->reps

			 * speed_unittime * speed_precision

			 / MAX (t[i], speed_unittime));

	  if (reps_d > 2e9 || reps_d < 1.0)

	    {

	      fprintf (stderr, "Fatal error: new reps bad: %.2f\n", reps_d);

	      fprintf (stderr, "  (old reps %u, unittime %.4g, precision %d, t[i] %.4g)\n",

		       s->reps, speed_unittime, speed_precision, t[i]);

	      abort ();

	    }

	  s->reps = (unsigned) reps_d;

	}

      t[i] /= s->reps;

      t_unsorted[i] = t[i];

      if (speed_precision == 0)

	return t[i];

      /* require 3 values within TOLERANCE when >= 2 secs, 4 when below */

      if (t[0] >= 2.0)

	e = 3;

      else

	e = 4;

      /* Look for e many t[]'s within TOLERANCE of each other to consider a

	 valid measurement.  Return smallest among them.  */

      if (i >= e)

	{

	  qsort (t, i+1, sizeof(t[0]), (qsort_function_t) double_cmp_ptr);

	  for (j = e-1; j < i; j++)

	    if (t[j] <= t[j-e+1] * TOLERANCE)

	      return t[j-e+1] / s->time_divisor;

	}

    }

  fprintf (stderr, "speed_measure() could not get %d results within %.1f%%\n",

	   e, (TOLERANCE-1.0)*100.0);

  fprintf (stderr, "    unsorted         sorted\n");

  fprintf (stderr, "  %.12f    %.12f    is about 0.5%%\n",

	   t_unsorted[0]*(TOLERANCE-1.0), t[0]*(TOLERANCE-1.0));

  for (i = 0; i < numberof (t); i++)

    fprintf (stderr, "  %.09f       %.09f\n", t_unsorted[i], t[i]);

  return -1.0;

}

/* Read all of ptr,size to get it into the CPU memory cache.

   A call to mpn_cache_fill_dummy() is used to make sure the compiler

   doesn't optimize away the whole loop.  Using "volatile mp_limb_t sum"

   would work too, but the function call means we don't rely on every

   compiler actually implementing volatile properly.

   mpn_cache_fill_dummy() is in a separate source file to stop gcc thinking

   it can inline it.  */

void

mpn_cache_fill (mp_srcptr ptr, mp_size_t size)

{

  mp_limb_t  sum = 0;

  mp_size_t  i;

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

    sum += ptr[i];

  mpn_cache_fill_dummy(sum);

}

void

mpn_cache_fill_write (mp_ptr ptr, mp_size_t size)

{

  mpn_cache_fill (ptr, size);

#if 0

  mpn_random (ptr, size);

#endif

#if 0

  mp_size_t  i;

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

    ptr[i] = i;

#endif

}

void

speed_operand_src (struct speed_params *s, mp_ptr ptr, mp_size_t size)

{

  if (s->src_num >= numberof (s->src))

    {

      fprintf (stderr, "speed_operand_src: no room left in s->src[]\n");

      abort ();

    }

  s->src[s->src_num].ptr = ptr;

  s->src[s->src_num].size = size;

  s->src_num++;

}

void

speed_operand_dst (struct speed_params *s, mp_ptr ptr, mp_size_t size)

{

  if (s->dst_num >= numberof (s->dst))

    {

      fprintf (stderr, "speed_operand_dst: no room left in s->dst[]\n");

      abort ();

    }

  s->dst[s->dst_num].ptr = ptr;

  s->dst[s->dst_num].size = size;

  s->dst_num++;

}

void

speed_cache_fill (struct speed_params *s)

{

  static struct speed_params  prev;

  int  i;

  /* FIXME: need a better way to get the format string for a pointer */

  if (speed_option_addrs)

    {

      int  different;

      different = (s->dst_num != prev.dst_num || s->src_num != prev.src_num);

      for (i = 0; i < s->dst_num; i++)

	different |= (s->dst[i].ptr != prev.dst[i].ptr);

      for (i = 0; i < s->src_num; i++)

	different |= (s->src[i].ptr != prev.src[i].ptr);

      if (different)

	{

	  if (s->dst_num != 0)

	    {

	      printf ("dst");

	      for (i = 0; i < s->dst_num; i++)

		printf (" %08lX", (unsigned long) s->dst[i].ptr);

	      printf (" ");

	    }

	  if (s->src_num != 0)

	    {

	      printf ("src");

	      for (i = 0; i < s->src_num; i++)

		printf (" %08lX", (unsigned long) s->src[i].ptr);

	      printf (" ");

	    }

	  printf ("  (cf sp approx %08lX)\n", (unsigned long) &different);

	}

      memcpy (&prev, s, sizeof(prev));

    }

  switch (s->cache) {

  case 0:

    for (i = 0; i < s->dst_num; i++)

      mpn_cache_fill_write (s->dst[i].ptr, s->dst[i].size);

    for (i = 0; i < s->src_num; i++)

      mpn_cache_fill (s->src[i].ptr, s->src[i].size);

    break;

  case 1:

    pentium_wbinvd();

    break;

  }

}

/* Miscellaneous options accepted by tune and speed programs under -o. */

void

speed_option_set (const char *s)

{

  int  n;

  if (strcmp (s, "addrs") == 0)

    {

      speed_option_addrs = 1;

    }

  else if (strcmp (s, "verbose") == 0)

    {

      speed_option_verbose++;

    }

  else if (sscanf (s, "verbose=%d", &n) == 1)

    {

      speed_option_verbose = n;

    }

  else if (strcmp (s, "cycles-broken") == 0)

    {

      speed_option_cycles_broken = 1;

    }

  else

    {

      printf ("Unrecognised -o option: %s\n", s);

      exit (1);

    }

}

/* The following are basic speed running routines for various gmp functions.

   Many are very similar and use speed.h macros.

   Each routine allocates it's own destination space for the result of the

   function, because only it can know what the function needs.

   speed_starttime() and speed_endtime() are put tight around the code to be

   measured.  Any setups are done outside the timed portion.

   Each routine is responsible for its own cache priming.

   speed_cache_fill() is a good way to do this, see examples in speed.h.

   One cache priming possibility, for CPUs with write-allocate cache, and

   functions that don't take too long, is to do one dummy call before timing

   so as to cache everything that gets used.  But speed_measure() runs a

   routine at least twice and will take the smaller time, so this might not

   be necessary.

   Data alignment will be important, for source, destination and temporary

   workspace.  A routine can align its destination and workspace.  Programs

   using the routines will ensure s->xp and s->yp are aligned.  Aligning

   onto a CACHE_LINE_SIZE boundary is suggested.  s->align_wp and

   s->align_wp2 should be respected where it makes sense to do so.

   SPEED_TMP_ALLOC_LIMBS is a good way to do this.

   A loop of the following form can be expected to turn into good assembler

   code on most CPUs, thereby minimizing overhead in the measurement.  It

   can always be assumed s->reps >= 1.

	  i = s->reps

	  do

	    foo();

	  while (--i != 0);

   Additional parameters might be added to "struct speed_params" in the

   future.  Routines should ignore anything they don't use.

   s->size can be used creatively, and s->xp and s->yp can be ignored.  For

   example, speed_mpz_fac_ui() uses s->size as n for the factorial.  s->r is

   just a user-supplied parameter.  speed_mpn_lshift() uses it as a shift,

   speed_mpn_mul_1() uses it as a multiplier.  */

/* MPN_COPY etc can be macros, so the _CALL forms are necessary */

double

speed_MPN_COPY (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_COPY (MPN_COPY);

}

double

speed_MPN_COPY_INCR (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_COPY (MPN_COPY_INCR);

}

double

speed_MPN_COPY_DECR (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_COPY (MPN_COPY_DECR);

}

#if HAVE_NATIVE_mpn_copyi

double

speed_mpn_copyi (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_COPY (mpn_copyi);

}

#endif

#if HAVE_NATIVE_mpn_copyd

double

speed_mpn_copyd (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_COPY (mpn_copyd);

}

#endif

double

speed_memcpy (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_COPY_BYTES (memcpy);

}

double

speed_mpn_com (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_COPY (mpn_com);

}

double

speed_mpn_neg (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_COPY (mpn_neg);

}

double

speed_mpn_sec_tabselect (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_TABSELECT (mpn_sec_tabselect);

}

double

speed_mpn_addmul_1 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_1 (mpn_addmul_1);

}

double

speed_mpn_submul_1 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_1 (mpn_submul_1);

}

#if HAVE_NATIVE_mpn_addmul_2

double

speed_mpn_addmul_2 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_2 (mpn_addmul_2);

}

#endif

#if HAVE_NATIVE_mpn_addmul_3

double

speed_mpn_addmul_3 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_3 (mpn_addmul_3);

}

#endif

#if HAVE_NATIVE_mpn_addmul_4

double

speed_mpn_addmul_4 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_4 (mpn_addmul_4);

}

#endif

#if HAVE_NATIVE_mpn_addmul_5

double

speed_mpn_addmul_5 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_5 (mpn_addmul_5);

}

#endif

#if HAVE_NATIVE_mpn_addmul_6

double

speed_mpn_addmul_6 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_6 (mpn_addmul_6);

}

#endif

#if HAVE_NATIVE_mpn_addmul_7

double

speed_mpn_addmul_7 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_7 (mpn_addmul_7);

}

#endif

#if HAVE_NATIVE_mpn_addmul_8

double

speed_mpn_addmul_8 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_8 (mpn_addmul_8);

}

#endif

double

speed_mpn_mul_1 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_1 (mpn_mul_1);

}

double

speed_mpn_mul_1_inplace (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_1_INPLACE (mpn_mul_1);

}

#if HAVE_NATIVE_mpn_mul_2

double

speed_mpn_mul_2 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_2 (mpn_mul_2);

}

#endif

#if HAVE_NATIVE_mpn_mul_3

double

speed_mpn_mul_3 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_3 (mpn_mul_3);

}

#endif

#if HAVE_NATIVE_mpn_mul_4

double

speed_mpn_mul_4 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_4 (mpn_mul_4);

}

#endif

#if HAVE_NATIVE_mpn_mul_5

double

speed_mpn_mul_5 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_5 (mpn_mul_5);

}

#endif

#if HAVE_NATIVE_mpn_mul_6

double

speed_mpn_mul_6 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_6 (mpn_mul_6);

}

#endif

double

speed_mpn_lshift (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_1 (mpn_lshift);

}

double

speed_mpn_lshiftc (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_1 (mpn_lshiftc);

}

double

speed_mpn_rshift (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_UNARY_1 (mpn_rshift);

}

/* The carry-in variants (if available) are good for measuring because they

   won't skip a division if high

   with the plain _1 forms. */

double

speed_mpn_divrem_1 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIVREM_1 (mpn_divrem_1);

}

double

speed_mpn_divrem_1f (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIVREM_1F (mpn_divrem_1);

}

#if HAVE_NATIVE_mpn_divrem_1c

double

speed_mpn_divrem_1c (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIVREM_1C (mpn_divrem_1c);

}

double

speed_mpn_divrem_1cf (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIVREM_1CF (mpn_divrem_1c);

}

#endif

double

speed_mpn_divrem_1_div (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIVREM_1 (mpn_divrem_1_div);

}

double

speed_mpn_divrem_1f_div (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIVREM_1F (mpn_divrem_1_div);

}

double

speed_mpn_divrem_1_inv (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIVREM_1 (mpn_divrem_1_inv);

}

double

speed_mpn_divrem_1f_inv (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIVREM_1F (mpn_divrem_1_inv);

}

double

speed_mpn_mod_1_div (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MOD_1 (mpn_mod_1_div);

}

double

speed_mpn_mod_1_inv (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MOD_1 (mpn_mod_1_inv);

}

double

speed_mpn_preinv_divrem_1 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_PREINV_DIVREM_1 (mpn_preinv_divrem_1);

}

double

speed_mpn_preinv_divrem_1f (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_PREINV_DIVREM_1F (mpn_preinv_divrem_1);

}

#if GMP_NUMB_BITS % 4 == 0

double

speed_mpn_mod_34lsub1 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MOD_34LSUB1 (mpn_mod_34lsub1);

}

#endif

double

speed_mpn_divrem_2 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIVREM_2 (mpn_divrem_2);

}

double

speed_mpn_divrem_2_div (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIVREM_2 (mpn_divrem_2_div);

}

double

speed_mpn_divrem_2_inv (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIVREM_2 (mpn_divrem_2_inv);

}

double

speed_mpn_div_qr_1n_pi1 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIV_QR_1N_PI1 (mpn_div_qr_1n_pi1);

}

double

speed_mpn_div_qr_1n_pi1_1 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIV_QR_1N_PI1 (mpn_div_qr_1n_pi1_1);

}

double

speed_mpn_div_qr_1n_pi1_2 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIV_QR_1N_PI1 (mpn_div_qr_1n_pi1_2);

}

double

speed_mpn_div_qr_1 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIV_QR_1 (mpn_div_qr_1);

}

double

speed_mpn_div_qr_2n (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIV_QR_2 (mpn_div_qr_2, 1);

}

double

speed_mpn_div_qr_2u (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIV_QR_2 (mpn_div_qr_2, 0);

}

double

speed_mpn_mod_1 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MOD_1 (mpn_mod_1);

}

#if HAVE_NATIVE_mpn_mod_1c

double

speed_mpn_mod_1c (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MOD_1C (mpn_mod_1c);

}

#endif

double

speed_mpn_preinv_mod_1 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_PREINV_MOD_1 (mpn_preinv_mod_1);

}

double

speed_mpn_mod_1_1 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MOD_1_1 (mpn_mod_1_1p,mpn_mod_1_1p_cps);

}

double

speed_mpn_mod_1_1_1 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MOD_1_1 (mpn_mod_1_1p_1,mpn_mod_1_1p_cps_1);

}

double

speed_mpn_mod_1_1_2 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MOD_1_1 (mpn_mod_1_1p_2,mpn_mod_1_1p_cps_2);

}

double

speed_mpn_mod_1_2 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MOD_1_N (mpn_mod_1s_2p,mpn_mod_1s_2p_cps,2);

}

double

speed_mpn_mod_1_3 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MOD_1_N (mpn_mod_1s_3p,mpn_mod_1s_3p_cps,3);

}

double

speed_mpn_mod_1_4 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MOD_1_N (mpn_mod_1s_4p,mpn_mod_1s_4p_cps,4);

}

double

speed_mpn_divexact_1 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_DIVEXACT_1 (mpn_divexact_1);

}

double

speed_mpn_divexact_by3 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_COPY (mpn_divexact_by3);

}

double

speed_mpn_bdiv_dbm1c (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_BDIV_DBM1C (mpn_bdiv_dbm1c);

}

double

speed_mpn_bdiv_q_1 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_BDIV_Q_1 (mpn_bdiv_q_1);

}

double

speed_mpn_pi1_bdiv_q_1 (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_PI1_BDIV_Q_1 (mpn_pi1_bdiv_q_1);

}

#if HAVE_NATIVE_mpn_modexact_1_odd

double

speed_mpn_modexact_1_odd (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MODEXACT_1_ODD (mpn_modexact_1_odd);

}

#endif

double

speed_mpn_modexact_1c_odd (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MODEXACT_1C_ODD (mpn_modexact_1c_odd);

}

double

speed_mpz_mod (struct speed_params *s)

{

  SPEED_ROUTINE_MPZ_MOD (mpz_mod);

}

double

speed_mpn_sbpi1_div_qr (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_PI1_DIV (mpn_sbpi1_div_qr, inv.inv32, 2,0);

}

double

speed_mpn_dcpi1_div_qr (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_PI1_DIV (mpn_dcpi1_div_qr, &inv, 6,3);

}

double

speed_mpn_sbpi1_divappr_q (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_PI1_DIV (mpn_sbpi1_divappr_q, inv.inv32, 2,0);

}

double

speed_mpn_dcpi1_divappr_q (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_PI1_DIV (mpn_dcpi1_divappr_q, &inv, 6,3);

}

double

speed_mpn_mu_div_qr (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MU_DIV_QR (mpn_mu_div_qr, mpn_mu_div_qr_itch);

}

double

speed_mpn_mu_divappr_q (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MU_DIV_Q (mpn_mu_divappr_q, mpn_mu_divappr_q_itch);

}

double

speed_mpn_mu_div_q (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MU_DIV_Q (mpn_mu_div_q, mpn_mu_div_q_itch);

}

double

speed_mpn_mupi_div_qr (struct speed_params *s)

{

  SPEED_ROUTINE_MPN_MUPI_DIV_QR (mpn_preinv_mu_div_qr, mpn_preinv_mu_div_qr_itch);

}

double

speed_mpn_sbpi1_bdiv_qr (struct speed_params *s)

{