Tuning for radix conversion enabled

Author: czurnieden

etc/tune.c

@@ -148,6 +148,159 @@ static uint64_t s_time_sqr(int size)
    return t1;
 }
 
+/* Set cutoff for radix conversion (base 10 only for now but should be good enough) */
+#include <stdlib.h>
+static mp_err random_number(char **string, size_t length)
+{
+   char alphabet[] = "0123456789", *str_cpy;
+
+   *string = malloc(length + 1);
+   if (*string == NULL) {
+      return MP_MEM;
+   }
+   str_cpy = *string;
+   /* No leading zeros */
+   do {
+      *str_cpy = alphabet[rand() % 10];
+   } while (*str_cpy == '0');
+   length--;
+   str_cpy++;
+
+   do {
+      *str_cpy = alphabet[rand() % 10];
+      str_cpy++;
+   } while (--length > 0);
+
+   *str_cpy = '\0';
+
+   return MP_OKAY;
+}
+
+#include <string.h>
+static uint64_t s_time_radix_conversion_read(int size)
+{
+   int x;
+   size_t length;
+   size_t written;
+   mp_err  err;
+   mp_int  a;
+   char *str_a, *str_b;
+   uint64_t t1;
+
+   /* "size" is given as "number of limbs" and starts at 8 */
+   length = ((size_t)size - 7u) * MP_DIGIT_BIT;
+
+   /* Over-estimate number of base 10 digits */
+   /* TODO: can overflow with small INT_MAX */
+   length = (length * 28u) / 93u + 2u;
+
+   if ((err = random_number(&str_a, length)) != MP_OKAY) {
+      t1 = UINT64_MAX;
+      goto LBL_ERR_1;
+   }
+
+   if ((err = mp_init(&a)) != MP_OKAY) {
+      t1 = UINT64_MAX;
+      goto LBL_ERR_2;
+   }
+   s_timer_start();
+   for (x = 0; x < s_number_of_test_loops; x++) {
+      if ((err = mp_read_radix(&a, str_a, 10)) != MP_OKAY) {
+         t1 = UINT64_MAX;
+         goto LBL_ERR_3;
+      }
+   }
+   t1 = s_timer_stop();
+
+   if ((err = mp_radix_size(&a, 10, &length)) != MP_OKAY) {
+      t1 = UINT64_MAX;
+      goto LBL_ERR_3;
+   }
+
+   str_b = malloc(length + 1);
+   if (str_b == NULL) {
+      t1 = UINT64_MAX;
+      goto LBL_ERR_3;
+   }
+   if ((err = mp_to_radix(&a, str_b, length, &written, 10)) != MP_OKAY) {
+      t1 = UINT64_MAX;
+      goto LBL_ERR;
+   }
+
+   if (strcmp(str_a, str_b) != 0) {
+      t1 = 0u;
+      goto LBL_ERR;
+   }
+
+LBL_ERR:
+   free(str_b);
+LBL_ERR_3:
+   mp_clear(&a);
+LBL_ERR_2:
+   free(str_a);
+LBL_ERR_1:
+   return t1;
+}
+
+static uint64_t s_time_radix_conversion_write(int size)
+{
+   int x;
+   size_t written, length;
+   mp_err  err;
+   mp_int  a, b;
+   char *str_a;
+   uint64_t t1;
+
+
+   if ((err = mp_init_multi(&a, &b, NULL)) != MP_OKAY) {
+      t1 = UINT64_MAX;
+      goto LBL_ERR_1;
+   }
+   if ((err = mp_rand(&a, size)) != MP_OKAY) {
+      t1 = UINT64_MAX;
+      goto LBL_ERR_2;
+   }
+
+   if ((err = mp_radix_size(&a, 10, &length)) != MP_OKAY) {
+      t1 = UINT64_MAX;
+      goto LBL_ERR_2;
+   }
+
+   str_a = malloc(length + 1);
+   if (str_a == NULL) {
+      t1 = UINT64_MAX;
+      goto LBL_ERR_2;
+   }
+
+   s_timer_start();
+   for (x = 0; x < s_number_of_test_loops; x++) {
+      if ((err =  mp_to_radix(&a, str_a, length, &written, 10)) != MP_OKAY) {
+         t1 = UINT64_MAX;
+         goto LBL_ERR_2;
+      }
+   }
+   t1 = s_timer_stop();
+
+   if ((err = mp_read_radix(&b, str_a, 10)) != MP_OKAY) {
+      t1 = UINT64_MAX;
+      goto LBL_ERR;
+   }
+
+   if (mp_cmp(&a, &b) != MP_EQ) {
+      t1 = 0u;
+      goto LBL_ERR;
+   }
+
+
+LBL_ERR:
+   free(str_a);
+LBL_ERR_2:
+   mp_clear_multi(&a, &b, NULL);
+LBL_ERR_1:
+   return t1;
+}
+
+
 struct tune_args {
    int testmode;
    int verbose;
@@ -238,11 +391,13 @@ static void s_usage(char *s)
    fprintf(stderr,"             (Not for computing the cut-offs!)\n");
    fprintf(stderr,"          -s 'preset' use values in 'preset' for printing.\n");
    fprintf(stderr,"             'preset' is a comma separated string with cut-offs for\n");
-   fprintf(stderr,"             ksm, kss, tc3m, tc3s in that order\n");
+   fprintf(stderr,"             ksm, kss, tc3m, tc3s, rcr, rcw in that order\n");
    fprintf(stderr,"             ksm  = karatsuba multiplication\n");
    fprintf(stderr,"             kss  = karatsuba squaring\n");
    fprintf(stderr,"             tc3m = Toom-Cook 3-way multiplication\n");
    fprintf(stderr,"             tc3s = Toom-Cook 3-way squaring\n");
+   fprintf(stderr,"             rcr = Fast radix conversion, reading\n");
+   fprintf(stderr,"             rcw = Fast radix conversion, writing\n");
    fprintf(stderr,"             Implies '-p'\n");
    fprintf(stderr,"          -h this message\n");
    exit(s_exit_code);
@@ -251,17 +406,20 @@ static void s_usage(char *s)
 struct cutoffs {
    int MUL_KARATSUBA, SQR_KARATSUBA;
    int MUL_TOOM, SQR_TOOM;
+   int RADIX_READ, RADIX_WRITE;
 };
 
 const struct cutoffs max_cutoffs =
-{ INT_MAX, INT_MAX, INT_MAX, INT_MAX };
+{ INT_MAX, INT_MAX, INT_MAX, INT_MAX,INT_MAX, INT_MAX };
 
 static void set_cutoffs(const struct cutoffs *c)
 {
    MP_MUL_KARATSUBA_CUTOFF = c->MUL_KARATSUBA;
    MP_SQR_KARATSUBA_CUTOFF = c->SQR_KARATSUBA;
    MP_MUL_TOOM_CUTOFF = c->MUL_TOOM;
    MP_SQR_TOOM_CUTOFF = c->SQR_TOOM;
+   MP_RADIX_READ_CUTOFF = c->RADIX_READ;
+   MP_RADIX_WRITE_CUTOFF = c->RADIX_WRITE;
 }
 
 static void get_cutoffs(struct cutoffs *c)
@@ -270,7 +428,8 @@ static void get_cutoffs(struct cutoffs *c)
    c->SQR_KARATSUBA  = MP_SQR_KARATSUBA_CUTOFF;
    c->MUL_TOOM = MP_MUL_TOOM_CUTOFF;
    c->SQR_TOOM = MP_SQR_TOOM_CUTOFF;
-
+   c->RADIX_READ = MP_RADIX_READ_CUTOFF;
+   c->RADIX_WRITE = MP_RADIX_WRITE_CUTOFF;
 }
 
 int main(int argc, char **argv)
