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 "util/u_cpu_detect.h"
38 #include "util/u_math.h"
40 #include "gallivm/lp_bld_const.h"
41 #include "gallivm/lp_bld_init.h"
42 #include "gallivm/lp_bld_debug.h"
50 fprintf(fp
, "%s%s%u%sx%u",
51 type
.sign
? (type
.floating
|| type
.fixed
? "" : "s") : "u",
52 type
.floating
? "f" : (type
.fixed
? "h" : "i"),
60 read_elem(struct lp_type type
, const void *src
, unsigned index
)
62 double scale
= lp_const_scale(type
);
64 assert(index
< type
.length
);
68 value
= *((const float *)src
+ index
);
71 value
= *((const double *)src
+ index
);
82 value
= *((const int8_t *)src
+ index
);
85 value
= *((const int16_t *)src
+ index
);
88 value
= *((const int32_t *)src
+ index
);
91 value
= *((const int64_t *)src
+ index
);
101 value
= *((const uint8_t *)src
+ index
);
104 value
= *((const uint16_t *)src
+ index
);
107 value
= *((const uint32_t *)src
+ index
);
110 value
= *((const uint64_t *)src
+ index
);
123 write_elem(struct lp_type type
, void *dst
, unsigned index
, double value
)
125 assert(index
< type
.length
);
126 if(!type
.sign
&& value
< 0.0)
128 if(type
.norm
&& value
< -1.0)
130 if(type
.norm
&& value
> 1.0)
135 *((float *)dst
+ index
) = (float)(value
);
138 *((double *)dst
+ index
) = value
;
145 double scale
= lp_const_scale(type
);
146 value
= round(value
*scale
);
148 long long lvalue
= (long long)value
;
149 lvalue
= MIN2(lvalue
, ((long long)1 << (type
.width
- 1)) - 1);
150 lvalue
= MAX2(lvalue
, -((long long)1 << (type
.width
- 1)));
153 *((int8_t *)dst
+ index
) = (int8_t)lvalue
;
156 *((int16_t *)dst
+ index
) = (int16_t)lvalue
;
159 *((int32_t *)dst
+ index
) = (int32_t)lvalue
;
162 *((int64_t *)dst
+ index
) = (int64_t)lvalue
;
169 unsigned long long lvalue
= (long long)value
;
170 lvalue
= MIN2(lvalue
, ((unsigned long long)1 << type
.width
) - 1);
173 *((uint8_t *)dst
+ index
) = (uint8_t)lvalue
;
176 *((uint16_t *)dst
+ index
) = (uint16_t)lvalue
;
179 *((uint32_t *)dst
+ index
) = (uint32_t)lvalue
;
182 *((uint64_t *)dst
+ index
) = (uint64_t)lvalue
;
193 random_elem(struct lp_type type
, void *dst
, unsigned index
)
196 assert(index
< type
.length
);
197 value
= (double)rand()/(double)RAND_MAX
;
203 unsigned long long mask
;
205 mask
= ((unsigned long long)1 << (type
.width
/ 2)) - 1;
207 mask
= ((unsigned long long)1 << (type
.width
- 1)) - 1;
209 mask
= ((unsigned long long)1 << type
.width
) - 1;
210 value
+= (double)(mask
& rand());
211 if (!type
.fixed
&& !type
.sign
&& type
.width
== 32) {
213 * rand only returns half the possible range
214 * XXX 64bit values...
217 value
+= (double)0x80000000;
224 write_elem(type
, dst
, index
, value
);
229 read_vec(struct lp_type type
, const void *src
, double *dst
)
232 for (i
= 0; i
< type
.length
; ++i
)
233 dst
[i
] = read_elem(type
, src
, i
);
238 write_vec(struct lp_type type
, void *dst
, const double *src
)
241 for (i
= 0; i
< type
.length
; ++i
)
242 write_elem(type
, dst
, i
, src
[i
]);
249 return (float)((double)rand()/(double)RAND_MAX
);
254 random_vec(struct lp_type type
, void *dst
)
257 for (i
= 0; i
< type
.length
; ++i
)
258 random_elem(type
, dst
, i
);
263 compare_vec_with_eps(struct lp_type type
, const void *res
, const void *ref
, double eps
)
266 eps
*= type
.floating
? 8.0 : 2.0;
267 for (i
= 0; i
< type
.length
; ++i
) {
268 double res_elem
= read_elem(type
, res
, i
);
269 double ref_elem
= read_elem(type
, ref
, i
);
270 double delta
= res_elem
- ref_elem
;
271 if (ref_elem
< -1.0 || ref_elem
> 1.0) {
285 compare_vec(struct lp_type type
, const void *res
, const void *ref
)
287 double eps
= lp_const_eps(type
);
288 return compare_vec_with_eps(type
, res
, ref
, eps
);
293 dump_vec(FILE *fp
, struct lp_type type
, const void *src
)
296 for (i
= 0; i
< type
.length
; ++i
) {
303 value
= *((const float *)src
+ i
);
306 value
= *((const double *)src
+ i
);
312 fprintf(fp
, "%f", value
);
315 if(type
.sign
&& !type
.norm
) {
320 value
= *((const int8_t *)src
+ i
);
324 value
= *((const int16_t *)src
+ i
);
328 value
= *((const int32_t *)src
+ i
);
332 value
= *((const int64_t *)src
+ i
);
340 fprintf(fp
, format
, value
);
343 unsigned long long value
;
347 value
= *((const uint8_t *)src
+ i
);
348 format
= type
.norm
? "%2x" : "%4llu";
351 value
= *((const uint16_t *)src
+ i
);
352 format
= type
.norm
? "%4x" : "%6llx";
355 value
= *((const uint32_t *)src
+ i
);
356 format
= type
.norm
? "%8x" : "%11llx";
359 value
= *((const uint64_t *)src
+ i
);
360 format
= type
.norm
? "%16x" : "%21llx";
367 fprintf(fp
, format
, value
);
374 int main(int argc
, char **argv
)
376 unsigned verbose
= 0;
378 unsigned long n
= 1000;
381 boolean single
= FALSE
;
385 fpstate
= util_fpstate_get();
386 util_fpstate_set_denorms_to_zero(fpstate
);
388 if (!lp_build_init())
391 for(i
= 1; i
< argc
; ++i
) {
392 if(strcmp(argv
[i
], "-v") == 0)
394 else if(strcmp(argv
[i
], "-s") == 0)
396 else if(strcmp(argv
[i
], "-o") == 0)
397 fp
= fopen(argv
[++i
], "wt");
404 gallivm_debug
|= GALLIVM_DEBUG_IR
;
405 gallivm_debug
|= GALLIVM_DEBUG_ASM
;
410 /* Warm up the caches */
411 test_some(0, NULL
, 100);
413 write_tsv_header(fp
);
417 success
= test_single(verbose
, fp
);
419 success
= test_some(verbose
, fp
, n
);
421 success
= test_all(verbose
, fp
);
428 return success
? 0 : 1;