src/gallium/drivers/llvmpipe/lp_test_arit.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2011 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 #include <limits.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32
  33 #include "util/u_pointer.h"
  34 #include "util/u_memory.h"
  35 #include "util/u_math.h"
  36
  37 #include "gallivm/lp_bld.h"
  38 #include "gallivm/lp_bld_init.h"
  39 #include "gallivm/lp_bld_arit.h"
  40
  41 #include "lp_test.h"
  42
  43
  44 void
  45 write_tsv_header(FILE *fp)
  46 {
  47    fprintf(fp,
  48            "result\t"
  49            "format\n");
  50
  51    fflush(fp);
  52 }
  53
  54
  55 typedef float (*unary_func_t)(float);
  56
  57
  58 /**
  59  * Describe a test case of one unary function.
  60  */
  61 struct unary_test_t
  62 {
  63    /*
  64     * Test name -- name of the mathematical function under test.
  65     */
  66
  67    const char *name;
  68
  69    LLVMValueRef
  70    (*builder)(struct lp_build_context *bld, LLVMValueRef a);
  71
  72    /*
  73     * Reference (pure-C) function.
  74     */
  75    float
  76    (*ref)(float a);
  77
  78    /*
  79     * Test values.
  80     */
  81    const float *values;
  82    unsigned num_values;
  83 };
  84
  85
  86 const float exp2_values[] = {
  87    -60,
  88    -4,
  89    -2,
  90    -1,
  91    -1e-007,
  92    0,
  93    1e-007,
  94    1,
  95    2,
  96    4,
  97    60
  98 };
  99
 100
 101 const float log2_values[] = {
 102 #if 0
 103    /*
 104     * Smallest denormalized number; meant just for experimentation, but not
 105     * validation.
 106     */
 107    1.4012984643248171e-45,
 108 #endif
 109    1e-007,
 110    0.5,
 111    1,
 112    2,
 113    4,
 114    100000,
 115    1e+018
 116 };
 117
 118
 119 static float rsqrtf(float x)
 120 {
 121    return 1.0/sqrt(x);
 122 }
 123
 124
 125 const float rsqrt_values[] = {
 126    -1, -1e-007,
 127    1e-007, 1,
 128    -4, -1,
 129    1, 4,
 130    -1e+035, -100000,
 131    100000, 1e+035,
 132 };
 133
 134
 135 const float sincos_values[] = {
 136    -5*M_PI/4,
 137    -4*M_PI/4,
 138    -4*M_PI/4,
 139    -3*M_PI/4,
 140    -2*M_PI/4,
 141    -1*M_PI/4,
 142     1*M_PI/4,
 143     2*M_PI/4,
 144     3*M_PI/4,
 145     4*M_PI/4,
 146     5*M_PI/4,
 147 };
 148
 149
 150 /*
 151  * Unary test cases.
 152  */
 153
 154 static const struct unary_test_t unary_tests[] = {
 155    {"exp2", &lp_build_exp2, &exp2f, exp2_values, Elements(exp2_values)},
 156    {"log2", &lp_build_log2, &log2f, log2_values, Elements(log2_values)},
 157    {"exp", &lp_build_exp, &expf, exp2_values, Elements(exp2_values)},
 158    {"log", &lp_build_log, &logf, log2_values, Elements(log2_values)},
 159    {"rsqrt", &lp_build_rsqrt, &rsqrtf, rsqrt_values, Elements(rsqrt_values)},
 160    {"sin", &lp_build_sin, &sinf, sincos_values, Elements(sincos_values)},
 161    {"cos", &lp_build_cos, &cosf, sincos_values, Elements(sincos_values)},
 162 };
 163
 164
 165 /*
 166  * Build LLVM function that exercises the unary operator builder.
 167  */
 168 static LLVMValueRef
 169 build_unary_test_func(struct gallivm_state *gallivm,
 170                       LLVMModuleRef module,
 171                       LLVMContextRef context,
 172                       const struct unary_test_t *test)
 173 {
 174    LLVMTypeRef i32t = LLVMInt32TypeInContext(context);
 175    LLVMTypeRef f32t = LLVMFloatTypeInContext(context);
 176    LLVMTypeRef v4f32t = LLVMVectorType(f32t, 4);
 177    LLVMTypeRef args[1] = { f32t };
 178    LLVMValueRef func = LLVMAddFunction(module, test->name, LLVMFunctionType(f32t, args, Elements(args), 0));
 179    LLVMValueRef arg1 = LLVMGetParam(func, 0);
 180    LLVMBuilderRef builder = gallivm->builder;
 181    LLVMBasicBlockRef block = LLVMAppendBasicBlockInContext(context, func, "entry");
 182    LLVMValueRef index0 = LLVMConstInt(i32t, 0, 0);
 183    LLVMValueRef ret;
 184
 185    struct lp_build_context bld;
 186
 187    lp_build_context_init(&bld, gallivm, lp_float32_vec4_type());
 188
 189    LLVMSetFunctionCallConv(func, LLVMCCallConv);
 190
 191    LLVMPositionBuilderAtEnd(builder, block);
 192
 193    /* scalar to vector */
 194    arg1 = LLVMBuildInsertElement(builder, LLVMGetUndef(v4f32t), arg1, index0, "");
 195
 196    ret = test->builder(&bld, arg1);
 197
 198    /* vector to scalar */
 199    ret = LLVMBuildExtractElement(builder, ret, index0, "");
 200
 201    LLVMBuildRet(builder, ret);
 202    return func;
 203 }
 204
 205
 206 /*
 207  * Test one LLVM unary arithmetic builder function.
 208  */
 209 static boolean
 210 test_unary(struct gallivm_state *gallivm, unsigned verbose, FILE *fp, const struct unary_test_t *test)
 211 {
 212    LLVMModuleRef module = gallivm->module;
 213    LLVMValueRef test_func;
 214    LLVMExecutionEngineRef engine = gallivm->engine;
 215    LLVMContextRef context = gallivm->context;
 216    char *error = NULL;
 217    unary_func_t test_func_jit;
 218    boolean success = TRUE;
 219    int i;
 220
 221    test_func = build_unary_test_func(gallivm, module, context, test);
 222
 223    if (LLVMVerifyModule(module, LLVMPrintMessageAction, &error)) {
 224       printf("LLVMVerifyModule: %s\n", error);
 225       LLVMDumpModule(module);
 226       abort();
 227    }
 228    LLVMDisposeMessage(error);
 229
 230    test_func_jit = (unary_func_t) pointer_to_func(LLVMGetPointerToGlobal(engine, test_func));
 231
 232    for (i = 0; i < test->num_values; ++i) {
 233       float value = test->values[i];
 234       float ref = test->ref(value);
 235       float src = test_func_jit(value);
 236
 237       double error = fabs(src - ref);
 238       double precision = error ? -log2(error/fabs(ref)) : FLT_MANT_DIG;
 239
 240       bool pass = precision >= 20.0;
 241
 242       if (isnan(ref)) {
 243          continue;
 244       }
 245
 246       if (!pass || verbose) {
 247          printf("%s(%.9g): ref = %.9g, src = %.9g, precision = %f bits, %s\n",
 248                test->name, value, ref, src, precision,
 249                pass ? "PASS" : "FAIL");
 250       }
 251
 252       if (!pass) {
 253          success = FALSE;
 254       }
 255    }
 256
 257    LLVMFreeMachineCodeForFunction(engine, test_func);
 258
 259    return success;
 260 }
 261
 262
 263 boolean
 264 test_all(struct gallivm_state *gallivm, unsigned verbose, FILE *fp)
 265 {
 266    boolean success = TRUE;
 267    int i;
 268
 269    for (i = 0; i < Elements(unary_tests); ++i) {
 270       if (!test_unary(gallivm, verbose, fp, &unary_tests[i])) {
 271          success = FALSE;
 272       }
 273    }
 274
 275    return success;
 276 }
 277
 278
 279 boolean
 280 test_some(struct gallivm_state *gallivm, unsigned verbose, FILE *fp,
 281           unsigned long n)
 282 {
 283    /*
 284     * Not randomly generated test cases, so test all.
 285     */
 286
 287    return test_all(gallivm, verbose, fp);
 288 }
 289
 290
 291 boolean
 292 test_single(struct gallivm_state *gallivm, unsigned verbose, FILE *fp)
 293 {
 294    return TRUE;
 295 }