@@ -416,13 +575,17 @@ int main(int argc, char **argv)
                s_usage(argv[0]);
             }
             str = argv[opt];
-            MP_MUL_KARATSUBA_CUTOFF = (int)s_strtol(str, &endptr, "[1/4] No value for MP_MUL_KARATSUBA_CUTOFF given");
+            MP_MUL_KARATSUBA_CUTOFF = (int)s_strtol(str, &endptr, "[1/6] No value for MP_MUL_KARATSUBA_CUTOFF given");
+            str = endptr + 1;
+            MP_SQR_KARATSUBA_CUTOFF = (int)s_strtol(str, &endptr, "[2/6] No value for MP_SQR_KARATSUBA_CUTOFF given");
             str = endptr + 1;
-            MP_SQR_KARATSUBA_CUTOFF = (int)s_strtol(str, &endptr, "[2/4] No value for MP_SQR_KARATSUBA_CUTOFF given");
+            MP_MUL_TOOM_CUTOFF = (int)s_strtol(str, &endptr, "[3/6] No value for MP_MUL_TOOM_CUTOFF given");
             str = endptr + 1;
-            MP_MUL_TOOM_CUTOFF = (int)s_strtol(str, &endptr, "[3/4] No value for MP_MUL_TOOM_CUTOFF given");
+            MP_SQR_TOOM_CUTOFF = (int)s_strtol(str, &endptr, "[4/6] No value for MP_SQR_TOOM_CUTOFF given");
             str = endptr + 1;
-            MP_SQR_TOOM_CUTOFF = (int)s_strtol(str, &endptr, "[4/4] No value for MP_SQR_TOOM_CUTOFF given");
+            MP_RADIX_READ_CUTOFF = (int)s_strtol(str, &endptr, "[5/6] No value for MP_RADIX_READ_CUTOFF given");
+            str = endptr + 1;
+            MP_RADIX_WRITE_CUTOFF = (int)s_strtol(str, &endptr, "[6/6] No value for MP_RADIX_WRITE_CUTOFF given");
             break;
          case 'h':
             s_exit_code = EXIT_SUCCESS;
