static int if_eval (const char *s, DATASET *dset, void *ptr, int *err)
{
GENERATOR *ifgen = NULL;
double val = NADBL;
int ret = -1;
#if IFDEBUG
fprintf(stderr, "if_eval: s = '%s'\n", s);
#endif
while (*s == ' ') s++;
if (ptr != NULL) {
/* We're being called from a loop, with the implicit
request that the if-condition be "compiled" (if
that's not already done) and subsequently executed
without having to be evaluated from scratch.
*/
ifgen = *(GENERATOR **) ptr;
if (ifgen == NULL) {
/* Generator not compiled yet: do it now. The
flags OPT_P and OPT_S indicate that we're
generating a "private" scalar.
*/
GENERATOR **pgen = (GENERATOR **) ptr;
*pgen = ifgen = genr_compile(s, dset, OPT_P | OPT_S, err);
}
}
if (ifgen != NULL) {
val = evaluate_if_cond(ifgen, dset, err);
} else {
*err = 0;
val = generate_scalar(s, dset, err);
}
#if IFDEBUG
fprintf(stderr, "if_eval: generate returned %d\n", *err);
#endif
if (*err) {
gretl_errmsg_set(_("error evaluating 'if'"));
} else if (na(val)) {
*err = 1;
gretl_errmsg_set(_("indeterminate condition for 'if'"));
} else {
ret = (int) val;
}
#if IFDEBUG
fprintf(stderr, "if_eval: returning %d\n", ret);
#endif
return ret;
}
int main(int argc, char **argv) {
bench_data data;
int i, p;
secp256k1_gej* pubkeys_gej;
size_t scratch_size;
if (argc > 1) {
if(have_flag(argc, argv, "pippenger_wnaf")) {
printf("Using pippenger_wnaf:\n");
data.ecmult_multi = secp256k1_ecmult_pippenger_batch_single;
} else if(have_flag(argc, argv, "strauss_wnaf")) {
printf("Using strauss_wnaf:\n");
data.ecmult_multi = secp256k1_ecmult_strauss_batch_single;
}
} else {
data.ecmult_multi = secp256k1_ecmult_multi_var;
}
/* Allocate stuff */
data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
scratch_size = secp256k1_strauss_scratch_size(POINTS) + STRAUSS_SCRATCH_OBJECTS*16;
data.scratch = secp256k1_scratch_space_create(data.ctx, scratch_size);
data.scalars = malloc(sizeof(secp256k1_scalar) * POINTS);
data.seckeys = malloc(sizeof(secp256k1_scalar) * POINTS);
data.pubkeys = malloc(sizeof(secp256k1_ge) * POINTS);
data.expected_output = malloc(sizeof(secp256k1_gej) * (ITERS + 1));
data.output = malloc(sizeof(secp256k1_gej) * (ITERS + 1));
/* Generate a set of scalars, and private/public keypairs. */
pubkeys_gej = malloc(sizeof(secp256k1_gej) * POINTS);
secp256k1_gej_set_ge(&pubkeys_gej[0], &secp256k1_ge_const_g);
secp256k1_scalar_set_int(&data.seckeys[0], 1);
for (i = 0; i < POINTS; ++i) {
generate_scalar(i, &data.scalars[i]);
if (i) {
secp256k1_gej_double_var(&pubkeys_gej[i], &pubkeys_gej[i - 1], NULL);
secp256k1_scalar_add(&data.seckeys[i], &data.seckeys[i - 1], &data.seckeys[i - 1]);
}
}
secp256k1_ge_set_all_gej_var(data.pubkeys, pubkeys_gej, POINTS);
free(pubkeys_gej);
for (i = 1; i <= 8; ++i) {
run_test(&data, i, 1);
}
for (p = 0; p <= 11; ++p) {
for (i = 9; i <= 16; ++i) {
run_test(&data, i << p, 1);
}
}
secp256k1_context_destroy(data.ctx);
secp256k1_scratch_space_destroy(data.scratch);
free(data.scalars);
free(data.pubkeys);
free(data.seckeys);
free(data.output);
free(data.expected_output);
return(0);
}
