1 /**************************************************************************
2 *
3 * Copyright 2009 VMware, Inc.
4 * All Rights Reserved.
5 *
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:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
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.
25 *
26 **************************************************************************/
27
28
29 /**
30 * @file
31 * Unit tests for type conversion.
32 *
33 * @author Jose Fonseca <jfonseca@vmware.com>
34 */
35
36
37 #include "util/u_pointer.h"
38 #include "gallivm/lp_bld_init.h"
39 #include "gallivm/lp_bld_type.h"
40 #include "gallivm/lp_bld_const.h"
41 #include "gallivm/lp_bld_conv.h"
42 #include "gallivm/lp_bld_debug.h"
43 #include "lp_test.h"
44
45
46 typedef void (*conv_test_ptr_t)(const void *src, const void *dst);
47
48
49 void
write_tsv_header(FILE * fp)50 write_tsv_header(FILE *fp)
51 {
52 fprintf(fp,
53 "result\t"
54 "cycles_per_channel\t"
55 "src_type\t"
56 "dst_type\n");
57
58 fflush(fp);
59 }
60
61
62 static void
write_tsv_row(FILE * fp,struct lp_type src_type,struct lp_type dst_type,double cycles,boolean success)63 write_tsv_row(FILE *fp,
64 struct lp_type src_type,
65 struct lp_type dst_type,
66 double cycles,
67 boolean success)
68 {
69 fprintf(fp, "%s\t", success ? "pass" : "fail");
70
71 fprintf(fp, "%.1f\t", cycles / MAX2(src_type.length, dst_type.length));
72
73 dump_type(fp, src_type);
74 fprintf(fp, "\t");
75
76 dump_type(fp, dst_type);
77 fprintf(fp, "\n");
78
79 fflush(fp);
80 }
81
82
83 static void
dump_conv_types(FILE * fp,struct lp_type src_type,struct lp_type dst_type)84 dump_conv_types(FILE *fp,
85 struct lp_type src_type,
86 struct lp_type dst_type)
87 {
88 fprintf(fp, "src_type=");
89 dump_type(fp, src_type);
90
91 fprintf(fp, " dst_type=");
92 dump_type(fp, dst_type);
93
94 fprintf(fp, " ...\n");
95 fflush(fp);
96 }
97
98
99 static LLVMValueRef
add_conv_test(struct gallivm_state * gallivm,struct lp_type src_type,unsigned num_srcs,struct lp_type dst_type,unsigned num_dsts)100 add_conv_test(struct gallivm_state *gallivm,
101 struct lp_type src_type, unsigned num_srcs,
102 struct lp_type dst_type, unsigned num_dsts)
103 {
104 LLVMModuleRef module = gallivm->module;
105 LLVMContextRef context = gallivm->context;
106 LLVMBuilderRef builder = gallivm->builder;
107 LLVMTypeRef args[2];
108 LLVMValueRef func;
109 LLVMValueRef src_ptr;
110 LLVMValueRef dst_ptr;
111 LLVMBasicBlockRef block;
112 LLVMValueRef src[LP_MAX_VECTOR_LENGTH];
113 LLVMValueRef dst[LP_MAX_VECTOR_LENGTH];
114 unsigned i;
115
116 args[0] = LLVMPointerType(lp_build_vec_type(gallivm, src_type), 0);
117 args[1] = LLVMPointerType(lp_build_vec_type(gallivm, dst_type), 0);
118
119 func = LLVMAddFunction(module, "test",
120 LLVMFunctionType(LLVMVoidTypeInContext(context),
121 args, 2, 0));
122 LLVMSetFunctionCallConv(func, LLVMCCallConv);
123 src_ptr = LLVMGetParam(func, 0);
124 dst_ptr = LLVMGetParam(func, 1);
125
126 block = LLVMAppendBasicBlockInContext(context, func, "entry");
127 LLVMPositionBuilderAtEnd(builder, block);
128
129 for(i = 0; i < num_srcs; ++i) {
130 LLVMValueRef index = LLVMConstInt(LLVMInt32TypeInContext(context), i, 0);
131 LLVMValueRef ptr = LLVMBuildGEP(builder, src_ptr, &index, 1, "");
132 src[i] = LLVMBuildLoad(builder, ptr, "");
133 }
134
135 lp_build_conv(gallivm, src_type, dst_type, src, num_srcs, dst, num_dsts);
136
137 for(i = 0; i < num_dsts; ++i) {
138 LLVMValueRef index = LLVMConstInt(LLVMInt32TypeInContext(context), i, 0);
139 LLVMValueRef ptr = LLVMBuildGEP(builder, dst_ptr, &index, 1, "");
140 LLVMBuildStore(builder, dst[i], ptr);
141 }
142
143 LLVMBuildRetVoid(builder);
144
145 gallivm_verify_function(gallivm, func);
146
147 return func;
148 }
149
150
151 PIPE_ALIGN_STACK
152 static boolean
test_one(unsigned verbose,FILE * fp,struct lp_type src_type,struct lp_type dst_type)153 test_one(unsigned verbose,
154 FILE *fp,
155 struct lp_type src_type,
156 struct lp_type dst_type)
157 {
158 LLVMContextRef context;
159 struct gallivm_state *gallivm;
160 LLVMValueRef func = NULL;
161 conv_test_ptr_t conv_test_ptr;
162 boolean success;
163 const unsigned n = LP_TEST_NUM_SAMPLES;
164 int64_t cycles[LP_TEST_NUM_SAMPLES];
165 double cycles_avg = 0.0;
166 unsigned num_srcs;
167 unsigned num_dsts;
168 double eps;
169 unsigned i, j;
170
171 if ((src_type.width >= dst_type.width && src_type.length > dst_type.length) ||
172 (src_type.width <= dst_type.width && src_type.length < dst_type.length)) {
173 return TRUE;
174 }
175
176 /* Known failures
177 * - fixed point 32 -> float 32
178 * - float 32 -> signed normalized integer 32
179 */
180 if ((src_type.floating && !dst_type.floating && dst_type.sign && dst_type.norm && src_type.width == dst_type.width) ||
181 (!src_type.floating && dst_type.floating && src_type.fixed && src_type.width == dst_type.width)) {
182 return TRUE;
183 }
184
185 /* Known failures
186 * - fixed point 32 -> float 32
187 * - float 32 -> signed normalized integer 32
188 */
189 if ((src_type.floating && !dst_type.floating && dst_type.sign && dst_type.norm && src_type.width == dst_type.width) ||
190 (!src_type.floating && dst_type.floating && src_type.fixed && src_type.width == dst_type.width)) {
191 return TRUE;
192 }
193
194 if(verbose >= 1)
195 dump_conv_types(stderr, src_type, dst_type);
196
197 if (src_type.length > dst_type.length) {
198 num_srcs = 1;
199 num_dsts = src_type.length/dst_type.length;
200 }
201 else if (src_type.length < dst_type.length) {
202 num_dsts = 1;
203 num_srcs = dst_type.length/src_type.length;
204 }
205 else {
206 num_dsts = 1;
207 num_srcs = 1;
208 }
209
210 /* We must not loose or gain channels. Only precision */
211 assert(src_type.length * num_srcs == dst_type.length * num_dsts);
212
213 eps = MAX2(lp_const_eps(src_type), lp_const_eps(dst_type));
214 if (dst_type.norm && dst_type.sign && src_type.sign && !src_type.floating) {
215 /*
216 * This is quite inaccurate due to shift being used.
217 * I don't think it's possible to hit such conversions with
218 * llvmpipe though.
219 */
220 eps *= 2;
221 }
222
223 context = LLVMContextCreate();
224 #if LLVM_VERSION_MAJOR >= 15
225 LLVMContextSetOpaquePointers(context, false);
226 #endif
227 gallivm = gallivm_create("test_module", context, NULL);
228
229 func = add_conv_test(gallivm, src_type, num_srcs, dst_type, num_dsts);
230
231 gallivm_compile_module(gallivm);
232
233 conv_test_ptr = (conv_test_ptr_t)gallivm_jit_function(gallivm, func);
234
235 gallivm_free_ir(gallivm);
236
237 success = TRUE;
238 for(i = 0; i < n && success; ++i) {
239 unsigned src_stride = src_type.length*src_type.width/8;
240 unsigned dst_stride = dst_type.length*dst_type.width/8;
241 alignas(LP_MIN_VECTOR_ALIGN) uint8_t src[LP_MAX_VECTOR_LENGTH*LP_MAX_VECTOR_LENGTH];
242 alignas(LP_MIN_VECTOR_ALIGN) uint8_t dst[LP_MAX_VECTOR_LENGTH*LP_MAX_VECTOR_LENGTH];
243 double fref[LP_MAX_VECTOR_LENGTH*LP_MAX_VECTOR_LENGTH];
244 uint8_t ref[LP_MAX_VECTOR_LENGTH*LP_MAX_VECTOR_LENGTH];
245 int64_t start_counter = 0;
246 int64_t end_counter = 0;
247
248 for(j = 0; j < num_srcs; ++j) {
249 random_vec(src_type, src + j*src_stride);
250 read_vec(src_type, src + j*src_stride, fref + j*src_type.length);
251 }
252
253 for(j = 0; j < num_dsts; ++j) {
254 write_vec(dst_type, ref + j*dst_stride, fref + j*dst_type.length);
255 }
256
257 start_counter = rdtsc();
258 conv_test_ptr(src, dst);
259 end_counter = rdtsc();
260
261 cycles[i] = end_counter - start_counter;
262
263 for(j = 0; j < num_dsts; ++j) {
264 if(!compare_vec_with_eps(dst_type, dst + j*dst_stride, ref + j*dst_stride, eps))
265 success = FALSE;
266 }
267
268 if (!success || verbose >= 3) {
269 if(verbose < 1)
270 dump_conv_types(stderr, src_type, dst_type);
271 if (success) {
272 fprintf(stderr, "PASS\n");
273 }
274 else {
275 fprintf(stderr, "MISMATCH\n");
276 }
277
278 for(j = 0; j < num_srcs; ++j) {
279 fprintf(stderr, " Src%u: ", j);
280 dump_vec(stderr, src_type, src + j*src_stride);
281 fprintf(stderr, "\n");
282 }
283
284 #if 1
285 fprintf(stderr, " Ref: ");
286 for(j = 0; j < src_type.length*num_srcs; ++j)
287 fprintf(stderr, " %f", fref[j]);
288 fprintf(stderr, "\n");
289 #endif
290
291 for(j = 0; j < num_dsts; ++j) {
292 fprintf(stderr, " Dst%u: ", j);
293 dump_vec(stderr, dst_type, dst + j*dst_stride);
294 fprintf(stderr, "\n");
295
296 fprintf(stderr, " Ref%u: ", j);
297 dump_vec(stderr, dst_type, ref + j*dst_stride);
298 fprintf(stderr, "\n");
299 }
300 }
301 }
302
303 /*
304 * Unfortunately the output of cycle counter is not very reliable as it comes
305 * -- sometimes we get outliers (due IRQs perhaps?) which are
306 * better removed to avoid random or biased data.
307 */
308 {
309 double sum = 0.0, sum2 = 0.0;
310 double avg, std;
311 unsigned m;
312
313 for(i = 0; i < n; ++i) {
314 sum += cycles[i];
315 sum2 += cycles[i]*cycles[i];
316 }
317
318 avg = sum/n;
319 std = sqrtf((sum2 - n*avg*avg)/n);
320
321 m = 0;
322 sum = 0.0;
323 for(i = 0; i < n; ++i) {
324 if(fabs(cycles[i] - avg) <= 4.0*std) {
325 sum += cycles[i];
326 ++m;
327 }
328 }
329
330 cycles_avg = sum/m;
331
332 }
333
334 if(fp)
335 write_tsv_row(fp, src_type, dst_type, cycles_avg, success);
336
337 gallivm_destroy(gallivm);
338 LLVMContextDispose(context);
339
340 return success;
341 }
342
343
344 const struct lp_type conv_types[] = {
345 /* float, fixed, sign, norm, width, len */
346
347 /* Float */
348 { TRUE, FALSE, TRUE, TRUE, 32, 4 },
349 { TRUE, FALSE, TRUE, FALSE, 32, 4 },
350 { TRUE, FALSE, FALSE, TRUE, 32, 4 },
351 { TRUE, FALSE, FALSE, FALSE, 32, 4 },
352
353 { TRUE, FALSE, TRUE, TRUE, 32, 8 },
354 { TRUE, FALSE, TRUE, FALSE, 32, 8 },
355 { TRUE, FALSE, FALSE, TRUE, 32, 8 },
356 { TRUE, FALSE, FALSE, FALSE, 32, 8 },
357
358 /* Fixed */
359 { FALSE, TRUE, TRUE, TRUE, 32, 4 },
360 { FALSE, TRUE, TRUE, FALSE, 32, 4 },
361 { FALSE, TRUE, FALSE, TRUE, 32, 4 },
362 { FALSE, TRUE, FALSE, FALSE, 32, 4 },
363
364 { FALSE, TRUE, TRUE, TRUE, 32, 8 },
365 { FALSE, TRUE, TRUE, FALSE, 32, 8 },
366 { FALSE, TRUE, FALSE, TRUE, 32, 8 },
367 { FALSE, TRUE, FALSE, FALSE, 32, 8 },
368
369 /* Integer */
370 { FALSE, FALSE, TRUE, TRUE, 32, 4 },
371 { FALSE, FALSE, TRUE, FALSE, 32, 4 },
372 { FALSE, FALSE, FALSE, TRUE, 32, 4 },
373 { FALSE, FALSE, FALSE, FALSE, 32, 4 },
374
375 { FALSE, FALSE, TRUE, TRUE, 32, 8 },
376 { FALSE, FALSE, TRUE, FALSE, 32, 8 },
377 { FALSE, FALSE, FALSE, TRUE, 32, 8 },
378 { FALSE, FALSE, FALSE, FALSE, 32, 8 },
379
380 { FALSE, FALSE, TRUE, TRUE, 16, 8 },
381 { FALSE, FALSE, TRUE, FALSE, 16, 8 },
382 { FALSE, FALSE, FALSE, TRUE, 16, 8 },
383 { FALSE, FALSE, FALSE, FALSE, 16, 8 },
384
385 { FALSE, FALSE, TRUE, TRUE, 8, 16 },
386 { FALSE, FALSE, TRUE, FALSE, 8, 16 },
387 { FALSE, FALSE, FALSE, TRUE, 8, 16 },
388 { FALSE, FALSE, FALSE, FALSE, 8, 16 },
389
390 { FALSE, FALSE, TRUE, TRUE, 8, 4 },
391 { FALSE, FALSE, TRUE, FALSE, 8, 4 },
392 { FALSE, FALSE, FALSE, TRUE, 8, 4 },
393 { FALSE, FALSE, FALSE, FALSE, 8, 4 },
394
395 { FALSE, FALSE, FALSE, TRUE, 8, 8 },
396 };
397
398
399 const unsigned num_types = ARRAY_SIZE(conv_types);
400
401
402 boolean
test_all(unsigned verbose,FILE * fp)403 test_all(unsigned verbose, FILE *fp)
404 {
405 const struct lp_type *src_type;
406 const struct lp_type *dst_type;
407 boolean success = TRUE;
408 int error_count = 0;
409
410 for(src_type = conv_types; src_type < &conv_types[num_types]; ++src_type) {
411 for(dst_type = conv_types; dst_type < &conv_types[num_types]; ++dst_type) {
412
413 if(src_type == dst_type)
414 continue;
415
416 if(!test_one(verbose, fp, *src_type, *dst_type)){
417 success = FALSE;
418 ++error_count;
419 }
420 }
421 }
422
423 fprintf(stderr, "%d failures\n", error_count);
424
425 return success;
426 }
427
428
429 boolean
test_some(unsigned verbose,FILE * fp,unsigned long n)430 test_some(unsigned verbose, FILE *fp,
431 unsigned long n)
432 {
433 const struct lp_type *src_type;
434 const struct lp_type *dst_type;
435 unsigned long i;
436 boolean success = TRUE;
437
438 for(i = 0; i < n; ++i) {
439 src_type = &conv_types[rand() % num_types];
440
441 do {
442 dst_type = &conv_types[rand() % num_types];
443 } while (src_type == dst_type || src_type->norm != dst_type->norm);
444
445 if(!test_one(verbose, fp, *src_type, *dst_type))
446 success = FALSE;
447 }
448
449 return success;
450 }
451
452
453 boolean
test_single(unsigned verbose,FILE * fp)454 test_single(unsigned verbose, FILE *fp)
455 {
456 /* float, fixed, sign, norm, width, len */
457 struct lp_type f32x4_type =
458 { TRUE, FALSE, TRUE, TRUE, 32, 4 };
459 struct lp_type ub8x4_type =
460 { FALSE, FALSE, FALSE, TRUE, 8, 16 };
461
462 boolean success;
463
464 success = test_one(verbose, fp, f32x4_type, ub8x4_type);
465
466 return success;
467 }
468