1 /**************************************************************************
3 * Copyright 2009 VMware, Inc.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
31 * Shared testing code.
33 * @author Jose Fonseca <jfonseca@vmware.com>
37 #include "lp_bld_const.h"
45 fprintf(fp
, "%s%s%u%sx%u",
46 type
.sign
? (type
.floating
|| type
.fixed
? "" : "s") : "u",
47 type
.floating
? "f" : (type
.fixed
? "h" : "i"),
55 read_elem(struct lp_type type
, const void *src
, unsigned index
)
57 double scale
= lp_const_scale(type
);
59 assert(index
< type
.length
);
63 value
= *((const float *)src
+ index
);
66 value
= *((const double *)src
+ index
);
77 value
= *((const int8_t *)src
+ index
);
80 value
= *((const int16_t *)src
+ index
);
83 value
= *((const int32_t *)src
+ index
);
86 value
= *((const int64_t *)src
+ index
);
96 value
= *((const uint8_t *)src
+ index
);
99 value
= *((const uint16_t *)src
+ index
);
102 value
= *((const uint32_t *)src
+ index
);
105 value
= *((const uint64_t *)src
+ index
);
118 write_elem(struct lp_type type
, void *dst
, unsigned index
, double value
)
120 assert(index
< type
.length
);
121 if(!type
.sign
&& value
< 0.0)
123 if(type
.norm
&& value
< -1.0)
125 if(type
.norm
&& value
> 1.0)
130 *((float *)dst
+ index
) = (float)(value
);
133 *((double *)dst
+ index
) = value
;
140 double scale
= lp_const_scale(type
);
141 value
= round(value
*scale
);
143 long long lvalue
= (long long)value
;
144 lvalue
= MIN2(lvalue
, ((long long)1 << (type
.width
- 1)) - 1);
147 *((int8_t *)dst
+ index
) = (int8_t)lvalue
;
150 *((int16_t *)dst
+ index
) = (int16_t)lvalue
;
153 *((int32_t *)dst
+ index
) = (int32_t)lvalue
;
156 *((int64_t *)dst
+ index
) = (int64_t)lvalue
;
163 unsigned long long lvalue
= (long long)value
;
164 lvalue
= MIN2(lvalue
, ((unsigned long long)1 << type
.width
) - 1);
167 *((uint8_t *)dst
+ index
) = (uint8_t)lvalue
;
170 *((uint16_t *)dst
+ index
) = (uint16_t)lvalue
;
173 *((uint32_t *)dst
+ index
) = (uint32_t)lvalue
;
176 *((uint64_t *)dst
+ index
) = (uint64_t)lvalue
;
187 random_elem(struct lp_type type
, void *dst
, unsigned index
)
190 assert(index
< type
.length
);
191 value
= (double)rand()/(double)RAND_MAX
;
193 unsigned long long mask
;
195 mask
= ~(unsigned long long)0;
197 mask
= ((unsigned long long)1 << (type
.width
/ 2)) - 1;
199 mask
= ((unsigned long long)1 << (type
.width
- 1)) - 1;
201 mask
= ((unsigned long long)1 << type
.width
) - 1;
202 value
+= (double)(mask
& rand());
207 write_elem(type
, dst
, index
, value
);
212 read_vec(struct lp_type type
, const void *src
, double *dst
)
215 for (i
= 0; i
< type
.length
; ++i
)
216 dst
[i
] = read_elem(type
, src
, i
);
221 write_vec(struct lp_type type
, void *dst
, const double *src
)
224 for (i
= 0; i
< type
.length
; ++i
)
225 write_elem(type
, dst
, i
, src
[i
]);
232 return (float)((double)rand()/(double)RAND_MAX
);
237 random_vec(struct lp_type type
, void *dst
)
240 for (i
= 0; i
< type
.length
; ++i
)
241 random_elem(type
, dst
, i
);
246 compare_vec_with_eps(struct lp_type type
, const void *res
, const void *ref
, double eps
)
249 for (i
= 0; i
< type
.length
; ++i
) {
250 double res_elem
= read_elem(type
, res
, i
);
251 double ref_elem
= read_elem(type
, ref
, i
);
252 double delta
= fabs(res_elem
- ref_elem
);
262 compare_vec(struct lp_type type
, const void *res
, const void *ref
)
264 double eps
= lp_const_eps(type
);
265 return compare_vec_with_eps(type
, res
, ref
, eps
);
270 dump_vec(FILE *fp
, struct lp_type type
, const void *src
)
273 for (i
= 0; i
< type
.length
; ++i
) {
280 value
= *((const float *)src
+ i
);
283 value
= *((const double *)src
+ i
);
289 fprintf(fp
, "%f", value
);
292 if(type
.sign
&& !type
.norm
) {
297 value
= *((const int8_t *)src
+ i
);
301 value
= *((const int16_t *)src
+ i
);
305 value
= *((const int32_t *)src
+ i
);
309 value
= *((const int64_t *)src
+ i
);
317 fprintf(fp
, format
, value
);
320 unsigned long long value
;
324 value
= *((const uint8_t *)src
+ i
);
325 format
= type
.norm
? "%2x" : "%4llu";
328 value
= *((const uint16_t *)src
+ i
);
329 format
= type
.norm
? "%4x" : "%6llx";
332 value
= *((const uint32_t *)src
+ i
);
333 format
= type
.norm
? "%8x" : "%11llx";
336 value
= *((const uint64_t *)src
+ i
);
337 format
= type
.norm
? "%16x" : "%21llx";
344 fprintf(fp
, format
, value
);
351 int main(int argc
, char **argv
)
353 unsigned verbose
= 0;
355 unsigned long n
= 1000;
359 for(i
= 1; i
< argc
; ++i
) {
360 if(strcmp(argv
[i
], "-v") == 0)
362 else if(strcmp(argv
[i
], "-o") == 0)
363 fp
= fopen(argv
[++i
], "wt");
369 /* Warm up the caches */
370 test_some(0, NULL
, 100);
372 write_tsv_header(fp
);
376 success
= test_some(verbose
, fp
, n
);
378 success
= test_all(verbose
, fp
);
383 return success
? 0 : 1;