Introduce check_t func.

3 files changed, 38 insertions, 30 deletions

diff --git a/src/invalid/invalid.c b/src/invalid/invalid.c
index cd00b43..f0a1941 100644
--- a/src/invalid/invalid.c
+++ b/src/invalid/invalid.c
@@ -3,6 +3,7 @@
  * Copyright (C) 2017 J08nY
  */
 #include "invalid.h"
+#include <exhaustive/exhaustive.h>
 #include "exhaustive/exhaustive.h"
 #include "gen/curve.h"
 #include "gen/equation.h"
@@ -79,10 +80,11 @@ static size_t invalid_primes(GEN order, pari_ulong **primes) {
 	return nprimes;
 }
 
-static size_t invalid_curves(curve_t *curve, config_t *cfg, pari_ulong *primes,
-                             size_t nprimes, curve_t **curves,
-                             gen_t invalid_gen[], unroll_t unrolls[]) {
+static size_t invalid_curves(const curve_t *curve, const config_t *cfg,
+                             pari_ulong *primes, size_t nprimes,
+                             curve_t **curves, exhaustive_t *setup) {
 	arg_t *invalid_argss[OFFSET_END];
+	setup->argss = invalid_argss;
 
 	// Alloc a curve, and only alloc a new one when this pointer is saved into
 	// **curves
@@ -95,8 +97,7 @@ static size_t invalid_curves(curve_t *curve, config_t *cfg, pari_ulong *primes,
 	while (ncurves < nprimes) {
 		pari_sp btop = avma;
 		// generate a curve with random b
-		exhaustive_gen(invalid, cfg, invalid_gen, NULL, unrolls, OFFSET_B,
-		               OFFSET_GENERATORS);
+		exhaustive_gen(invalid, cfg, setup, OFFSET_B, OFFSET_GENERATORS);
 
 		// does some small prime from our array divide the curve order?
 		// if so how many?
@@ -114,8 +115,8 @@ static size_t invalid_curves(curve_t *curve, config_t *cfg, pari_ulong *primes,
 		}
 
 		if (total > 0) {
-			if (!exhaustive_gen_retry(invalid, cfg, invalid_gen, NULL, unrolls,
-			                          OFFSET_GENERATORS, OFFSET_POINTS, 1)) {
+			if (!exhaustive_gen_retry(invalid, cfg, setup, OFFSET_GENERATORS,
+			                          OFFSET_POINTS, 1)) {
 				curve_unroll(invalid, cfg, avma,
 				             btop);  // necessary to free the ellinit
 				avma = btop;
@@ -143,8 +144,7 @@ static size_t invalid_curves(curve_t *curve, config_t *cfg, pari_ulong *primes,
 
 			// generate prime order points, this is expensive (order needs to be
 			// factorised, so only do it if we want the curve)
-			exhaustive_gen(invalid, cfg, invalid_gen, invalid_argss, unrolls,
-			               OFFSET_POINTS, OFFSET_END);
+			exhaustive_gen(invalid, cfg, setup, OFFSET_POINTS, OFFSET_END);
 
 			size_t count = 0;
 			for (size_t i = nprimes; i-- > 0;) {
@@ -196,10 +196,9 @@ static size_t invalid_curves(curve_t *curve, config_t *cfg, pari_ulong *primes,
 	return ncurves;
 }
 
-static size_t invalid_curves_threaded(curve_t *curve, config_t *cfg,
+static size_t invalid_curves_threaded(const curve_t *curve, const config_t *cfg,
                                       pari_ulong *primes, size_t nprimes,
-                                      curve_t **curves, gen_t invalid_gen[],
-                                      unroll_t unrolls[]) {
+                                      curve_t **curves, exhaustive_t *setup) {
 	pthread_t pthreads[cfg->threads];
 	thread_t threads[cfg->threads];
 	struct pari_thread pari_threads[cfg->threads];
@@ -230,8 +229,7 @@ static size_t invalid_curves_threaded(curve_t *curve, config_t *cfg,
 		threads[i].mutex_state = &state_mutex;
 		threads[i].cond_generated = &generated_cond;
 		threads[i].cfg = cfg;
-		threads[i].gens = invalid_gen;
-		threads[i].unrolls = unrolls;
+		threads[i].setup = setup;
 	}
 
 	pthread_mutex_lock(&state_mutex);
@@ -284,11 +282,15 @@ int invalid_do(config_t *cfg) {
 	unroll_t common_unrolls[OFFSET_END];
 	invalid_original_ginit(original_gens, cfg);
 	exhaustive_uinit(common_unrolls, cfg);
+	exhaustive_t original_setup = {.generators = original_gens,
+	                               .validators = NULL,
+	                               .argss = original_argss,
+	                               .unrolls = common_unrolls};
 
 	debug_log_start("Starting to create curve to invalidate");
 	curve_t *curve = curve_new();
-	if (!exhaustive_gen(curve, cfg, original_gens, original_argss,
-	                    common_unrolls, OFFSET_FIELD, OFFSET_POINTS)) {
+	if (!exhaustive_gen(curve, cfg, &original_setup, OFFSET_FIELD,
+	                    OFFSET_POINTS)) {
 		curve_free(&curve);
 		return EXIT_FAILURE;
 	}
@@ -310,15 +312,19 @@ int invalid_do(config_t *cfg) {
 	// init the invalid curve gen_t
 	gen_t invalid_gens[OFFSET_END];
 	invalid_invalid_ginit(invalid_gens, cfg);
+	exhaustive_t invalid_setup = {.generators = invalid_gens,
+	                              .validators = NULL,
+	                              .argss = NULL,
+	                              .unrolls = common_unrolls};
 
 	debug_log_start("Starting to generate invalid curves");
 	size_t ncurves;
 	if (cfg->threads == 1) {
-		ncurves = invalid_curves(curve, cfg, primes, nprimes, curves,
-		                         invalid_gens, common_unrolls);
+		ncurves =
+		    invalid_curves(curve, cfg, primes, nprimes, curves, &invalid_setup);
 	} else {
 		ncurves = invalid_curves_threaded(curve, cfg, primes, nprimes, curves,
-		                                  invalid_gens, common_unrolls);
+		                                  &invalid_setup);
 	}
 	debug_log_end("Finished generating invalid curves");
 	output_o_end(cfg);
diff --git a/src/invalid/invalid_thread.c b/src/invalid/invalid_thread.c
index b94e456..be2c4aa 100644
--- a/src/invalid/invalid_thread.c
+++ b/src/invalid/invalid_thread.c
@@ -14,6 +14,10 @@ void *invalid_thread(void *arg) {
 	pari_thread_start(thread->pari_thread);
 	random_init();
 	arg_t *invalid_argss[OFFSET_END];
+	exhaustive_t invalid_setup = {.generators = thread->setup->generators,
+	                              .validators = thread->setup->validators,
+	                              .argss = invalid_argss,
+	                              .unrolls = thread->setup->unrolls};
 
 	curve_t *invalid = curve_new();
 	invalid->field = gcopy(thread->original_curve->field);
@@ -21,8 +25,8 @@ void *invalid_thread(void *arg) {
 
 	while (*thread->generated < thread->nprimes) {
 		pari_sp btop = avma;
-		exhaustive_gen(invalid, thread->cfg, thread->gens, NULL,
-		               thread->unrolls, OFFSET_B, OFFSET_GENERATORS);
+		exhaustive_gen(invalid, thread->cfg, thread->setup, OFFSET_B,
+		               OFFSET_GENERATORS);
 		size_t ndivides = 0;
 		for (size_t i = thread->nprimes; i-- > 0;) {
 			if (dvdis(invalid->order, thread->primes[i])) {
@@ -33,8 +37,7 @@ void *invalid_thread(void *arg) {
 
 		debug("ndivides = %lu\n", ndivides);
 		if (ndivides > 0 &&
-		    exhaustive_gen_retry(invalid, thread->cfg, thread->gens,
-		                         invalid_argss, thread->unrolls,
+		    exhaustive_gen_retry(invalid, thread->cfg, &invalid_setup,
 		                         OFFSET_GENERATORS, OFFSET_POINTS, 1)) {
 			pthread_mutex_lock(thread->mutex_state);
 			size_t nfree = 0;
@@ -55,9 +58,8 @@ void *invalid_thread(void *arg) {
 			if (nfree > 0) {
 				arg_t prime_divisors = {primes, nprimes};
 				invalid_argss[OFFSET_POINTS] = &prime_divisors;
-				exhaustive_gen(invalid, thread->cfg, thread->gens,
-				               invalid_argss, thread->unrolls, OFFSET_POINTS,
-				               OFFSET_END);
+				exhaustive_gen(invalid, thread->cfg, &invalid_setup,
+				               OFFSET_POINTS, OFFSET_END);
 
 				pthread_mutex_lock(thread->mutex_state);
 				size_t count = 0;
diff --git a/src/invalid/invalid_thread.h b/src/invalid/invalid_thread.h
index 0f1b4d0..e93bbda 100644
--- a/src/invalid/invalid_thread.h
+++ b/src/invalid/invalid_thread.h
@@ -8,6 +8,7 @@
 #ifndef ECGEN_INVALID_THREAD_H
 #define ECGEN_INVALID_THREAD_H
 
+#include <exhaustive/exhaustive.h>
 #include <pthread.h>
 #include "misc/types.h"
 
@@ -15,7 +16,7 @@ typedef enum { STATE_FREE, STATE_GENERATING, STATE_GENERATED } state_e;
 
 typedef struct {
 	struct pari_thread *pari_thread;
-	curve_t *original_curve;
+	const curve_t *original_curve;
 	size_t nprimes;
 	pari_ulong *primes;
 	state_e *states;
@@ -23,9 +24,8 @@ typedef struct {
 	size_t *generated;
 	pthread_mutex_t *mutex_state;
 	pthread_cond_t *cond_generated;
-	config_t *cfg;
-	gen_t *gens;
-	unroll_t *unrolls;
+	const config_t *cfg;
+	const exhaustive_t *setup;
 } thread_t;
 
 /**