double
profile_mpn_mulmid_fallback (void* arg, unsigned long count)
{
profile_info_struct* info = (profile_info_struct*) arg;
size_t n1 = info->n1;
size_t n2 = info->n2;
ulong* buf1 = (ulong*) malloc (sizeof (mp_limb_t) * n1);
ulong* buf2 = (ulong*) malloc (sizeof (mp_limb_t) * n2);
ulong* buf3 = (ulong*) malloc (sizeof (mp_limb_t) * (n1 - n2 + 3));
// generate random inputs
mpn_random (buf1, n1);
mpn_random (buf2, n2);
// warm up
ulong j;
for (j = 0; j < count; j++)
ZNP_mpn_mulmid_fallback (buf3, buf1, n1, buf2, n2);
// do the actual profile
cycle_count_t t0 = get_cycle_counter ();
for (j = 0; j < count; j++)
ZNP_mpn_mulmid_fallback (buf3, buf1, n1, buf2, n2);
cycle_count_t t1 = get_cycle_counter ();
free (buf3);
free (buf2);
free (buf1);
return cycle_diff (t0, t1);
}
static double domeasure (mpfr_prec_t *threshold,
double (*func) (struct speed_params *),
mpfr_prec_t p)
{
struct speed_params s;
mp_size_t size;
double t;
s.align_xp = s.align_yp = s.align_wp = 64;
s.size = p;
size = (p - 1)/GMP_NUMB_BITS+1;
s.xp = malloc (2*size*sizeof (mp_limb_t));
if (s.xp == NULL)
{
fprintf (stderr, "Can't allocate memory.\n");
abort ();
}
mpn_random (s.xp, size);
s.yp = s.xp + size;
mpn_random (s.yp, size);
t = speed_measure (func, &s);
if (t == -1.0)
{
fprintf (stderr, "Failed to measure function!\n");
abort ();
}
free (s.xp);
return t;
}
double
profile_mpn_smp_kara (void* arg, unsigned long count)
{
profile_info_struct* info = (profile_info_struct*) arg;
size_t n = info->n;
ulong* buf1 = (ulong*) malloc (sizeof (mp_limb_t) * (2 * n - 1));
ulong* buf2 = (ulong*) malloc (sizeof (mp_limb_t) * n);
ulong* buf3 = (ulong*) malloc (sizeof (mp_limb_t) * (n + 2));
// generate random inputs
mpn_random (buf1, 2 * n - 1);
mpn_random (buf2, n);
// warm up
ulong j;
for (j = 0; j < count; j++)
ZNP_mpn_smp_kara (buf3, buf1, buf2, n);
// do the actual profile
cycle_count_t t0 = get_cycle_counter ();
for (j = 0; j < count; j++)
ZNP_mpn_smp_kara (buf3, buf1, buf2, n);
cycle_count_t t1 = get_cycle_counter ();
free (buf3);
free (buf2);
free (buf1);
return cycle_diff (t0, t1);
}
static void
matrix_random(struct matrix *M, mp_size_t n, gmp_randstate_ptr rands)
{
M->n = n;
mpn_random (M->e00, n);
mpn_random (M->e01, n);
mpn_random (M->e10, n);
mpn_random (M->e11, n);
}
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*/
}
}
void
mpfr_random2 (mpfr_ptr x, mp_size_t size, mp_exp_t exp)
{
mp_size_t xn;
unsigned long cnt;
mp_ptr xp = MPFR_MANT(x), yp[1];
mp_size_t prec = (MPFR_PREC(x) - 1)/BITS_PER_MP_LIMB;
MPFR_CLEAR_FLAGS(x);
xn = ABS (size);
if (xn != 0)
{
if (xn > prec + 1)
xn = prec + 1;
mpn_random2 (xp, xn);
}
if (exp != 0) {
/* use mpn_random instead of random since that function is not
available on all platforms (for example HPUX, DEC OSF, ...) */
mpn_random ((mp_limb_t*) yp, 1);
exp = (mp_exp_t) yp[0] % (2 * exp) - exp;
}
count_leading_zeros(cnt, xp[xn - 1]);
if (cnt) mpn_lshift(xp, xp, xn, cnt);
MPFR_EXP(x) = exp-cnt;
cnt = xn*BITS_PER_MP_LIMB - prec;
/* cnt is the number of non significant bits in the low limb */
xp[0] &= ~((MP_LIMB_T_ONE << cnt) - MP_LIMB_T_ONE);
}
mp_limb_t
r_string (const char *s)
{
const char *s_orig = s;
long n;
if (strcmp (s, "aas") == 0)
return GMP_NUMB_0xAA;
{
mpz_t z;
mp_limb_t l;
int set, siz;
mpz_init (z);
set = mpz_set_str (z, s, 0);
siz = SIZ(z);
l = (siz == 0 ? 0 : siz > 0 ? PTR(z)[0] : -PTR(z)[0]);
mpz_clear (z);
if (set == 0)
{
if (siz > 1 || siz < -1)
printf ("Warning, r parameter %s truncated to %d bits\n",
s_orig, BITS_PER_MP_LIMB);
return l;
}
}
if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
n = strtoul (s+2, (char **) &s, 16);
else
n = strtol (s, (char **) &s, 10);
if (strcmp (s, "bits") == 0)
{
mp_limb_t l;
if (n > BITS_PER_MP_LIMB)
{
fprintf (stderr, "%ld bit parameter invalid (max %d bits)\n",
n, BITS_PER_MP_LIMB);
exit (1);
}
mpn_random (&l, 1);
return (l | (CNST_LIMB(1) << (n-1))) & LIMB_ONES(n);
}
else if (strcmp (s, "ones") == 0)
{
if (n > BITS_PER_MP_LIMB)
{
fprintf (stderr, "%ld bit parameter invalid (max %d bits)\n",
n, BITS_PER_MP_LIMB);
exit (1);
}
return LIMB_ONES (n);
}
else if (*s != '\0')
{
fprintf (stderr, "invalid r parameter: %s\n", s_orig);
exit (1);
}
return n;
}
int main(int argc, char *argv[])
{
unsigned char str[154];
unsigned int arr[] = {9,2,5,8,4,2,4,1,6,9,1,8,9,9,6,1,5,7,0,7,7,4,3,7,6,3,9,5,4,2,3,0,4,4,1,5,3,3,7,2,3,3,7,0,9,4,5,2,8,4,6,\
2,1,3,4,1,4,2,6,0,8,5,1,7,3,1,4,4,7,0,5,3,4,4,8,9,1,1,9,8,3,5,1,8,3,4,4,8,3,2,8,1,2,8,7,4,1,8,1,8,0,4,\
8,4,2,4,4,5,4,9,1,8,3,4,9,5,6,3,3,1,4,6,4,1,0,2,0,2,5,1,4,8,5,9,9,6,9,4,0,3,6,5,5,9,5,4,2,2,3,7,8,5,9,7};
long i;
double t1, t2, Itime;
int provided;
/* Allocation */
v1 = (vector *) malloc (VLEN * sizeof (vector));
v2 = (vector *) malloc (VLEN * sizeof (vector));
v3 = (vector *) malloc (VLEN * sizeof (vector));
fin_sum = (mp_limb_t *) malloc ((2*LIMBS+1) * sizeof (mp_limb_t));
result = (mp_limb_t *) malloc ((2*LIMBS+1) * sizeof (mp_limb_t));
q = (mp_limb_t *) malloc (LIMBS * sizeof (mp_limb_t));
MPI_Init_thread (&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
MPI_Comm_rank (MPI_COMM_WORLD, &id);
MPI_Comm_size (MPI_COMM_WORLD, &p);
MPI_Type_contiguous (2*LIMBS+1, MPI_UNSIGNED_LONG_LONG, &mpntype0);
MPI_Type_commit (&mpntype0);
MPI_Type_contiguous (LIMBS, MPI_UNSIGNED_LONG_LONG, &mpntype1);
MPI_Type_commit (&mpntype1);
MPI_Op_create ((MPI_User_function *)addmpn, 1, &mpn_sum);
for (i=0; i<154; ++i) str[i] = (unsigned char)arr[i];
mpn_set_str (q, str, 154, 10);
//if (!id) gmp_printf ("Modulus: %Nd\n", q, LIMBS);
MPI_Barrier (MPI_COMM_WORLD);
/* Setting limits for 2 MPI nodes */
VOffset = BLOCK_LOW(id,p,VLEN);
VChunk = BLOCK_SIZE(id,p,VLEN);
/* Setting limits for NCORES-1 threads */
for (i=0; i<NCORES-1; ++i)
{
VStart[i] = VOffset + BLOCK_LOW(i,NCORES-1,VChunk);
VEnd[i] = VOffset + BLOCK_HIGH(i,NCORES-1,VChunk);
}
for (i=0; i<VLEN; ++i) mpn_random (v1[i], LIMBS);
for (i=0; i<VLEN; ++i) mpn_random (v2[i], LIMBS);
for (i=BLOCK_LOW(id,p,VLEN); i<=BLOCK_HIGH(id,p,VLEN); ++i) mpn_random (v3[i], LIMBS);
MPI_Barrier (MPI_COMM_WORLD);
t1 = MPI_Wtime ();
for (i=0; i<NCORES; ++i)
pthread_create(&threads[i], &attr, VectMul, (void *) i);
for (i=0; i<NCORES; ++i)
pthread_join (threads[i], NULL);
t2 = MPI_Wtime ();
Itime = t2 - t1;
if (!id) printf ("Total time taken: %lf\n",Itime);
if (!id) gmp_printf ("Result: %Nd\n", cnum, LIMBS);
MPI_Op_free(&mpn_sum);
MPI_Request_free (&Rrqst);
MPI_Request_free (&Srqst);
MPI_Finalize ();
return 0;
}
void mpfq_p_127_735_random(mpfq_p_127_735_src_field k, mpfq_p_127_735_dst_elt r) {
mpn_random(r, 2);
mpfq_p_127_735_normalize(k, r);
}
int
main (int argc, char **argv)
{
gmp_randstate_ptr rands;
mp_ptr ap, rp, pp, scratch;
int count = COUNT;
unsigned i;
TMP_DECL;
TMP_MARK;
if (argc > 1)
{
char *end;
count = strtol (argv[1], &end, 0);
if (*end || count <= 0)
{
fprintf (stderr, "Invalid test count: %s.\n", argv[1]);
return 1;
}
}
tests_start ();
rands = RANDS;
ap = TMP_ALLOC_LIMBS (MAX_LIMBS);
rp = TMP_ALLOC_LIMBS (MAX_LIMBS);
pp = TMP_ALLOC_LIMBS (MAX_LIMBS);
scratch = TMP_ALLOC_LIMBS (3*MAX_LIMBS); /* For mpn_powlo */
for (i = 0; i < count; i++)
{
mp_size_t n;
mp_limb_t k;
int c;
n = 1 + gmp_urandomm_ui (rands, MAX_LIMBS);
if (i & 1)
mpn_random2 (ap, n);
else
mpn_random (ap, n);
ap[0] |= 1;
if (i < 100)
k = 3 + 2*i;
else
{
mpn_random (&k, 1);
if (k < 3)
k = 3;
else
k |= 1;
}
mpn_broot (rp, ap, n, k);
mpn_powlo (pp, rp, &k, 1, n, scratch);
MPN_CMP (c, ap, pp, n);
if (c != 0)
{
gmp_fprintf (stderr,
"mpn_broot returned bad result: %u limbs\n",
(unsigned) n);
gmp_fprintf (stderr, "k = %Mx\n", k);
gmp_fprintf (stderr, "a = %Nx\n", ap, n);
gmp_fprintf (stderr, "r = %Nx\n", rp, n);
gmp_fprintf (stderr, "r^n = %Nx\n", pp, n);
abort ();
}
}
TMP_FREE;
tests_end ();
return 0;
}
static mp_size_t
one_test (mpz_t a, mpz_t b, int i)
{
struct hgcd_matrix hgcd;
struct hgcd_ref ref;
mpz_t ref_r0;
mpz_t ref_r1;
mpz_t hgcd_r0;
mpz_t hgcd_r1;
int res[2];
mp_size_t asize;
mp_size_t bsize;
mp_size_t hgcd_init_scratch;
mp_size_t hgcd_scratch;
mp_ptr hgcd_init_tp;
mp_ptr hgcd_tp;
mp_limb_t marker[4];
asize = a->_mp_size;
bsize = b->_mp_size;
ASSERT (asize >= bsize);
hgcd_init_scratch = MPN_HGCD_MATRIX_INIT_ITCH (asize);
hgcd_init_tp = refmpn_malloc_limbs (hgcd_init_scratch + 2) + 1;
mpn_hgcd_matrix_init (&hgcd, asize, hgcd_init_tp);
hgcd_scratch = mpn_hgcd_appr_itch (asize);
hgcd_tp = refmpn_malloc_limbs (hgcd_scratch + 2) + 1;
mpn_random (marker, 4);
hgcd_init_tp[-1] = marker[0];
hgcd_init_tp[hgcd_init_scratch] = marker[1];
hgcd_tp[-1] = marker[2];
hgcd_tp[hgcd_scratch] = marker[3];
#if 0
fprintf (stderr,
"one_test: i = %d asize = %d, bsize = %d\n",
i, a->_mp_size, b->_mp_size);
gmp_fprintf (stderr,
"one_test: i = %d\n"
" a = %Zx\n"
" b = %Zx\n",
i, a, b);
#endif
hgcd_ref_init (&ref);
mpz_init_set (ref_r0, a);
mpz_init_set (ref_r1, b);
res[0] = hgcd_ref (&ref, ref_r0, ref_r1);
mpz_init_set (hgcd_r0, a);
mpz_init_set (hgcd_r1, b);
if (bsize < asize)
{
_mpz_realloc (hgcd_r1, asize);
MPN_ZERO (hgcd_r1->_mp_d + bsize, asize - bsize);
}
res[1] = mpn_hgcd_appr (hgcd_r0->_mp_d,
hgcd_r1->_mp_d,
asize,
&hgcd, hgcd_tp);
if (hgcd_init_tp[-1] != marker[0]
|| hgcd_init_tp[hgcd_init_scratch] != marker[1]
|| hgcd_tp[-1] != marker[2]
|| hgcd_tp[hgcd_scratch] != marker[3])
{
fprintf (stderr, "ERROR in test %d\n", i);
fprintf (stderr, "scratch space overwritten!\n");
if (hgcd_init_tp[-1] != marker[0])
gmp_fprintf (stderr,
"before init_tp: %Mx\n"
"expected: %Mx\n",
hgcd_init_tp[-1], marker[0]);
if (hgcd_init_tp[hgcd_init_scratch] != marker[1])
gmp_fprintf (stderr,
"after init_tp: %Mx\n"
"expected: %Mx\n",
hgcd_init_tp[hgcd_init_scratch], marker[1]);
if (hgcd_tp[-1] != marker[2])
gmp_fprintf (stderr,
"before tp: %Mx\n"
"expected: %Mx\n",
hgcd_tp[-1], marker[2]);
if (hgcd_tp[hgcd_scratch] != marker[3])
gmp_fprintf (stderr,
"after tp: %Mx\n"
"expected: %Mx\n",
hgcd_tp[hgcd_scratch], marker[3]);
abort ();
}
if (!hgcd_appr_valid_p (a, b, res[0], &ref, ref_r0, ref_r1,
res[1], &hgcd))
{
fprintf (stderr, "ERROR in test %d\n", i);
fprintf (stderr, "Invalid results for hgcd and hgcd_ref\n");
fprintf (stderr, "op1="); debug_mp (a, -16);
fprintf (stderr, "op2="); debug_mp (b, -16);
fprintf (stderr, "hgcd_ref: %ld\n", (long) res[0]);
fprintf (stderr, "mpn_hgcd_appr: %ld\n", (long) res[1]);
abort ();
}
refmpn_free_limbs (hgcd_init_tp - 1);
refmpn_free_limbs (hgcd_tp - 1);
hgcd_ref_clear (&ref);
mpz_clear (ref_r0);
mpz_clear (ref_r1);
mpz_clear (hgcd_r0);
mpz_clear (hgcd_r1);
return res[0];
}
static void
bench_curve (const struct ecc_curve *ecc)
{
struct ecc_ctx ctx;
double modp, reduce, modq, modinv, modinv_gcd, modinv_powm,
dup_jj, add_jja, add_hhh,
mul_g, mul_a;
mp_limb_t mask;
mp_size_t itch;
ctx.ecc = ecc;
ctx.rp = xalloc_limbs (3*ecc->p.size);
ctx.ap = xalloc_limbs (3*ecc->p.size);
ctx.bp = xalloc_limbs (3*ecc->p.size);
itch = ecc->mul_itch;
#ifdef mpn_sec_powm
{
mp_size_t powm_itch
= mpn_sec_powm_itch (ecc->p.size, ecc->p.bit_size, ecc->p.size);
if (powm_itch > itch)
itch = powm_itch;
}
#endif
ctx.tp = xalloc_limbs (itch);
mpn_random (ctx.ap, 3*ecc->p.size);
mpn_random (ctx.bp, 3*ecc->p.size);
mask = (~(mp_limb_t) 0) >> (ecc->p.size * GMP_NUMB_BITS - ecc->p.bit_size);
ctx.ap[ecc->p.size - 1] &= mask;
ctx.ap[2*ecc->p.size - 1] &= mask;
ctx.ap[3*ecc->p.size - 1] &= mask;
ctx.bp[ecc->p.size - 1] &= mask;
ctx.bp[2*ecc->p.size - 1] &= mask;
ctx.bp[3*ecc->p.size - 1] &= mask;
modp = time_function (bench_modp, &ctx);
reduce = time_function (bench_reduce, &ctx);
modq = time_function (bench_modq, &ctx);
modinv = time_function (bench_modinv, &ctx);
#if !NETTLE_USE_MINI_GMP
modinv_gcd = time_function (bench_modinv_gcd, &ctx);
#else
modinv_gcd = 0;
#endif
#ifdef mpn_sec_powm
modinv_powm = time_function (bench_modinv_powm, &ctx);
#else
modinv_powm = 0;
#endif
if (ecc->p.bit_size == 255)
{
/* For now, curve25519 is a special case */
dup_jj = time_function (bench_dup_eh, &ctx);
add_jja = time_function (bench_add_eh, &ctx);
}
else
{
dup_jj = time_function (bench_dup_jj, &ctx);
add_jja = time_function (bench_add_jja, &ctx);
}
add_hhh = time_function (bench_add_hhh, &ctx);
mul_g = time_function (bench_mul_g, &ctx);
mul_a = time_function (bench_mul_a, &ctx);
free (ctx.rp);
free (ctx.ap);
free (ctx.bp);
free (ctx.tp);
printf ("%4d %6.4f %6.4f %6.4f %6.2f %6.3f %6.2f %6.3f %6.3f %6.3f %6.1f %6.1f\n",
ecc->p.bit_size, 1e6 * modp, 1e6 * reduce, 1e6 * modq,
1e6 * modinv, 1e6 * modinv_gcd, 1e6 * modinv_powm,
1e6 * dup_jj, 1e6 * add_jja, 1e6 * add_hhh,
1e6 * mul_g, 1e6 * mul_a);
}
int main(void)
{
mp_limb_t r1, r2, dinv1, dinv2, a1[80], a2[80], b[40], q1[80], q2[80];
mp_size_t limbs = 10;
long i, j;
for (i = 0; i < 1000; i++)
{
mpn_random(a1, 2*limbs);
mpn_random(b, limbs);
mpn_copyi(a2, a1, 2*limbs);
b[limbs - 1] |= GMP_NUMB_HIGHBIT; /* normalise b */
#if (TIME == MPIR) || TEST
invert_1(dinv1, b[limbs - 1], b[limbs - 2]);
#endif
#if (TIME == THIS) || TEST
dinv2 = div_preinv1(b[limbs - 1], b[limbs - 2]);
#endif
#if TEST
r1 = mpn_sb_div_qr(q1, a1, 2*limbs, b, limbs, dinv1);
r2 = div_basecase(q2, a2, 2*limbs, b, limbs, dinv2);
#endif
#if TIME
for (j = 0; j < 1000; j++)
{
#if TIME == MPIR
r1 = mpn_sb_div_qr(q1, a1, 2*limbs, b, limbs, dinv1);
mpn_copyi(a1, a2, 2*limbs);
#endif
#if TIME == THIS
r2 = div_basecase(q2, a2, 2*limbs, b, limbs, dinv2);
mpn_copyi(a2, a1, 2*limbs);
#endif
}
#endif
#if TEST
if (r1 != r2)
{
printf("Error in most significant limb\n", j);
printf("%lu vs %lu\n", r1, r2);
abort();
}
for (j = 0; j < limbs; j++)
{
if (q1[limbs - j - 1] != q2[limbs - j - 1])
{
printf("Error in limb %ld of quotient\n", limbs - j - 1);
printf("%lu vs %lu\n", q1[limbs - j - 1], q2[limbs - j - 1]);
abort();
}
}
for (j = 0; j < limbs; j++)
{
if (a1[limbs - j - 1] != a2[limbs - j - 1])
{
printf("Error in limb %ld of remainder\n", limbs - j - 1);
printf("%lu vs %lu\n", a1[limbs - j - 1], a2[limbs - j - 1]);
abort();
}
}
#endif
}
printf("PASS\n");
return 0;
}