@@ -461,31 +624,54 @@ int main(int argc, char **argv)
          T_MUL_SQR("Karatsuba squaring", SQR_KARATSUBA, s_time_sqr),
          T_MUL_SQR("Toom-Cook 3-way multiplying", MUL_TOOM, s_time_mul),
          T_MUL_SQR("Toom-Cook 3-way squaring", SQR_TOOM, s_time_sqr),
+         /* TODO: adapt macro above (or the names of the cutoffs and/or functions) */
+         {
+            "\"Faster radix conversion (reading)\"", &MP_RADIX_READ_CUTOFF,
+            &(updated.RADIX_READ),MP_HAS(S_MP_FASTER_READ_RADIX) ? s_time_radix_conversion_read : NULL
+         },
+         {
+            "\"Faster radix conversion (writing)\"", &MP_RADIX_WRITE_CUTOFF,
+            &(updated.RADIX_WRITE),MP_HAS(S_MP_FASTER_TO_RADIX) ? s_time_radix_conversion_write : NULL
+         }
 #undef T_MUL_SQR
       };
       /* Turn all limits from bncore.c to the max */
       set_cutoffs(&max_cutoffs);
-      for (n = 0; n < sizeof(test)/sizeof(test[0]); ++n) {
+      for (n = 0; n < (sizeof(test)/sizeof(test[0]) - 2); ++n) {
          if (test[n].fn != NULL) {
             s_run(test[n].name, test[n].fn, test[n].cutoff);
             *test[n].update = *test[n].cutoff;
             *test[n].cutoff = INT_MAX;
+         };
+      }
+      /* Cutoffs for radix conversions are in bits to make handling of 62 different radices
+         more feasible.  */
+      for (; n < sizeof(test)/sizeof(test[0]); ++n) {
+         if (test[n].fn != NULL) {
+            s_run(test[n].name, test[n].fn, test[n].cutoff);
+            /* TODO: can overflow for small INT_MAX */
+            *test[n].update = ((*test[n].cutoff) * MP_DIGIT_BIT * 93)/28;
+            *test[n].cutoff = INT_MAX;
          }
       }
    }
    if (args.terse == 1) {
-      printf("%d %d %d %d\n",
+      printf("%d %d %d %d %d %d\n",
              updated.MUL_KARATSUBA,
              updated.SQR_KARATSUBA,
              updated.MUL_TOOM,
-             updated.SQR_TOOM);
+             updated.SQR_TOOM,
+             updated.RADIX_READ,
+             updated.RADIX_WRITE);
    } else {
       printf("MUL_KARATSUBA_CUTOFF = %d\n", updated.MUL_KARATSUBA);
       printf("SQR_KARATSUBA_CUTOFF = %d\n", updated.SQR_KARATSUBA);
       printf("MUL_TOOM_CUTOFF = %d\n", updated.MUL_TOOM);
       printf("SQR_TOOM_CUTOFF = %d\n", updated.SQR_TOOM);
+      printf("RADIX_READ_CUTOFF = %d\n", updated.RADIX_READ);
+      printf("RADIX_WRITE_CUTOFF = %d\n", updated.RADIX_WRITE);
    }
