| /* |
| * Copyright (c) 2008-2010 Stefan Krah. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND |
| * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
| * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| */ |
| |
| |
| #include "mpdecimal.h" |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <time.h> |
| #include "mptypes.h" |
| #include "mptest.h" |
| #include "malloc_fail.h" |
| |
| |
| /* |
| * Code coverage for _mpd_fntmul, _mpd_kmul, and _mpd_kmul_fnt. Since |
| * _mpd_kmul_fnt is only triggered for a result length that exceeds |
| * 3*MPD_MAXTRANSFORM_2N, the final tests require substantial amounts |
| * of RAM. |
| * |
| * For CONFIG_32, 4-8GB are required, This means that the tests will |
| * run comfortably on a 64-bit 8GB machine if the compile option |
| * MACHINE=full_coverage is chosen. |
| * |
| * For CONFIG_64, about 1TB of memory would be needed. |
| */ |
| |
| |
| #ifndef _MSC_VER |
| #define ASSERT(p) if (!(p)) {abort();} |
| #else |
| #define ASSERT(p) if (!(p)) {mpd_err_fatal("assertion failed");} |
| #endif |
| |
| #define MAXWORDS 10000 |
| |
| |
| int |
| main(void) |
| { |
| uint32_t status = 0; |
| mpd_context_t ctx; |
| mpd_uint_t *a, *b; |
| mpd_uint_t *fntresult, *kresult, *kfntresult; |
| mpd_size_t rsize; |
| mpd_t *x, *y, *z; |
| mpd_ssize_t xl[5] = {MPD_MAXTRANSFORM_2N, 2*MPD_MAXTRANSFORM_2N, |
| 4*MPD_MAXTRANSFORM_2N, 4*MPD_MAXTRANSFORM_2N-1, |
| 4*MPD_MAXTRANSFORM_2N-1}; |
| mpd_ssize_t yl[5] = {MPD_MAXTRANSFORM_2N/2, MPD_MAXTRANSFORM_2N, |
| 2*MPD_MAXTRANSFORM_2N, 2*MPD_MAXTRANSFORM_2N, |
| 32}; |
| mpd_ssize_t k, alen, blen; |
| mpd_ssize_t xlen, ylen; |
| time_t seed; |
| int i; |
| |
| |
| mpd_maxcontext(&ctx); |
| |
| a = malloc(MAXWORDS * (sizeof *a)); |
| b = malloc(MAXWORDS * (sizeof *b)); |
| |
| for (k = 0; k < MAXWORDS; k++) { |
| a[k] = MPD_RADIX-1; |
| } |
| for (k = 0; k < MAXWORDS; k++) { |
| b[k] = MPD_RADIX-1; |
| } |
| |
| fprintf(stderr, "Running fntcov ... \n\n"); |
| fprintf(stderr, " Testing Karatsuba multiplication and number " |
| "theoretic transform ... "); |
| |
| /* bignum: all digits 9 */ |
| for (alen = 1200; alen < MAXWORDS; alen += 1000) { |
| |
| fntresult = _mpd_fntmul(a, a, alen, alen, &rsize); |
| kresult = _mpd_kmul(a, a, alen, alen, &rsize); |
| kfntresult = _mpd_kmul_fnt(a, a, alen, alen, &rsize); |
| |
| for (k = 0; k < 2*alen; k++) { |
| if (kresult[k] != fntresult[k] || kfntresult[k] != fntresult[k]) { |
| fprintf(stderr, " FAIL\n"); |
| exit(1); |
| } |
| } |
| |
| __mingw_dfp_get_globals()->mpd_free(fntresult); |
| __mingw_dfp_get_globals()->mpd_free(kresult); |
| __mingw_dfp_get_globals()->mpd_free(kfntresult); |
| |
| for (blen = 1200; blen <= alen; blen += 1000) { |
| |
| fntresult = _mpd_fntmul(a, b, alen, blen, &rsize); |
| kresult = _mpd_kmul(a, b, alen, blen, &rsize); |
| kfntresult = _mpd_kmul_fnt(a, b, alen, blen, &rsize); |
| |
| for (k = 0; k < alen+blen; k++) { |
| if (kresult[k] != fntresult[k] || kfntresult[k] != fntresult[k]) { |
| fprintf(stderr, " FAIL\n"); |
| exit(1); |
| } |
| } |
| |
| __mingw_dfp_get_globals()->mpd_free(fntresult); |
| __mingw_dfp_get_globals()->mpd_free(kresult); |
| __mingw_dfp_get_globals()->mpd_free(kfntresult); |
| } |
| } |
| |
| /* Bignum: random test */ |
| seed = time(NULL); |
| srandom((unsigned int)seed); |
| |
| for (alen = 1200; alen < MAXWORDS; alen += 1000) { |
| |
| for (k = 0; k < alen; k++) { |
| a[k] = random()%MPD_RADIX; |
| } |
| |
| fntresult = _mpd_fntmul(a, a, alen, alen, &rsize); |
| kresult = _mpd_kmul(a, a, alen, alen, &rsize); |
| kfntresult = _mpd_kmul_fnt(a, a, alen, alen, &rsize); |
| |
| for (k = 0; k < 2*alen; k++) { |
| if (kresult[k] != fntresult[k] || kfntresult[k] != fntresult[k]) { |
| fprintf(stderr, " FAIL: seed = %"PRI_time_t"\n", seed); |
| exit(1); |
| } |
| } |
| |
| __mingw_dfp_get_globals()->mpd_free(fntresult); |
| __mingw_dfp_get_globals()->mpd_free(kresult); |
| __mingw_dfp_get_globals()->mpd_free(kfntresult); |
| |
| for (blen = 1200; blen <= alen; blen += 1000) { |
| |
| for (k = 0; k < blen; k++) { |
| b[k] = random()%MPD_RADIX; |
| } |
| |
| fntresult = _mpd_fntmul(a, b, alen, blen, &rsize); |
| kresult = _mpd_kmul(a, b, alen, blen, &rsize); |
| kfntresult = _mpd_kmul_fnt(a, b, alen, blen, &rsize); |
| |
| for (k = 0; k < alen+blen; k++) { |
| if (kresult[k] != fntresult[k] || kfntresult[k] != fntresult[k]) { |
| fprintf(stderr, " FAIL: seed = %"PRI_time_t"\n", seed); |
| exit(1); |
| } |
| } |
| |
| __mingw_dfp_get_globals()->mpd_free(fntresult); |
| __mingw_dfp_get_globals()->mpd_free(kresult); |
| __mingw_dfp_get_globals()->mpd_free(kfntresult); |
| } |
| } |
| |
| /* Excessive lengths */ |
| fntresult = _mpd_fntmul(a, a, 2*MPD_MAXTRANSFORM_2N, 2*MPD_MAXTRANSFORM_2N, |
| &rsize); |
| ASSERT(fntresult == NULL) |
| |
| /* Allocation failures */ |
| for (alen=500, blen = 500; alen <= 4000; alen+=3500, blen+=1500) { |
| |
| for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) { |
| |
| mpd_set_alloc_fail(&ctx); |
| fntresult = _mpd_fntmul(a, a, alen, alen, &rsize); |
| mpd_set_alloc(&ctx); |
| |
| if (fntresult != NULL) { |
| __mingw_dfp_get_globals()->mpd_free(fntresult); |
| if (alloc_idx < alloc_fail) { |
| break; |
| } |
| } |
| } |
| for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) { |
| |
| mpd_set_alloc_fail(&ctx); |
| fntresult = _mpd_fntmul(a, b, alen, blen, &rsize); |
| mpd_set_alloc(&ctx); |
| |
| if (fntresult != NULL) { |
| __mingw_dfp_get_globals()->mpd_free(fntresult); |
| if (alloc_idx < alloc_fail) { |
| break; |
| } |
| } |
| } |
| for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) { |
| |
| mpd_set_alloc_fail(&ctx); |
| kresult = _mpd_kmul(a, a, alen, alen, &rsize); |
| mpd_set_alloc(&ctx); |
| |
| if (kresult != NULL) { |
| __mingw_dfp_get_globals()->mpd_free(kresult); |
| if (alloc_idx < alloc_fail) { |
| break; |
| } |
| } |
| } |
| for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) { |
| |
| mpd_set_alloc_fail(&ctx); |
| kresult = _mpd_kmul(a, b, alen, blen, &rsize); |
| mpd_set_alloc(&ctx); |
| |
| if (kresult != NULL) { |
| __mingw_dfp_get_globals()->mpd_free(kresult); |
| if (alloc_idx < alloc_fail) { |
| break; |
| } |
| } |
| } |
| for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) { |
| |
| mpd_set_alloc_fail(&ctx); |
| kfntresult = _mpd_kmul_fnt(a, a, alen, alen, &rsize); |
| mpd_set_alloc(&ctx); |
| |
| if (kfntresult != NULL) { |
| __mingw_dfp_get_globals()->mpd_free(kfntresult); |
| if (alloc_idx < alloc_fail) { |
| break; |
| } |
| } |
| } |
| for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) { |
| |
| mpd_set_alloc_fail(&ctx); |
| kfntresult = _mpd_kmul_fnt(a, b, alen, blen, &rsize); |
| mpd_set_alloc(&ctx); |
| |
| if (kfntresult != NULL) { |
| __mingw_dfp_get_globals()->mpd_free(kfntresult); |
| if (alloc_idx < alloc_fail) { |
| break; |
| } |
| } |
| } |
| } |
| |
| __mingw_dfp_get_globals()->mpd_free(a); |
| __mingw_dfp_get_globals()->mpd_free(b); |
| |
| |
| /* Huge numbers */ |
| fprintf(stderr, "\n\n Long test, requires more than 4GB of memory ... \n\n"); |
| |
| x = mpd_new(&ctx); |
| y = mpd_new(&ctx); |
| z = mpd_new(&ctx); |
| |
| ctx.traps = 0; |
| /* NOT safe, but works for this test. */ |
| ctx.emax = MPD_SSIZE_MAX; |
| ctx.prec = MPD_SSIZE_MAX; |
| for (i = 0; i < 5; i++) { |
| |
| xlen = xl[i]; |
| ylen = yl[i]; |
| fprintf(stderr, " op1: %11"PRI_mpd_ssize_t" words op2: " |
| "%11"PRI_mpd_ssize_t" words\n", xlen, ylen); |
| |
| if (!mpd_qresize(x, xlen, &status)) { |
| goto malloc_error; |
| } |
| for (k = 0; k < xlen; k++) { |
| x->data[k] = MPD_RADIX-1; |
| } |
| x->len = xlen; |
| x->exp = 0; |
| mpd_setdigits(x); |
| |
| if (!mpd_qresize(y, ylen, &status)) { |
| goto malloc_error; |
| } |
| for (k = 0; k < ylen; k++) { |
| y->data[k] = MPD_RADIX-1; |
| } |
| y->len = ylen; |
| y->exp = 0; |
| mpd_setdigits(y); |
| |
| ctx.status = 0; |
| mpd_mul(z, x, y, &ctx); |
| if (mpd_isnan(z)) { |
| ASSERT(ctx.status&MPD_Malloc_error); |
| goto malloc_error; |
| } |
| |
| ASSERT(z->data[0] == 1) |
| for (k = 1; k < ylen; k++) { |
| ASSERT(z->data[k] == 0) |
| } |
| for (; k < xlen; k++) { |
| ASSERT(z->data[k] == MPD_RADIX-1); |
| } |
| ASSERT(z->data[k] == MPD_RADIX-2) |
| k++; |
| for (; k < xlen+ylen; k++) { |
| ASSERT(z->data[k] == MPD_RADIX-1); |
| } |
| |
| #if 0 |
| /* Allocation failures: Only reasonable to test with an |
| * artificially small MPD_MAXTRANSFORM_2N. For example, |
| * with MPD_MAXTRANSFORM_2N=4096 coverage of _mpd_kmul_fnt |
| * is 100%, i.e. also lines tagged with GCOV_UNLIKELY are |
| * reached. |
| */ |
| for (alloc_fail = 1; alloc_fail < INT_MAX; alloc_fail++) { |
| ctx.status = 0; |
| |
| mpd_set_alloc_fail(&ctx); |
| mpd_mul(z, x, y, &ctx); |
| mpd_set_alloc(&ctx); |
| |
| if (!(ctx.status&MPD_Malloc_error)) { |
| if (alloc_idx < alloc_fail) { |
| printf("alloc_idx: %d\n", alloc_idx); |
| break; |
| } |
| } |
| else { |
| ASSERT(mpd_isnan(z)); |
| } |
| } |
| #endif |
| } |
| |
| fprintf(stderr, "\nfntcov: PASS\n\n"); |
| |
| out: |
| mpd_del(x); |
| mpd_del(y); |
| mpd_del(z); |
| return 0; |
| |
| |
| malloc_error: |
| fprintf(stderr, "\nfntcov: out of memory: this test requires large " |
| "amounts of memory\n\n"); |
| goto out; |
| } |
| |
| |
