diff options
| -rw-r--r-- | test/dtypes.c | 193 |
1 files changed, 50 insertions, 143 deletions
diff --git a/test/dtypes.c b/test/dtypes.c index d984105..77a0446 100644 --- a/test/dtypes.c +++ b/test/dtypes.c @@ -118,7 +118,7 @@ static int num_opaque_conversions_g = 0; #define aligned_malloc(Z) ((void*)((char*)HDmalloc(ALIGNMENT+Z)+ALIGNMENT)) #define aligned_free(M) HDfree((char*)(M)-ALIGNMENT) -/* Initialize source buffer of integer for integer->integer and integer->floating-point conversion test. +/* Initialize source buffer of integer for integer->integer conversion test. * This algorithm is mainly to avoid any casting and comparison between source and destination types * for compiler, because we're testing conversions. */ #define INIT_INTEGER(TYPE, SRC_MAX, SRC_MIN, SRC_SIZE, DST_SIZE, SRC_PREC, BUF, SAVED, NELMTS) \ @@ -169,129 +169,6 @@ static int num_opaque_conversions_g = 0; } \ } -/* Change a buffer's byte order from big endian to little endian. It's mainly for library's - * bit operations which handle only little endian order. - */ -#define CHANGE_ORDER(EBUF, EORDER, ESIZE) \ -{ \ - if (H5T_ORDER_BE==EORDER) { \ - int m; \ - unsigned char mediator; \ - size_t half_size = ESIZE/2; \ - for (m=0; m<half_size; m++) { \ - mediator = EBUF[ESIZE-(m+1)]; \ - EBUF[ESIZE-(m+1)] = EBUF[m]; \ - EBUF[m] = mediator; \ - } \ - } \ -} - -/* Allocate buffer and initialize it with floating-point normalized and denormalized values. - * It's for conversion test of floating-point as the source. - */ -#define INIT_FP(TYPE, SRC_MAX, SRC_MIN, SRC_MAX_10_EXP, SRC_MIN_10_EXP, SRC_MANT_DIG, SRC_SIZE, \ - SRC_PREC, SRC_ORDR, DST_SIZE, BUF, SAVED, NELMTS) \ -{ \ - unsigned char *buf_p, *saved_p; \ - unsigned char *tmp1, *tmp2; \ - size_t num_norm, factor, n; \ - TYPE value1, value2; \ - TYPE multiply; \ - \ - /*Determine the number of normalized values and increment pace. The values start from \ - *minimal normalized value and are multiplied by MULTIPLY each step until reach to maximal \ - *normalized value.*/ \ - if(SRC_MAX_10_EXP<100) { /*for float*/ \ - factor = 0; \ - multiply = 10; \ - } else if(SRC_MAX_10_EXP>=100 && SRC_MAX_10_EXP<400) { /*for double*/ \ - factor = 2; \ - multiply = 10000; \ - } else { /*for long double*/ \ - factor = 3; \ - multiply = 100000000; \ - } \ - \ - /*The number of values if multiplied by 10 for each step.*/ \ - num_norm = (SRC_MAX_10_EXP - SRC_MIN_10_EXP); \ - /*Reduce the number of values by 2^factor. MULTIPLY=10^(2^factor). Using this algorithm \ - *instead of arithmatic operation to avoid any conversion*/ \ - num_norm >>= factor; \ - \ - /*Total number of values*/ \ - NELMTS = 2 * /*both positive and negative*/ \ - (num_norm + /*number of normalized values*/ \ - 1 + /*maximal normalized value*/ \ - SRC_MANT_DIG - 1); /*number of denormalized values*/ \ - \ - /* Allocate buffers */ \ - BUF = (unsigned char*)aligned_malloc(NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - SAVED = (unsigned char*)aligned_malloc(NELMTS*MAX(SRC_SIZE, DST_SIZE)); \ - tmp1 = (unsigned char*)malloc(SRC_SIZE); \ - tmp2 = (unsigned char*)malloc(SRC_SIZE); \ - \ - buf_p = BUF; \ - saved_p = SAVED; \ - \ - /*Normalized values*/ \ - value1 = SRC_MIN; \ - value2 = -SRC_MIN; \ - for(n=0; n<num_norm; n++) { \ - if(value1<SRC_MAX) { /*positive*/ \ - memcpy(buf_p, &value1, SRC_SIZE); \ - memcpy(saved_p, &value1, SRC_SIZE); \ - value1 *= multiply; \ - buf_p += SRC_SIZE; \ - saved_p += SRC_SIZE; \ - } \ - if(value2>-SRC_MAX) { /*negative*/ \ - memcpy(buf_p, &value2, SRC_SIZE); \ - memcpy(saved_p, &value2, SRC_SIZE); \ - value2 *= multiply; \ - buf_p += SRC_SIZE; \ - saved_p += SRC_SIZE; \ - } \ - } \ - \ - value1 = SRC_MAX; /*maximal value*/ \ - memcpy(buf_p, &value1, SRC_SIZE); \ - memcpy(saved_p, &value1, SRC_SIZE); \ - buf_p += SRC_SIZE; \ - saved_p += SRC_SIZE; \ - \ - value2 = -SRC_MAX; /*negative value*/ \ - memcpy(buf_p, &value2, SRC_SIZE); \ - memcpy(saved_p, &value2, SRC_SIZE); \ - buf_p += SRC_SIZE; \ - saved_p += SRC_SIZE; \ - \ - /*Denormalized values. Exponent is 0. Let mantissa starts from 00000001, 00000011, \ - *00000111,..., until 11111111.*/ \ - memset(tmp1, 0, SRC_SIZE); \ - memset(tmp2, 0, SRC_SIZE); \ - H5T_bit_set (tmp2, SRC_PREC-1, 1, TRUE); /*the negative value*/ \ - for(n=0; n<SRC_MANT_DIG-1; n++) { \ - H5T_bit_set (tmp1, n, 1, TRUE); /*turn on 1 bit each time*/ \ - CHANGE_ORDER(tmp1, SRC_ORDR, SRC_SIZE); /*change order for big endian*/ \ - memcpy(buf_p, tmp1, SRC_SIZE); \ - memcpy(saved_p, tmp1, SRC_SIZE); \ - CHANGE_ORDER(tmp1, SRC_ORDR, SRC_SIZE); /*change back the order for bit operation*/ \ - buf_p += SRC_SIZE; \ - saved_p += SRC_SIZE; \ - \ - /*negative values*/ \ - H5T_bit_set (tmp2, n, 1, TRUE); \ - CHANGE_ORDER(tmp2, SRC_ORDR, SRC_SIZE); \ - memcpy(buf_p, tmp2, SRC_SIZE); \ - memcpy(saved_p, tmp2, SRC_SIZE); \ - CHANGE_ORDER(tmp2, SRC_ORDR, SRC_SIZE); \ - buf_p += SRC_SIZE; \ - saved_p += SRC_SIZE; \ - } \ - free(tmp1); \ - free(tmp2); \ -} - void some_dummy_func(float x); static hbool_t overflows(unsigned char *origin_bits, hid_t src_id, size_t dst_num_bits); static int my_isnan(dtype_t type, void *val); @@ -4776,9 +4653,9 @@ test_conv_int_1(const char *name, hid_t src, hid_t dst) } else if(src_type == INT_ULONG) { INIT_INTEGER(unsigned long, ULONG_MAX, 0, src_size, dst_size, src_nbits, buf, saved, nelmts); } else if(src_type == INT_LLONG) { - INIT_INTEGER(long_long, LLONG_MAX, LLONG_MIN, src_size, dst_size, src_nbits, buf, saved, nelmts); + INIT_INTEGER(long long, LLONG_MAX, LLONG_MIN, src_size, dst_size, src_nbits, buf, saved, nelmts); } else if(src_type == INT_ULLONG) { - INIT_INTEGER(unsigned long_long, ULLONG_MAX, 0, src_size, dst_size, src_nbits, buf, saved, nelmts); + INIT_INTEGER(unsigned long long, ULLONG_MAX, 0, src_size, dst_size, src_nbits, buf, saved, nelmts); } else goto error; @@ -6418,9 +6295,9 @@ test_conv_int_float(const char *name, hid_t src, hid_t dst) goto error; } - /* Allocate and initialize the source buffer through macro INIT_INTEGER if the source is integer, - * INIT_FP if floating-point. The BUF will be used for the conversion while the SAVED buffer - * will be used for the comparison later. + /* Allocate and initialize the source buffer through macro INIT_INTEGER if the source is integer. + * The BUF will be used for the conversion while the SAVED buffer will be + * used for the comparison later. */ if(src_type == INT_SCHAR) { INIT_INTEGER(signed char, SCHAR_MAX, SCHAR_MIN, src_size, dst_size, src_nbits, buf, saved, nelmts); @@ -6439,20 +6316,50 @@ test_conv_int_float(const char *name, hid_t src, hid_t dst) } else if(src_type == INT_ULONG) { INIT_INTEGER(unsigned long, ULONG_MAX, 0, src_size, dst_size, src_nbits, buf, saved, nelmts); } else if(src_type == INT_LLONG) { - INIT_INTEGER(long_long, LLONG_MAX, LLONG_MIN, src_size, dst_size, src_nbits, buf, saved, nelmts); + INIT_INTEGER(long long, LLONG_MAX, LLONG_MIN, src_size, dst_size, src_nbits, buf, saved, nelmts); } else if(src_type == INT_ULLONG) { - INIT_INTEGER(unsigned long_long, ULLONG_MAX, 0, src_size, dst_size, src_nbits, buf, saved, nelmts); - } else if(src_type == FLT_FLOAT) { - INIT_FP(float, FLT_MAX, FLT_MIN, FLT_MAX_10_EXP, FLT_MIN_10_EXP, FLT_MANT_DIG, - src_size, src_nbits, endian, dst_size, buf, saved, nelmts); - } else if(src_type == FLT_DOUBLE) { - INIT_FP(double, DBL_MAX, DBL_MIN, DBL_MAX_10_EXP, DBL_MIN_10_EXP, DBL_MANT_DIG, - src_size, src_nbits, endian, dst_size, buf, saved, nelmts); - } else if(src_type == FLT_LDOUBLE) { - INIT_FP(long double, LDBL_MAX, LDBL_MIN, LDBL_MAX_10_EXP, LDBL_MIN_10_EXP, LDBL_MANT_DIG, - src_size, src_nbits, endian, dst_size, buf, saved, nelmts); - } else - goto error; + INIT_INTEGER(unsigned long long, ULLONG_MAX, 0, src_size, dst_size, src_nbits, buf, saved, nelmts); + } else { /* source is floating number. Use the old way to fill in random values. */ + /* Reduce the number of elements if the source is "long double" + * because it takes too long. + */ + if(src_type == FLT_LDOUBLE) + nelmts = NTESTELEM / 10; + else + nelmts = NTESTELEM; + + /* Allocate buffers */ + buf = (unsigned char*)aligned_malloc(nelmts*MAX(src_size, dst_size)); + saved = (unsigned char*)aligned_malloc(nelmts*MAX(src_size, dst_size)); + + /* + * Initialize the source buffers to random bits. The `buf' buffer + * will be used for the conversion while the `saved' buffer will be + * used for the comparison later. + */ + for (j=0; j<nelmts*src_size; j++) { + buf[j] = saved[j] = HDrand(); + + /* For Intel machines, the size of "long double" is 12 byte, precision + * is 80 bits, mantissa size is 64 bits, and no normalization. So the + * most significant bit of mantissa is always 1 unless the floating number + * has special value. This step tries to compensate this case by turning + * on the most significant bit of mantissa if the mantissa bits aren't + * all 0s. It also tries to decrease exponent by one if the exponent + * happens to be set all 1s(NaN). + */ + if(endian==H5T_ORDER_LE && src_type==FLT_LDOUBLE && src_size==12) { + if(j%12==7) { + buf[j] |= 0x80; + saved[j] |= 0x80; + } + if(j%12==9 && (buf[j]==0xff || buf[j]==0x7f) && buf[j-1]==0xff) { + buf[j] -= 1; + saved[j] -= 1; + } + } + } + } /* The tests */ for (i=0; i<ntests; i++) { @@ -7558,7 +7465,7 @@ run_float_int_conv(const char *name) nerrors += test_conv_int_float(name, H5T_NATIVE_FLOAT, H5T_NATIVE_SCHAR); nerrors += test_conv_int_float(name, H5T_NATIVE_DOUBLE, H5T_NATIVE_SCHAR); - nerrors += test_conv_int_float(name, H5T_NATIVE_FLOAT, H5T_NATIVE_UCHAR); + nerrors += test_conv_int_float(name, H5T_NATIVE_FLOAT, H5T_NATIVE_UCHAR); nerrors += test_conv_int_float(name, H5T_NATIVE_DOUBLE, H5T_NATIVE_UCHAR); nerrors += test_conv_int_float(name, H5T_NATIVE_FLOAT, H5T_NATIVE_SHORT); |