Back to working(?) state

Author: czurnieden

s_mp_faster_read_radix.c

@@ -4,7 +4,7 @@
 /* SPDX-License-Identifier: Unlicense */
 
 /* TODO: It is tunable. Or is it? */
-#define MP_READ_RADIX_CUTOFF_MULTIPLICATOR 1
+#define MP_READ_RADIX_CUTOFF_MULTIPLICATOR 10
 
 /* for(n=2,64,t = ceil(log(2^100)/log(n)); printf(t", ");)  */
 static const uint8_t s_read_radix_cutoff[65] = { 0, 0,                            /*  0 .. 1*/

s_mp_faster_to_radix.c

@@ -134,7 +134,7 @@ mp_err s_mp_faster_to_radix(const mp_int *a, char *str, size_t maxlen, size_t *w
 
    /* Cutoff at about twice the size of P[0]. */
    /* TODO: Check if it makes sense to make it tunable. */
-   if (ilog2a < (2 * k)) {
+   if (ilog2a < (2 * k * MP_RADIX_BARRETT_START_MULTIPLICATOR)) {
       if ((err = s_mp_slower_to_radix(a, sptr, &part_maxlen, &part_written, radix, false)) != MP_OKAY)   goto LTM_ERR;
       /* part_written does not count EOS */
       *written = part_written + 1;
@@ -165,8 +165,18 @@ mp_err s_mp_faster_to_radix(const mp_int *a, char *str, size_t maxlen, size_t *w
       with R_0 = (2^(2*k))/b^y and k = ceil(log_2(n)) as computed above.
     */
 
+   /* To get the tree a bit flatter. Alternative: do it iteratively instead of recursively */
+   k = k * MP_RADIX_BARRETT_START_MULTIPLICATOR;
+
+
    /* Compute initial reciprocal R[0] and expand it (R[0]^(2^k) */
    if ((err = mp_init_i32(&P[0], n)) != MP_OKAY)                                                         goto LTM_ERR;
+   /* TODO: chunksize does not seem to matter much above the initial b^y, d.n.f.t. remove this line if
+            MP_RADIX_BARRETT_START_MULTIPLICATOR  is removed but don't forget the possibility that
+            the OS does not like too many recursions. This routine does use a lot of stack
+            and it calls other D&C algorithms (fast multiplication, fast division) that need a little
+            slice of the stack, too (vid.: ulimit -s) */
+   if ((err = mp_expt_n(&P[0], MP_RADIX_BARRETT_START_MULTIPLICATOR, &P[0])) != MP_OKAY)                 goto LTM_ERR;
    if ((err = mp_init(&R[0])) != MP_OKAY)                                                                goto LTM_ERR;
    if ((err = mp_2expt(&R[0], 2*k)) != MP_OKAY)                                                          goto LTM_ERR;
    if ((err = mp_div(&R[0], &P[0], &R[0], NULL)) != MP_OKAY)                                             goto LTM_ERR;

s_mp_slower_to_radix.c

@@ -26,7 +26,7 @@ mp_err s_mp_slower_to_radix(const mp_int *a, char **str, size_t *part_maxlen, si
 
    /* The number of digits of "radix" to be filled if this chunk is not the most significant one. */
    if (pad) {
-      ybar = s_mp_radix_exponent_y[radix];
+      ybar = s_mp_radix_exponent_y[radix] * MP_RADIX_BARRETT_START_MULTIPLICATOR;
    }
 
    if ((err = mp_init_copy(&t, a)) != MP_OKAY)                                                           goto LTM_ERR;

tommath.h

@@ -126,6 +126,9 @@ MP_RADIX_CUTOFF;
 #endif
 
 
+#ifndef MP_RADIX_BARRETT_START_MULTIPLICATOR
+#   define MP_RADIX_BARRETT_START_MULTIPLICATOR   10
+#endif
 
 
 /* define this to use lower memory usage routines (exptmods mostly) */