9 files changed, 101 insertions, 87 deletions

diff --git a/tools/000_gendata/gendata.c b/tools/000_gendata/gendata.c
index 2798862..eec9f76 100644
--- a/tools/000_gendata/gendata.c
+++ b/tools/000_gendata/gendata.c
@@ -1,16 +1,16 @@
 #include "../tool.h"
 #include "../expected_distributions.h"
 
-char *solver, *options;
+char *solver;
 uint64_t *expected;
 
 static void
 run(void) {
         int64_t size;
+        bool consistent, expected;
         char *buf, filename[1024];
         
-        getfilename(solver, options, filename);
-        size = generatetable(solver, options, &buf);
+        size = generatetable(solver, &buf);
         switch (size) {
         case -1:
                 return;
@@ -18,11 +18,19 @@ run(void) {
                 goto gendata_run_finish;
         default:
                 nissy_datainfo(buf, write_stdout);
-                if (check_distribution(solver, buf)) {
+                consistent = nissy_checkdata(solver, buf) == 0;
+                expected = check_distribution(solver, buf);
+                if (consistent && expected) {
                         printf("\n");
                         printf("Generated %" PRId64 " bytes.\n", size);
+                        sprintf(filename, "tables/%s", solver);
                         writetable(buf, size, filename);
                 }
+                if (!consistent)
+                        printf("Error: table is not consistent with info"
+                            " (nissy_checkdata() failed)\n");
+                if (!expected)
+                        printf("Error: distribution is not as expected\n");
                 break;
         }
 
@@ -33,15 +41,14 @@ gendata_run_finish:
 int main(int argc, char **argv) {
         uint8_t h, k;
 
-        if (argc < 3) {
+        if (argc < 2) {
                 fprintf(stderr, "Error: not enough arguments. "
-                    "A solver and its options must be given.\n");
+                    "A solver must be given.\n");
                 return 1;
         }
 
         solver = argv[1];
-        options = argv[2];
-        parse_h48_options(options, &h, &k, NULL);
+        parse_h48_solver(solver, &h, &k);
         expected = expected_h48[h][k];
 
         nissy_setlogger(log_stderr);
diff --git a/tools/001_derive_h48/derive_h48.c b/tools/001_derive_h48/derive_h48.c
index ba282ff..c5f28c8 100644
--- a/tools/001_derive_h48/derive_h48.c
+++ b/tools/001_derive_h48/derive_h48.c
@@ -11,25 +11,25 @@ edit the base value in the source code and recompile.
 
 #include "../tool.h"
 
-char *opts_large, *opts_small, *filename_large, *filename_small;
+char *solver_large, *solver_small, *filename_large, *filename_small;
 
 void run(void) {
-        derivedata_run(opts_large, opts_small, filename_large, filename_small);
+        derivedata_run(solver_large, solver_small, filename_large, filename_small);
 }
 
 int main(int argc, char **argv) {
         if (argc < 5) {
                 fprintf(stderr,
                     "Error: not enough arguments. Required:\n"
-                    "1. Options for large table\n"
-                    "2. Options for derived table\n"
+                    "1. Solver name for large table\n"
+                    "2. Solver name for derived table\n"
                     "3. Filename containing large table\n"
                     "4. Filename for saving derived table\n");
                 return 1;
         }
 
-        opts_large = argv[1];
-        opts_small = argv[2];
+        solver_large = argv[1];
+        solver_small = argv[2];
         filename_large = argv[3];
         filename_small = argv[4];
 
diff --git a/tools/100_checkdata/checkdata.c b/tools/100_checkdata/checkdata.c
index 502925f..695a4dd 100644
--- a/tools/100_checkdata/checkdata.c
+++ b/tools/100_checkdata/checkdata.c
@@ -1,15 +1,15 @@
 #include "../tool.h"
 #include "../expected_distributions.h"
 
-char *solver, *options, *filename;
+char *solver, *filename;
 
 static void
 run(void) {
-        int64_t size;
+        int64_t size, result;
         char *buf;
         FILE *f;
         
-        size = nissy_datasize(solver, options);
+        size = nissy_datasize(solver);
 
         if (size <= 0) {
                 fprintf(stderr, "Error in datasize\n");
@@ -24,22 +24,23 @@ run(void) {
         buf = malloc(size);
         fread(buf, size, 1, f);
         fclose(f);
-        nissy_checkdata(solver, options, buf);
+        result = nissy_checkdata(solver, buf);
         free(buf);
 
+        printf("checkdata %s\n", result == 0 ? "succeeded" : "failed");
+
         /* TODO: cross-check with expected distributions? */
 }
 
 int main(int argc, char **argv) {
-        if (argc < 4) {
+        if (argc < 3) {
                 fprintf(stderr, "Error: not enough arguments. "
-                    "A solver, its options and a file name must be given.\n");
+                    "A solver and a file name must be given.\n");
                 return 1;
         }
 
         solver = argv[1];
-        options = argv[2];
-        filename = argv[3];
+        filename = argv[2];
         nissy_setlogger(log_stderr);
 
         timerun(run);
diff --git a/tools/200_stats_tables_h48/stats_tables_h48.c b/tools/200_stats_tables_h48/stats_tables_h48.c
index ea5fa5a..a9a2a1e 100644
--- a/tools/200_stats_tables_h48/stats_tables_h48.c
+++ b/tools/200_stats_tables_h48/stats_tables_h48.c
@@ -3,11 +3,10 @@
 #include "../tool.h"
 
 #define MAXMOVES 20
-#define NCUBES_PER_THREAD 10000
 #define LOG_EVERY (NCUBES_PER_THREAD / 10)
 
+int NCUBES_PER_THREAD;
 const char *solver = "h48stats";
-const char *options = "";
 const char *filename = "tables/h48h0k4";
 char *buf;
 
@@ -29,7 +28,7 @@ uint64_t rand64(void) {
 static void *
 run_thread(void *arg)
 {
-        char sols[12], cube[22];
+        char s[12], cube[22];
         int64_t ep, eo, cp, co;
         int i, j;
 
@@ -41,10 +40,9 @@ run_thread(void *arg)
                 cp = rand64();
                 co = rand64();
                 nissy_getcube(ep, eo, cp, co, "fix", cube);
-                nissy_solve(cube, "h48stats", "", "",
-                    0, MAXMOVES, 1, -1, buf, sols);
+                nissy_solve(cube, "h48stats", "", 0, MAXMOVES, 1, -1, buf, s);
                 for (j = 0; j < 12; j++)
-                        a->v[j][(int)sols[j]]++;
+                        a->v[j][(int)s[j]]++;
                 if ((i+1) % LOG_EVERY == 0)
                         fprintf(stderr, "[thread %d] %d cubes solved...\n",
                             a->thread_id, i+1);
@@ -85,11 +83,27 @@ void run(void) {
         }
 }
 
-int main(void) {
+int main(int argc, char **argv) {
         srand(time(NULL));
         nissy_setlogger(log_stderr);
 
-        if (getdata(solver, options, &buf, filename) != 0)
+        if (argc < 2) {
+                fprintf(stderr, "Error: not enough arguments. "
+                    "Number of cubes per thread must be provided.\n");
+                return 1;
+        }
+
+        NCUBES_PER_THREAD = atoi(argv[1]);
+
+        if (NCUBES_PER_THREAD < 1 || NCUBES_PER_THREAD > 1000000) {
+                fprintf(stderr, "Invalid number of cubes: must be > 0 and "
+                    "< 1000000, but %d was given.\n", NCUBES_PER_THREAD);
+                return 1;
+        }
+
+        printf("Using %d cubes per thread (%d total)\n",
+            NCUBES_PER_THREAD, NCUBES_PER_THREAD * THREADS);
+        if (getdata(solver, &buf, filename) != 0)
                 return 1;
 
         timerun(run);
diff --git a/tools/300_solve_small/solve_small.c b/tools/300_solve_small/solve_small.c
index b572cf5..ade949a 100644
--- a/tools/300_solve_small/solve_small.c
+++ b/tools/300_solve_small/solve_small.c
@@ -1,8 +1,6 @@
 #include "../tool.h"
 
-const char *solver = "h48";
-const char *options = "0;4;20";
-const char *filename = "tables/h48h0k4";
+const char *solver = "h48h0k4";
 char *buf;
 
 char *scrambles[] = {
@@ -28,7 +26,7 @@ void run(void) {
                         continue;
                 }
                 n = nissy_solve(
-                    cube, "h48", options, "", 0, 20, 1, -1, buf, sol);
+                    cube, solver, "", 0, 20, 1, -1, buf, sol);
                 if (n == 0) {
                         printf("No solution\n");
                         fprintf(stderr, "No solution found\n");
@@ -39,10 +37,13 @@ void run(void) {
 }
 
 int main(void) {
+        char filename[255];
+
         srand(time(NULL));
         nissy_setlogger(log_stderr);
 
-        if (getdata(solver, options, &buf, filename) != 0)
+        sprintf(filename, "tables/%s", solver);
+        if (getdata(solver, &buf, filename) != 0)
                 return 1;
 
         timerun(run);
diff --git a/tools/expected_distributions.h b/tools/expected_distributions.h
index 202edf9..1b97166 100644
--- a/tools/expected_distributions.h
+++ b/tools/expected_distributions.h
@@ -155,7 +155,7 @@ check_distribution(const char *solver, const void *data)
 {
         tableinfo_t info = {0};
 
-        if (!strcmp(solver, "h48")) {
+        if (!strncmp(solver, "h48", 3)) {
                 readtableinfo(data, &info);
                 if (!distribution_equal(
                     expected_cocsep, info.distribution, info.maxvalue)) {
diff --git a/tools/nissy_extra.h b/tools/nissy_extra.h
index f9baf00..53c3df7 100644
--- a/tools/nissy_extra.h
+++ b/tools/nissy_extra.h
@@ -9,4 +9,4 @@ for testing purposes only.
 #include "../src/solvers/tables.h"
 
 size_t gendata_h48_derive(uint8_t, const void *, void *);
-int parse_h48_options(const char *, uint8_t *, uint8_t *, uint8_t *);
+int parse_h48_solver(const char *, uint8_t [static 1], uint8_t [static 1]);
diff --git a/tools/tool.h b/tools/tool.h
index 2aaabae..02ff0f2 100644
--- a/tools/tool.h
+++ b/tools/tool.h
@@ -12,12 +12,11 @@
 static void log_stderr(const char *, ...);
 static void log_stdout(const char *, ...);
 static double timerun(void (*)(void));
-static void getfilename(const char *, const char *, char *);
 static void writetable(const char *, int64_t, const char *);
-static int64_t generatetable(const char *, const char *, char **);
+static int64_t generatetable(const char *, char **);
 static int64_t derivetable(const char *, const char *, const char *, char **);
-static int getdata(const char *, const char *, char **, const char *);
-static void gendata_run(const char *, const char *, uint64_t[static 21]);
+static int getdata(const char *, char **, const char *);
+static void gendata_run(const char *, uint64_t[static 21]);
 static void derivedata_run(
     const char *, const char *, const char *, const char *);
 
@@ -71,50 +70,39 @@ timerun(void (*run)(void))
 }
 
 static void
-getfilename(const char *solver, const char *options, char *filename)
-{
-        uint8_t h, k;
-
-        /* Only h48 supported for now */
-        parse_h48_options(options, &h, &k, NULL);
-
-        sprintf(filename, "tables/%sh%dk%d", solver, h, k);
-}
-
-static void
 writetable(const char *buf, int64_t size, const char *filename)
 {
         FILE *f;
 
         if ((f = fopen(filename, "wb")) == NULL) {
-                fprintf(stderr, "Could not write tables to file %s"
+                printf("Could not write tables to file %s"
                     ", will be regenerated next time.\n", filename);
         } else {
                 fwrite(buf, size, 1, f);
                 fclose(f);
-                fprintf(stderr, "Table written to %s.\n", filename);
+                printf("Table written to %s.\n", filename);
         }
 }
 
 static int64_t
-generatetable(const char *solver, const char *options, char **buf)
+generatetable(const char *solver, char **buf)
 {
         int64_t size, gensize;
 
-        size = nissy_datasize(solver, options);
+        size = nissy_datasize(solver);
         if (size == -1) {
                 printf("Error getting table size.\n");
                 return -1;
         }
 
         *buf = malloc(size);
-        gensize = nissy_gendata(solver, options, *buf);
+        gensize = nissy_gendata(solver, *buf);
 
         if (gensize != size) {
-                fprintf(stderr, "Error generating table");
+                printf("Error generating table");
                 if (gensize != -1)
-                        fprintf(stderr, " (got %" PRId64 " bytes)", gensize);
-                fprintf(stderr, "\n");
+                        printf(" (got %" PRId64 " bytes)", gensize);
+                printf("\n");
                 return -2;
         }
 
@@ -123,46 +111,53 @@ generatetable(const char *solver, const char *options, char **buf)
 
 static int64_t
 derivetable(
-        const char *opts_large,
-        const char *opts_small,
+        const char *solver_large,
+        const char *solver_small,
         const char *filename_large,
         char **buf
 )
 {
-        uint8_t h;
+        uint8_t h, k;
         int64_t size, gensize;
         char *fulltable;
 
-        if (getdata("h48", opts_large, &fulltable, filename_large) != 0) {
+        if (getdata(solver_large, &fulltable, filename_large) != 0) {
                 printf("Error reading full table.\n");
-                return -1;
+                gensize = -1;
+                goto derivetable_error_nofree;
         }
 
-        size = nissy_datasize("h48", opts_small);
+        size = nissy_datasize(solver_small);
         if (size == -1) {
                 printf("Error getting table size.\n");
-                free(fulltable);
-                return -1;
+                gensize = -2;
+                goto derivetable_error;
+        }
+
+        if (parse_h48_solver(solver_small, &h, &k) != 0) {
+                gensize = -3;
+                goto derivetable_error;
         }
 
-        h = atoi(opts_small); /* TODO: use option parser */
         *buf = malloc(size);
         gensize = gendata_h48_derive(h, fulltable, *buf);
 
         if (gensize != size) {
-                fprintf(stderr, "Error deriving table\n");
-                free(fulltable);
-                return -2;
+                printf("Error deriving table\n");
+                gensize = -4;
+                goto derivetable_error;
         }
 
+derivetable_error:
         free(fulltable);
+
+derivetable_error_nofree:
         return gensize;
 }
 
 static int
 getdata(
         const char *solver,
-        const char *options,
         char **buf,
         const char *filename
 ) {
@@ -170,8 +165,8 @@ getdata(
         FILE *f;
 
         if ((f = fopen(filename, "rb")) == NULL) {
-                fprintf(stderr, "Table file not found, generating it.\n");
-                size = generatetable(solver, options, buf);
+                printf("Table file not found, generating it.\n");
+                size = generatetable(solver, buf);
                 switch (size) {
                 case -1:
                         goto getdata_error_nofree;
@@ -182,13 +177,13 @@ getdata(
                         break;
                 }
         } else {
-                fprintf(stderr, "Reading tables from file %s\n", filename);
-                size = nissy_datasize(solver, options);
+                printf("Reading tables from file %s\n", filename);
+                size = nissy_datasize(solver);
                 *buf = malloc(size);
                 sizeread = fread(*buf, size, 1, f);
                 fclose(f);
                 if (sizeread != 1) {
-                        fprintf(stderr, "Error reading table, stopping\n");
+                        printf("Error reading table, stopping\n");
                         goto getdata_error;
                 }
         }
@@ -204,14 +199,13 @@ getdata_error_nofree:
 static void
 gendata_run(
         const char *solver,
-        const char *options,
         uint64_t expected[static 21]
 ) {
         int64_t size;
         char *buf, filename[1024];
 
-        getfilename(solver, options, filename);
-        size = generatetable(solver, options, &buf);
+        sprintf(filename, "tables/%s", solver);
+        size = generatetable(solver, &buf);
         switch (size) {
         case -1:
                 return;
@@ -234,8 +228,8 @@ gendata_run_finish:
 
 static void
 derivedata_run(
-        const char *opts_large,
-        const char *opts_small,
+        const char *solver_large,
+        const char *solver_small,
         const char *filename_large,
         const char *filename_small
 )
@@ -243,7 +237,7 @@ derivedata_run(
         int64_t size;
         char *buf;
 
-        size = derivetable(opts_large, opts_small, filename_large, &buf);
+        size = derivetable(solver_large, solver_small, filename_large, &buf);
         switch (size) {
         case -1:
                 return;
diff --git a/tools/tool.sh b/tools/tool.sh
index 23d781d..aea203f 100755
--- a/tools/tool.sh
+++ b/tools/tool.sh
@@ -29,15 +29,12 @@ date +'%Y-%m-%d %H:%M'
 echo ""
 echo "======== config.mk ========"
 cat config.mk
-echo "==========================="
 echo ""
 echo "=== tool configuration ===="
 echo "TOOL=$toolname"
 echo "TOOLARGS=$TOOLARGS"
 echo "CC=$CC"
-echo "==========================="
 echo ""
 echo "======= tool output ======="
 $BIN $TOOLARGS 
-echo "==========================="
 ) | tee "$file" "$LAST"