-
+   /* TODO: add graphs for radix conversion, too? */
    if (args.print == 1) {
       printf("Printing data for graphing to \"%s\" and \"%s\"\n",mullog, sqrlog);
 

etc/tune_it.sh

@@ -56,7 +56,7 @@ KEEP_TEMP=1
 echo "You might like to watch the numbers go up to $LIMIT but it will take a long time!"
 
 # Might not have sufficient rights or disc full.
-echo "km ks tc3m tc3s" > $FILE_NAME || die "Writing header to $FILE_NAME" $?
+echo "km ks tc3m tc3s rcr rcw" > $FILE_NAME || die "Writing header to $FILE_NAME" $?
 i=1
 while [ $i -le $LIMIT ]; do
    RNUM=$(LCG)
@@ -104,3 +104,23 @@ echo "#define MP_DEFAULT_MUL_TOOM_CUTOFF      $TMP" >> $TOMMATH_CUTOFFS_H || die
 TMP=$(median $FILE_NAME 4 $i)
 echo "#define MP_DEFAULT_SQR_TOOM_CUTOFF      $TMP"
 echo "#define MP_DEFAULT_SQR_TOOM_CUTOFF      $TMP" >> $TOMMATH_CUTOFFS_H || die "(tc3s) Appending to $TOMMATH_CUTOFFS_H" $?
+
+TMP=$(median $FILE_NAME 5 $i)
+echo "#define MP_DEFAULT_RADIX_READ_CUTOFF      $TMP"
+echo "#define MP_DEFAULT_RADIX_READ_CUTOFF      $TMP" >> $TOMMATH_CUTOFFS_H || die "(rcr) Appending to $TOMMATH_CUTOFFS_H" $?
+TMP=$(median $FILE_NAME 6 $i)
+echo "#define MP_DEFAULT_RADIX_WRITE_CUTOFF      $TMP"
+echo "#define MP_DEFAULT_RADIX_WRITE_CUTOFF      $TMP" >> $TOMMATH_CUTOFFS_H || die "(rcw) Appending to $TOMMATH_CUTOFFS_H" $?
+
+
+
+
+
+
+
+
+
+
+
+
+

helper.pl

@@ -476,7 +476,8 @@ sub generate_def {
     MP_SQR_KARATSUBA_CUTOFF
     MP_MUL_TOOM_CUTOFF
     MP_SQR_TOOM_CUTOFF
-    MP_RADIX_CUTOFF
+    MP_RADIX_READ_CUTOFF,
+    MP_RADIX_WRITE_CUTOFF
 ";
     return 0;
 }

mp_cutoffs.c

@@ -9,7 +9,8 @@ int MP_MUL_KARATSUBA_CUTOFF = MP_DEFAULT_MUL_KARATSUBA_CUTOFF,
     MP_SQR_KARATSUBA_CUTOFF = MP_DEFAULT_SQR_KARATSUBA_CUTOFF,
     MP_MUL_TOOM_CUTOFF = MP_DEFAULT_MUL_TOOM_CUTOFF,
     MP_SQR_TOOM_CUTOFF = MP_DEFAULT_SQR_TOOM_CUTOFF,
-    MP_RADIX_CUTOFF = MP_DEFAULT_RADIX_CUTOFF;
+    MP_RADIX_READ_CUTOFF = MP_DEFAULT_RADIX_READ_CUTOFF,
+    MP_RADIX_WRITE_CUTOFF = MP_DEFAULT_RADIX_WRITE_CUTOFF;
 #endif
 
 #endif

mp_read_radix.c

@@ -5,7 +5,6 @@
 
 #ifdef MP_USE_MEMOPS
 #  include <string.h>
-
 #  define MP_STRLEN(s) strlen(s)
 #else
 static size_t s_mp_strlen(const char *s)
@@ -26,7 +25,7 @@ mp_err mp_read_radix(mp_int *a, const char *str, int radix)
 
    mp_err   err = MP_OKAY;
    mp_sign  sign = MP_ZPOS;
-   size_t slen;
+   size_t slen, slen_2;
 
    /* make sure the radix is ok */
    if ((radix < 2) || (radix > 64)) {
@@ -68,29 +67,28 @@ mp_err mp_read_radix(mp_int *a, const char *str, int radix)
    if (MP_IS_2EXPT((unsigned int)radix) &&
        ((slen * (size_t) s_mp_log2_radix[radix]) > ((MP_MAX_DIGIT_COUNT - 2) * MP_DIGIT_BIT))) {
       return MP_OVF;
-   }
-
-   if ((radix == 10) && (slen >
+   } else  if ((radix == 10) && (slen >
 #if (MP_DIGIT_BIT == 15)
-                         2183
+                                 2183
 #elif (MP_DIGIT_BIT == 28)
-                         76695844
+                                 76695844
 #elif (MP_DIGIT_BIT == 31)
-                         69273664
+                                 69273664
 #elif (MP_DIGIT_BIT == 60)
-                         35791392
+                                 35791392
 #endif
-                        )) {
+                                )) {
       return MP_OVF;
    }
 
-   mp_zero(a);
+   /* Roughly (over)estimate bit-size for cutoff by assuming slen to be ceil(log_{radix}(input))
+      so  bits(slen) ~ slen_{radix} * ceil(log_2(radix)) */
+   slen_2 = slen * (size_t)(s_mp_log2_radix[radix] + 1);
 
-   /* TODO: Reading is quite quick, especially for bases of the form 2^n. Faster even for small input.
-            Include branches for them and/or (tunable?) cutoff? */
+   mp_zero(a);
 
    /* Try faster version first */
-   if (MP_HAS(S_MP_FASTER_READ_RADIX)) {
+   if (MP_HAS(S_MP_FASTER_READ_RADIX) && (slen_2 < (size_t)MP_RADIX_READ_CUTOFF)) {
       if ((err = s_mp_faster_read_radix(a, str, 0, slen, radix)) != MP_OKAY)                             goto LTM_ERR;
    } else if (MP_HAS(S_MP_SLOWER_READ_RADIX)) {
       if ((err = s_mp_slower_read_radix(a, str, 0, slen, radix)) != MP_OKAY)                             goto LTM_ERR;