Copyright 1999-2006, 2008-2017, 2019-2022 Free Software Foundation, Inc.
This file is part of the GNU MP Library.
The GNU MP Library is free software; you can redistribute it and/or modify it under the terms of either:
* the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.
or
* the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
or both in parallel, as here.
The GNU MP Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received copies of the GNU General Public License and the GNU Lesser General Public License along with the GNU MP Library. If not,
see https://www.gnu.org/licenses/. */
int speed_option_addrs = 0; int speed_option_verbose = 0; int speed_option_cycles_broken = 0;
/* Provide __clz_tab even if it's not required, for the benefit of new code
being tested with many.pl. */ #ifndef COUNT_LEADING_ZEROS_NEED_CLZ_TAB #define COUNT_LEADING_ZEROS_NEED_CLZ_TAB #include"mp_clz_tab.c" #undef COUNT_LEADING_ZEROS_NEED_CLZ_TAB #endif
if (fd == -2)
{
fd = open ("/dev/wbinvd", O_RDWR); if (fd == -1)
perror ("open /dev/wbinvd");
}
if (fd != -1)
ioctl (fd, 0, 0);
} #endif
#if 0 #define WBINVDSIZE 1024*1024*2
{ staticchar *p = NULL; int i, sum;
if (p == NULL)
p = malloc (WBINVDSIZE);
#if 0 for (i = 0; i < WBINVDSIZE; i++)
p[i] = i & 0xFF; #endif
sum = 0; for (i = 0; i < WBINVDSIZE; i++)
sum += p[i];
mpn_cache_fill_dummy (sum);
} #endif
}
int
double_cmp_ptr (constdouble *p, constdouble *q)
{ if (*p > *q) return 1; if (*p < *q) return -1; return 0;
}
/* Measure the speed of a given routine.
The routine is run with enough repetitions to make it take at least speed_precision * speed_unittime. This aims to minimize the effects of a limited accuracy time base and the overhead of the measuring itself.
Measurements are made looking for 4 results within TOLERANCE of each other (or 3 for routines taking longer than 2 seconds). This aims to get an accurate reading even if some runs are bloated by interrupts or task switches or whatever.
The given (*fun)() is expected to run its function "s->reps" many times and return the total elapsed time measured using speed_starttime() and speed_endtime(). If the function doesn't support the given s->size or
s->r, -1.0 should be returned. See the various base routines below. */
struct speed_params s_dummy; int i, j, e; double t[30]; double t_unsorted[30]; double reps_d; int zeros = 0;
/* Use dummy parameters if caller doesn't provide any. Only a few special
"fun"s will cope with this, speed_noop() is one. */ if (s == NULL)
{
memset (&s_dummy, '\0', sizeof (s_dummy));
s = &s_dummy;
}
s->reps = 1;
s->time_divisor = 1.0; for (i = 0; i < numberof (t); i++)
{ for (;;)
{
s->src_num = 0;
s->dst_num = 0;
t[i] = (*fun) (s);
if (speed_option_verbose >= 3)
gmp_printf("size=%ld reps=%u r=%Md attempt=%d %.9f\n",
(long) s->size, s->reps, s->r, i, t[i]);
if (t[i] == 0.0)
{
zeros++; if (zeros > max_zeros)
{
fprintf (stderr, "Fatal error: too many (%d) failed measurements (0.0)\n", zeros);
abort ();
} if (s->reps < 10000)
s->reps *= 2;
continue;
}
if (t[i] == -1.0) return -1.0;
if (t[i] >= speed_unittime * speed_precision) break;
/* go to a value of reps to make t[i] >= precision */
reps_d = ceil (1.1 * s->reps
* speed_unittime * speed_precision
/ MAX (t[i], speed_unittime)); if (reps_d > 2e9 || reps_d < 1.0)
{
fprintf (stderr, "Fatal error: new reps bad: %.2f\n", reps_d);
fprintf (stderr, " (old reps %u, unittime %.4g, precision %d, t[i] %.4g)\n",
s->reps, speed_unittime, speed_precision, t[i]);
abort ();
}
s->reps = (unsigned) reps_d;
}
t[i] /= s->reps;
t_unsorted[i] = t[i];
if (speed_precision == 0) return t[i];
/* require 3 values within TOLERANCE when >= 2 secs, 4 when below */ if (t[0] >= 2.0)
e = 3; else
e = 4;
/* Look for e many t[]'s within TOLERANCE of each other to consider a
valid measurement. Return smallest among them. */ if (i >= e)
{
qsort (t, i+1, sizeof(t[0]), (qsort_function_t) double_cmp_ptr); for (j = e-1; j < i; j++) if (t[j] <= t[j-e+1] * TOLERANCE) return t[j-e+1] / s->time_divisor;
}
}
fprintf (stderr, "speed_measure() could not get %d results within %.1f%%\n",
e, (TOLERANCE-1.0)*100.0);
fprintf (stderr, " unsorted sorted\n");
fprintf (stderr, " %.12f %.12f is about %.1f%%\n",
t_unsorted[0]*(TOLERANCE-1.0), t[0]*(TOLERANCE-1.0),
100*(TOLERANCE-1.0)); for (i = 0; i < numberof (t); i++)
fprintf (stderr, " %.09f %.09f\n", t_unsorted[i], t[i]);
return -1.0;
}
/* Read all of ptr,size to get it into the CPU memory cache.
A call to mpn_cache_fill_dummy() is used to make sure the compiler doesn't optimize away the whole loop. Using "volatile mp_limb_t sum" would work too, but the function call means we don't rely on every compiler actually implementing volatile properly.
mpn_cache_fill_dummy() is in a separate source file to stop gcc thinking
it can inline it. */
/* FIXME: need a better way to get the format string for a pointer */
if (speed_option_addrs)
{ int different;
different = (s->dst_num != prev.dst_num || s->src_num != prev.src_num); for (i = 0; i < s->dst_num; i++)
different |= (s->dst[i].ptr != prev.dst[i].ptr); for (i = 0; i < s->src_num; i++)
different |= (s->src[i].ptr != prev.src[i].ptr);
if (different)
{ if (s->dst_num != 0)
{
printf ("dst"); for (i = 0; i < s->dst_num; i++)
printf (" %08lX", (unsignedlong) s->dst[i].ptr);
printf (" ");
}
if (s->src_num != 0)
{
printf ("src"); for (i = 0; i < s->src_num; i++)
printf (" %08lX", (unsignedlong) s->src[i].ptr);
printf (" ");
}
printf (" (cf sp approx %08lX)\n", (unsignedlong) &different);
}
memcpy (&prev, s, sizeof(prev));
}
switch (s->cache) { case 0: for (i = 0; i < s->dst_num; i++)
mpn_cache_fill_write (s->dst[i].ptr, s->dst[i].size); for (i = 0; i < s->src_num; i++)
mpn_cache_fill (s->src[i].ptr, s->src[i].size); break; case 1:
pentium_wbinvd(); break;
}
}
/* Miscellaneous options accepted by tune and speed programs under -o. */
/* The following are basic speed running routines for various gmp functions. Many are very similar and use speed.h macros.
Each routine allocates it's own destination space for the result of the function, because only it can know what the function needs.
speed_starttime() and speed_endtime() are put tight around the code to be measured. Any setups are done outside the timed portion.
Each routine is responsible for its own cache priming. speed_cache_fill() is a good way to do this, see examples in speed.h. One cache priming possibility, for CPUs with write-allocate cache, and functions that don't take too long, is to do one dummy call before timing so as to cache everything that gets used. But speed_measure() runs a routine at least twice and will take the smaller time, so this might not be necessary.
Data alignment will be important, for source, destination and temporary workspace. A routine can align its destination and workspace. Programs using the routines will ensure s->xp and s->yp are aligned. Aligning onto a CACHE_LINE_SIZE boundary is suggested. s->align_wp and s->align_wp2 should be respected where it makes sense to do so. SPEED_TMP_ALLOC_LIMBS is a good way to do this.
A loop of the following form can be expected to turn into good assembler code on most CPUs, thereby minimizing overhead in the measurement. It can always be assumed s->reps >= 1.
i = s->reps do foo(); while (--i != 0);
Additional parameters might be added to "struct speed_params" in the future. Routines should ignore anything they don't use.
s->size can be used creatively, and s->xp and s->yp can be ignored. For example, speed_mpz_fac_ui() uses s->size as n for the factorial. s->r is just a user-supplied parameter. speed_mpn_lshift() uses it as a shift,
speed_mpn_mul_1() uses it as a multiplier. */
/* These are mod 2^N+1 multiplies and squares. If s->r is supplied it's used as k, otherwise the best k for the size is used. If s->size isn't a
multiple of 2^k it's rounded up to make the effective operation size. */
/* Compare these to see how much malloc/free costs and then how much __gmp_default_allocate/free and mpz_init/clear add. mpz_init/clear or mpq_init/clear will be doing a 1 limb allocate, so use that as the size
when including them in comparisons. */
/* Compare this to mpn_add_n to see how much overhead mpz_add adds. Note that repeatedly calling mpz_add with the same data gives branch prediction
in it an advantage. */
mpz_init (w); if (s->r != 0)
k = s->r; else for (k = 1; s->size >> k; ++k);
speed_starttime ();
i = s->reps; do
{
mpz_mfac_uiui (w, s->size, k);
} while (--i != 0);
t = speed_endtime ();
mpz_clear (w); return t;
}
/* The multiplies are successively dependent so the latency is measured, not the issue rate. There's only 10 per loop so the code doesn't get too big since umul_ppmm is several instructions on some cpus.
Putting the arguments as "h,l,l,h" gets slightly better code from gcc 2.95.2 on x86, it puts only one mov between each mul, not two. That mov though will probably show up as a bogus extra cycle though.
The measuring function macros are into three parts to avoid overflowing preprocessor expansion space if umul_ppmm is big.
Limitations:
The default umul_ppmm doing h*l will be getting increasing numbers of high zero bits in the calculation. CPUs with data-dependent multipliers will want to use umul_ppmm.1 to get some randomization into the
calculation. The extra xors and fetches will be a slowdown of course. */
#define SPEED_MACRO_UMUL_PPMM_A \
{ \
mp_limb_t h, l; \ unsigned i; \ double t; \
\
s->time_divisor = 10; \
\
h = s->xp[0]; \
l = s->yp[0]; \
\ if (s->r == 1) \
{ \
speed_starttime (); \
i = s->reps; \ do \
{
#define SPEED_MACRO_UMUL_PPMM_B \
} \ while (--i != 0); \
t = speed_endtime (); \
} \ else \
{ \
speed_starttime (); \
i = s->reps; \ do \
{
#define SPEED_MACRO_UMUL_PPMM_C \
} \ while (--i != 0); \
t = speed_endtime (); \
} \
\ /* stop the compiler optimizing away the whole calculation! */ \
noop_1 (h); \
noop_1 (l); \
\ return t; \
}
double
speed_umul_ppmm (struct speed_params *s)
{
SPEED_MACRO_UMUL_PPMM_A;
{
umul_ppmm (h, l, l, h); h ^= s->xp_block[0]; l ^= s->yp_block[0];
umul_ppmm (h, l, l, h); h ^= s->xp_block[1]; l ^= s->yp_block[1];
umul_ppmm (h, l, l, h); h ^= s->xp_block[2]; l ^= s->yp_block[2];
umul_ppmm (h, l, l, h); h ^= s->xp_block[3]; l ^= s->yp_block[3];
umul_ppmm (h, l, l, h); h ^= s->xp_block[4]; l ^= s->yp_block[4];
umul_ppmm (h, l, l, h); h ^= s->xp_block[5]; l ^= s->yp_block[5];
umul_ppmm (h, l, l, h); h ^= s->xp_block[6]; l ^= s->yp_block[6];
umul_ppmm (h, l, l, h); h ^= s->xp_block[7]; l ^= s->yp_block[7];
umul_ppmm (h, l, l, h); h ^= s->xp_block[8]; l ^= s->yp_block[8];
umul_ppmm (h, l, l, h); h ^= s->xp_block[9]; l ^= s->yp_block[9];
}
SPEED_MACRO_UMUL_PPMM_B;
{
umul_ppmm (h, l, l, h);
umul_ppmm (h, l, l, h);
umul_ppmm (h, l, l, h);
umul_ppmm (h, l, l, h);
umul_ppmm (h, l, l, h);
umul_ppmm (h, l, l, h);
umul_ppmm (h, l, l, h);
umul_ppmm (h, l, l, h);
umul_ppmm (h, l, l, h);
umul_ppmm (h, l, l, h);
}
SPEED_MACRO_UMUL_PPMM_C;
}
#if HAVE_NATIVE_mpn_umul_ppmm double
speed_mpn_umul_ppmm (struct speed_params *s)
{
SPEED_MACRO_UMUL_PPMM_A;
{
h = mpn_umul_ppmm (&l, h, l); h ^= s->xp_block[0]; l ^= s->yp_block[0];
h = mpn_umul_ppmm (&l, h, l); h ^= s->xp_block[1]; l ^= s->yp_block[1];
h = mpn_umul_ppmm (&l, h, l); h ^= s->xp_block[2]; l ^= s->yp_block[2];
h = mpn_umul_ppmm (&l, h, l); h ^= s->xp_block[3]; l ^= s->yp_block[3];
h = mpn_umul_ppmm (&l, h, l); h ^= s->xp_block[4]; l ^= s->yp_block[4];
h = mpn_umul_ppmm (&l, h, l); h ^= s->xp_block[5]; l ^= s->yp_block[5];
h = mpn_umul_ppmm (&l, h, l); h ^= s->xp_block[6]; l ^= s->yp_block[6];
h = mpn_umul_ppmm (&l, h, l); h ^= s->xp_block[7]; l ^= s->yp_block[7];
h = mpn_umul_ppmm (&l, h, l); h ^= s->xp_block[8]; l ^= s->yp_block[8];
h = mpn_umul_ppmm (&l, h, l); h ^= s->xp_block[9]; l ^= s->yp_block[9];
}
SPEED_MACRO_UMUL_PPMM_B;
{
h = mpn_umul_ppmm (&l, h, l);
h = mpn_umul_ppmm (&l, h, l);
h = mpn_umul_ppmm (&l, h, l);
h = mpn_umul_ppmm (&l, h, l);
h = mpn_umul_ppmm (&l, h, l);
h = mpn_umul_ppmm (&l, h, l);
h = mpn_umul_ppmm (&l, h, l);
h = mpn_umul_ppmm (&l, h, l);
h = mpn_umul_ppmm (&l, h, l);
h = mpn_umul_ppmm (&l, h, l);
}
SPEED_MACRO_UMUL_PPMM_C;
} #endif
#if HAVE_NATIVE_mpn_umul_ppmm_r double
speed_mpn_umul_ppmm_r (struct speed_params *s)
{
SPEED_MACRO_UMUL_PPMM_A;
{
h = mpn_umul_ppmm_r (h, l, &l); h ^= s->xp_block[0]; l ^= s->yp_block[0];
h = mpn_umul_ppmm_r (h, l, &l); h ^= s->xp_block[1]; l ^= s->yp_block[1];
h = mpn_umul_ppmm_r (h, l, &l); h ^= s->xp_block[2]; l ^= s->yp_block[2];
h = mpn_umul_ppmm_r (h, l, &l); h ^= s->xp_block[3]; l ^= s->yp_block[3];
h = mpn_umul_ppmm_r (h, l, &l); h ^= s->xp_block[4]; l ^= s->yp_block[4];
h = mpn_umul_ppmm_r (h, l, &l); h ^= s->xp_block[5]; l ^= s->yp_block[5];
h = mpn_umul_ppmm_r (h, l, &l); h ^= s->xp_block[6]; l ^= s->yp_block[6];
h = mpn_umul_ppmm_r (h, l, &l); h ^= s->xp_block[7]; l ^= s->yp_block[7];
h = mpn_umul_ppmm_r (h, l, &l); h ^= s->xp_block[8]; l ^= s->yp_block[8];
h = mpn_umul_ppmm_r (h, l, &l); h ^= s->xp_block[9]; l ^= s->yp_block[9];
}
SPEED_MACRO_UMUL_PPMM_B;
{
h = mpn_umul_ppmm_r (h, l, &l);
h = mpn_umul_ppmm_r (h, l, &l);
h = mpn_umul_ppmm_r (h, l, &l);
h = mpn_umul_ppmm_r (h, l, &l);
h = mpn_umul_ppmm_r (h, l, &l);
h = mpn_umul_ppmm_r (h, l, &l);
h = mpn_umul_ppmm_r (h, l, &l);
h = mpn_umul_ppmm_r (h, l, &l);
h = mpn_umul_ppmm_r (h, l, &l);
h = mpn_umul_ppmm_r (h, l, &l);
}
SPEED_MACRO_UMUL_PPMM_C;
} #endif
/* The divisions are successively dependent so latency is measured, not issue rate. There's only 10 per loop so the code doesn't get too big, especially for udiv_qrnnd_preinv and preinv2norm, which are several instructions each.
Note that it's only the division which is measured here, there's no data fetching and no shifting if the divisor gets normalized.
In speed_udiv_qrnnd with gcc 2.95.2 on x86 the parameters "q,r,r,q,d" generate x86 div instructions with nothing in between.
The measuring function macros are in two parts to avoid overflowing preprocessor expansion space if udiv_qrnnd etc are big.
Limitations:
Don't blindly use this to set UDIV_TIME in gmp-mparam.h, check the code generated first.
CPUs with data-dependent divisions may want more attention paid to the randomness of the data used. Probably the measurement wanted is over
uniformly distributed numbers, but what's here might not be giving that. */
#define SPEED_ROUTINE_UDIV_QRNND_A(normalize) \
{ \ double t; \ unsigned i; \
mp_limb_t q, r, d; \
mp_limb_t dinv; \
\
s->time_divisor = 10; \
\ /* divisor from "r" parameter, or a default */ \
d = s->r; \ if (d == 0) \
d = mp_bases[10].big_base; \
\ if (normalize) \
{ \ unsigned norm; \
count_leading_zeros (norm, d); \
d <<= norm; \
invert_limb (dinv, d); \
} \
\
q = s->xp[0]; \
r = s->yp[0] % d; \
\
speed_starttime (); \
i = s->reps; \ do \
{
#define SPEED_ROUTINE_UDIV_QRNND_B \
} \ while (--i != 0); \
t = speed_endtime (); \
\ /* stop the compiler optimizing away the whole calculation! */ \
noop_1 (q); \
noop_1 (r); \
\ return t; \
}
double
speed_udiv_qrnnd (struct speed_params *s)
{
SPEED_ROUTINE_UDIV_QRNND_A (UDIV_NEEDS_NORMALIZATION);
{
udiv_qrnnd (q, r, r, q, d);
udiv_qrnnd (q, r, r, q, d);
udiv_qrnnd (q, r, r, q, d);
udiv_qrnnd (q, r, r, q, d);
udiv_qrnnd (q, r, r, q, d);
udiv_qrnnd (q, r, r, q, d);
udiv_qrnnd (q, r, r, q, d);
udiv_qrnnd (q, r, r, q, d);
udiv_qrnnd (q, r, r, q, d);
udiv_qrnnd (q, r, r, q, d);
}
SPEED_ROUTINE_UDIV_QRNND_B;
}
double
speed_udiv_qrnnd_c (struct speed_params *s)
{
SPEED_ROUTINE_UDIV_QRNND_A (1);
{
__udiv_qrnnd_c (q, r, r, q, d);
__udiv_qrnnd_c (q, r, r, q, d);
__udiv_qrnnd_c (q, r, r, q, d);
__udiv_qrnnd_c (q, r, r, q, d);
__udiv_qrnnd_c (q, r, r, q, d);
__udiv_qrnnd_c (q, r, r, q, d);
__udiv_qrnnd_c (q, r, r, q, d);
__udiv_qrnnd_c (q, r, r, q, d);
__udiv_qrnnd_c (q, r, r, q, d);
__udiv_qrnnd_c (q, r, r, q, d);
}
SPEED_ROUTINE_UDIV_QRNND_B;
}
#if HAVE_NATIVE_mpn_udiv_qrnnd double
speed_mpn_udiv_qrnnd (struct speed_params *s)
{
SPEED_ROUTINE_UDIV_QRNND_A (1);
{
q = mpn_udiv_qrnnd (&r, r, q, d);
q = mpn_udiv_qrnnd (&r, r, q, d);
q = mpn_udiv_qrnnd (&r, r, q, d);
q = mpn_udiv_qrnnd (&r, r, q, d);
q = mpn_udiv_qrnnd (&r, r, q, d);
q = mpn_udiv_qrnnd (&r, r, q, d);
q = mpn_udiv_qrnnd (&r, r, q, d);
q = mpn_udiv_qrnnd (&r, r, q, d);
q = mpn_udiv_qrnnd (&r, r, q, d);
q = mpn_udiv_qrnnd (&r, r, q, d);
}
SPEED_ROUTINE_UDIV_QRNND_B;
} #endif
#if HAVE_NATIVE_mpn_udiv_qrnnd_r double
speed_mpn_udiv_qrnnd_r (struct speed_params *s)
{
SPEED_ROUTINE_UDIV_QRNND_A (1);
{
q = mpn_udiv_qrnnd_r (r, q, d, &r);
q = mpn_udiv_qrnnd_r (r, q, d, &r);
q = mpn_udiv_qrnnd_r (r, q, d, &r);
q = mpn_udiv_qrnnd_r (r, q, d, &r);
q = mpn_udiv_qrnnd_r (r, q, d, &r);
q = mpn_udiv_qrnnd_r (r, q, d, &r);
q = mpn_udiv_qrnnd_r (r, q, d, &r);
q = mpn_udiv_qrnnd_r (r, q, d, &r);
q = mpn_udiv_qrnnd_r (r, q, d, &r);
q = mpn_udiv_qrnnd_r (r, q, d, &r);
}
SPEED_ROUTINE_UDIV_QRNND_B;
} #endif
/* xp[0] might not be particularly random, but should give an indication how
"/" runs. Same for speed_operator_mod below. */ double
speed_operator_div (struct speed_params *s)
{ double t; unsigned i;
mp_limb_t x, q, d;
s->time_divisor = 10;
/* divisor from "r" parameter, or a default */
d = s->r; if (d == 0)
d = mp_bases[10].big_base;
/* divisor from "r" parameter, or a default */
d = s->r; if (d == 0)
d = mp_bases[10].big_base;
x = s->xp[0];
r = 0;
speed_starttime ();
i = s->reps; do
{
r ^= x; r %= d;
r ^= x; r %= d;
r ^= x; r %= d;
r ^= x; r %= d;
r ^= x; r %= d;
r ^= x; r %= d;
r ^= x; r %= d;
r ^= x; r %= d;
r ^= x; r %= d;
r ^= x; r %= d;
} while (--i != 0);
t = speed_endtime ();
/* stop the compiler optimizing away the whole calculation! */
noop_1 (r);
return t;
}
/* r==0 measures on data with the values uniformly distributed. This will be typical for count_trailing_zeros in a GCD etc.
r==1 measures on data with the resultant count uniformly distributed between 0 and GMP_LIMB_BITS-1. This is probably sensible for
count_leading_zeros on the high limbs of divisors. */
int
speed_routine_count_zeros_setup (struct speed_params *s,
mp_ptr xp, int leading, int zero)
{ int i, c;
mp_limb_t n;
if (s->r == 0)
{ /* Make uniformly distributed data. If zero isn't allowed then change
it to 1 for leading, or 0x800..00 for trailing. */
MPN_COPY (xp, s->xp_block, SPEED_BLOCK_SIZE); if (! zero) for (i = 0; i < SPEED_BLOCK_SIZE; i++) if (xp[i] == 0)
xp[i] = leading ? 1 : GMP_LIMB_HIGHBIT;
} elseif (s->r == 1)
{ /* Make counts uniformly distributed. A randomly chosen bit is set, and for leading the rest above it are cleared, or for trailing then the
rest below. */ for (i = 0; i < SPEED_BLOCK_SIZE; i++)
{
mp_limb_t set = CNST_LIMB(1) << (s->yp_block[i] % GMP_LIMB_BITS);
mp_limb_t keep_below = set-1;
mp_limb_t keep_above = MP_LIMB_T_MAX ^ keep_below;
mp_limb_t keep = (leading ? keep_below : keep_above);
xp[i] = (s->xp_block[i] & keep) | set;
}
} else
{ return 0;
}
/* Account for the effect of n^=c. */
c = 0; for (i = 0; i < SPEED_BLOCK_SIZE; i++)
{
n = xp[i];
xp[i] ^= c;
if (leading)
count_leading_zeros (c, n); else
count_trailing_zeros (c, n);
}
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
