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 (at) 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 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 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 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 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 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 normalised 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 normalised 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 215 context = LLVMContextCreate(); 216 gallivm = gallivm_create("test_module", context); 217 218 func = add_conv_test(gallivm, src_type, num_srcs, dst_type, num_dsts); 219 220 gallivm_compile_module(gallivm); 221 222 conv_test_ptr = (conv_test_ptr_t)gallivm_jit_function(gallivm, func); 223 224 gallivm_free_ir(gallivm); 225 226 success = TRUE; 227 for(i = 0; i < n && success; ++i) { 228 unsigned src_stride = src_type.length*src_type.width/8; 229 unsigned dst_stride = dst_type.length*dst_type.width/8; 230 PIPE_ALIGN_VAR(LP_MIN_VECTOR_ALIGN) uint8_t src[LP_MAX_VECTOR_LENGTH*LP_MAX_VECTOR_LENGTH]; 231 PIPE_ALIGN_VAR(LP_MIN_VECTOR_ALIGN) uint8_t dst[LP_MAX_VECTOR_LENGTH*LP_MAX_VECTOR_LENGTH]; 232 double fref[LP_MAX_VECTOR_LENGTH*LP_MAX_VECTOR_LENGTH]; 233 uint8_t ref[LP_MAX_VECTOR_LENGTH*LP_MAX_VECTOR_LENGTH]; 234 int64_t start_counter = 0; 235 int64_t end_counter = 0; 236 237 for(j = 0; j < num_srcs; ++j) { 238 random_vec(src_type, src + j*src_stride); 239 read_vec(src_type, src + j*src_stride, fref + j*src_type.length); 240 } 241 242 for(j = 0; j < num_dsts; ++j) { 243 write_vec(dst_type, ref + j*dst_stride, fref + j*dst_type.length); 244 } 245 246 start_counter = rdtsc(); 247 conv_test_ptr(src, dst); 248 end_counter = rdtsc(); 249 250 cycles[i] = end_counter - start_counter; 251 252 for(j = 0; j < num_dsts; ++j) { 253 if(!compare_vec_with_eps(dst_type, dst + j*dst_stride, ref + j*dst_stride, eps)) 254 success = FALSE; 255 } 256 257 if (!success || verbose >= 3) { 258 if(verbose < 1) 259 dump_conv_types(stderr, src_type, dst_type); 260 if (success) { 261 fprintf(stderr, "PASS\n"); 262 } 263 else { 264 fprintf(stderr, "MISMATCH\n"); 265 } 266 267 for(j = 0; j < num_srcs; ++j) { 268 fprintf(stderr, " Src%u: ", j); 269 dump_vec(stderr, src_type, src + j*src_stride); 270 fprintf(stderr, "\n"); 271 } 272 273 #if 1 274 fprintf(stderr, " Ref: "); 275 for(j = 0; j < src_type.length*num_srcs; ++j) 276 fprintf(stderr, " %f", fref[j]); 277 fprintf(stderr, "\n"); 278 #endif 279 280 for(j = 0; j < num_dsts; ++j) { 281 fprintf(stderr, " Dst%u: ", j); 282 dump_vec(stderr, dst_type, dst + j*dst_stride); 283 fprintf(stderr, "\n"); 284 285 fprintf(stderr, " Ref%u: ", j); 286 dump_vec(stderr, dst_type, ref + j*dst_stride); 287 fprintf(stderr, "\n"); 288 } 289 } 290 } 291 292 /* 293 * Unfortunately the output of cycle counter is not very reliable as it comes 294 * -- sometimes we get outliers (due IRQs perhaps?) which are 295 * better removed to avoid random or biased data. 296 */ 297 { 298 double sum = 0.0, sum2 = 0.0; 299 double avg, std; 300 unsigned m; 301 302 for(i = 0; i < n; ++i) { 303 sum += cycles[i]; 304 sum2 += cycles[i]*cycles[i]; 305 } 306 307 avg = sum/n; 308 std = sqrtf((sum2 - n*avg*avg)/n); 309 310 m = 0; 311 sum = 0.0; 312 for(i = 0; i < n; ++i) { 313 if(fabs(cycles[i] - avg) <= 4.0*std) { 314 sum += cycles[i]; 315 ++m; 316 } 317 } 318 319 cycles_avg = sum/m; 320 321 } 322 323 if(fp) 324 write_tsv_row(fp, src_type, dst_type, cycles_avg, success); 325 326 gallivm_destroy(gallivm); 327 LLVMContextDispose(context); 328 329 return success; 330 } 331 332 333 const struct lp_type conv_types[] = { 334 /* float, fixed, sign, norm, width, len */ 335 336 /* Float */ 337 { TRUE, FALSE, TRUE, TRUE, 32, 4 }, 338 { TRUE, FALSE, TRUE, FALSE, 32, 4 }, 339 { TRUE, FALSE, FALSE, TRUE, 32, 4 }, 340 { TRUE, FALSE, FALSE, FALSE, 32, 4 }, 341 342 { TRUE, FALSE, TRUE, TRUE, 32, 8 }, 343 { TRUE, FALSE, TRUE, FALSE, 32, 8 }, 344 { TRUE, FALSE, FALSE, TRUE, 32, 8 }, 345 { TRUE, FALSE, FALSE, FALSE, 32, 8 }, 346 347 /* Fixed */ 348 { FALSE, TRUE, TRUE, TRUE, 32, 4 }, 349 { FALSE, TRUE, TRUE, FALSE, 32, 4 }, 350 { FALSE, TRUE, FALSE, TRUE, 32, 4 }, 351 { FALSE, TRUE, FALSE, FALSE, 32, 4 }, 352 353 { FALSE, TRUE, TRUE, TRUE, 32, 8 }, 354 { FALSE, TRUE, TRUE, FALSE, 32, 8 }, 355 { FALSE, TRUE, FALSE, TRUE, 32, 8 }, 356 { FALSE, TRUE, FALSE, FALSE, 32, 8 }, 357 358 /* Integer */ 359 { FALSE, FALSE, TRUE, TRUE, 32, 4 }, 360 { FALSE, FALSE, TRUE, FALSE, 32, 4 }, 361 { FALSE, FALSE, FALSE, TRUE, 32, 4 }, 362 { FALSE, FALSE, FALSE, FALSE, 32, 4 }, 363 364 { FALSE, FALSE, TRUE, TRUE, 32, 8 }, 365 { FALSE, FALSE, TRUE, FALSE, 32, 8 }, 366 { FALSE, FALSE, FALSE, TRUE, 32, 8 }, 367 { FALSE, FALSE, FALSE, FALSE, 32, 8 }, 368 369 { FALSE, FALSE, TRUE, TRUE, 16, 8 }, 370 { FALSE, FALSE, TRUE, FALSE, 16, 8 }, 371 { FALSE, FALSE, FALSE, TRUE, 16, 8 }, 372 { FALSE, FALSE, FALSE, FALSE, 16, 8 }, 373 374 { FALSE, FALSE, TRUE, TRUE, 8, 16 }, 375 { FALSE, FALSE, TRUE, FALSE, 8, 16 }, 376 { FALSE, FALSE, FALSE, TRUE, 8, 16 }, 377 { FALSE, FALSE, FALSE, FALSE, 8, 16 }, 378 379 { FALSE, FALSE, TRUE, TRUE, 8, 4 }, 380 { FALSE, FALSE, TRUE, FALSE, 8, 4 }, 381 { FALSE, FALSE, FALSE, TRUE, 8, 4 }, 382 { FALSE, FALSE, FALSE, FALSE, 8, 4 }, 383 384 { FALSE, FALSE, FALSE, TRUE, 8, 8 }, 385 }; 386 387 388 const unsigned num_types = ARRAY_SIZE(conv_types); 389 390 391 boolean 392 test_all(unsigned verbose, FILE *fp) 393 { 394 const struct lp_type *src_type; 395 const struct lp_type *dst_type; 396 boolean success = TRUE; 397 int error_count = 0; 398 399 for(src_type = conv_types; src_type < &conv_types[num_types]; ++src_type) { 400 for(dst_type = conv_types; dst_type < &conv_types[num_types]; ++dst_type) { 401 402 if(src_type == dst_type) 403 continue; 404 405 if(!test_one(verbose, fp, *src_type, *dst_type)){ 406 success = FALSE; 407 ++error_count; 408 } 409 } 410 } 411 412 fprintf(stderr, "%d failures\n", error_count); 413 414 return success; 415 } 416 417 418 boolean 419 test_some(unsigned verbose, FILE *fp, 420 unsigned long n) 421 { 422 const struct lp_type *src_type; 423 const struct lp_type *dst_type; 424 unsigned long i; 425 boolean success = TRUE; 426 427 for(i = 0; i < n; ++i) { 428 src_type = &conv_types[rand() % num_types]; 429 430 do { 431 dst_type = &conv_types[rand() % num_types]; 432 } while (src_type == dst_type || src_type->norm != dst_type->norm); 433 434 if(!test_one(verbose, fp, *src_type, *dst_type)) 435 success = FALSE; 436 } 437 438 return success; 439 } 440 441 442 boolean 443 test_single(unsigned verbose, FILE *fp) 444 { 445 /* float, fixed, sign, norm, width, len */ 446 struct lp_type f32x4_type = 447 { TRUE, FALSE, TRUE, TRUE, 32, 4 }; 448 struct lp_type ub8x4_type = 449 { FALSE, FALSE, FALSE, TRUE, 8, 16 }; 450 451 boolean success; 452 453 success = test_one(verbose, fp, f32x4_type, ub8x4_type); 454 455 return success; 456 } 457
