src/mesa/math/m_debug_norm.c

   1 /* $Id: m_debug_norm.c,v 1.6 2001/03/29 06:46:27 gareth Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  3.5
   6  *
   7  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  * Authors:
  27  *    Gareth Hughes <gareth@valinux.com>
  28  */
  29
  30 #include "glheader.h"
  31 #include "context.h"
  32 #include "macros.h"
  33 #include "mem.h"
  34 #include "mmath.h"
  35
  36 #include "m_matrix.h"
  37 #include "m_xform.h"
  38
  39 #include "m_debug.h"
  40 #include "m_debug_util.h"
  41
  42
  43 #ifdef DEBUG  /* This code only used for debugging */
  44
  45
  46 static int m_norm_identity[16] = {
  47    ONE, NIL, NIL, NIL,
  48    NIL, ONE, NIL, NIL,
  49    NIL, NIL, ONE, NIL,
  50    NIL, NIL, NIL, NIL
  51 };
  52 static int m_norm_general[16] = {
  53    VAR, VAR, VAR, NIL,
  54    VAR, VAR, VAR, NIL,
  55    VAR, VAR, VAR, NIL,
  56    NIL, NIL, NIL, NIL
  57 };
  58 static int m_norm_no_rot[16] = {
  59    VAR, NIL, NIL, NIL,
  60    NIL, VAR, NIL, NIL,
  61    NIL, NIL, VAR, NIL,
  62    NIL, NIL, NIL, NIL
  63 };
  64 static int *norm_templates[8] = {
  65    m_norm_no_rot,
  66    m_norm_no_rot,
  67    m_norm_no_rot,
  68    m_norm_general,
  69    m_norm_general,
  70    m_norm_general,
  71    m_norm_identity,
  72    m_norm_identity
  73 };
  74 static int norm_types[8] = {
  75    NORM_TRANSFORM_NO_ROT,
  76    NORM_TRANSFORM_NO_ROT | NORM_RESCALE,
  77    NORM_TRANSFORM_NO_ROT | NORM_NORMALIZE,
  78    NORM_TRANSFORM,
  79    NORM_TRANSFORM | NORM_RESCALE,
  80    NORM_TRANSFORM | NORM_NORMALIZE,
  81    NORM_RESCALE,
  82    NORM_NORMALIZE
  83 };
  84 static int norm_scale_types[8] = {               /*  rescale factor          */
  85    NIL,                                          /*  NIL disables rescaling  */
  86    VAR,
  87    NIL,
  88    NIL,
  89    VAR,
  90    NIL,
  91    VAR,
  92    NIL
  93 };
  94 static int norm_normalize_types[8] = {           /*  normalizing ?? (no = 0) */
  95    0,
  96    0,
  97    1,
  98    0,
  99    0,
 100    1,
 101    0,
 102    1
 103 };
 104 static char *norm_strings[8] = {
 105    "NORM_TRANSFORM_NO_ROT",
 106    "NORM_TRANSFORM_NO_ROT | NORM_RESCALE",
 107    "NORM_TRANSFORM_NO_ROT | NORM_NORMALIZE",
 108    "NORM_TRANSFORM",
 109    "NORM_TRANSFORM | NORM_RESCALE",
 110    "NORM_TRANSFORM | NORM_NORMALIZE",
 111    "NORM_RESCALE",
 112    "NORM_NORMALIZE"
 113 };
 114
 115
 116 /* ================================================================
 117  * Reference transformations
 118  */
 119
 120 static void ref_norm_transform_rescale( const GLmatrix *mat,
 121                                         GLfloat scale,
 122                                         const GLvector3f *in,
 123                                         const GLfloat *lengths,
 124                                         const GLubyte mask[],
 125                                         GLvector3f *dest )
 126 {
 127    GLuint i;
 128    const GLfloat *s = in->start;
 129    const GLfloat *m = mat->inv;
 130    GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
 131
 132    (void) mask;
 133    (void) lengths;
 134
 135    for ( i = 0 ; i < in->count ; i++ ) {
 136       GLfloat t[3];
 137
 138       TRANSFORM_NORMAL( t, s, m );
 139       SCALE_SCALAR_3V( out[i], scale, t );
 140
 141       s = (GLfloat *)((char *)s + in->stride);
 142    }
 143 }
 144
 145 static void ref_norm_transform_normalize( const GLmatrix *mat,
 146                                           GLfloat scale,
 147                                           const GLvector3f *in,
 148                                           const GLfloat *lengths,
 149                                           const GLubyte mask[],
 150                                           GLvector3f *dest )
 151 {
 152    GLuint i;
 153    const GLfloat *s = in->start;
 154    const GLfloat *m = mat->inv;
 155    GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
 156
 157    (void) mask;
 158
 159    for ( i = 0 ; i < in->count ; i++ ) {
 160       GLfloat t[3];
 161
 162       TRANSFORM_NORMAL( t, s, m );
 163
 164       if ( !lengths ) {
 165          GLfloat len = LEN_SQUARED_3FV( t );
 166          if ( len > 1e-20 ) {
 167             /* Hmmm, don't know how we could test the precalculated
 168              * length case...
 169              */
 170             scale = 1.0 / sqrt( len );
 171             SCALE_SCALAR_3V( out[i], scale, t );
 172          } else {
 173             out[i][0] = out[i][1] = out[i][2] = 0;
 174          }
 175       } else {
 176          scale = lengths[i];;
 177          SCALE_SCALAR_3V( out[i], scale, t );
 178       }
 179
 180       s = (GLfloat *)((char *)s + in->stride);
 181    }
 182 }
 183
 184
 185 /* ================================================================
 186  * Normal transformation tests
 187  */
 188
 189 static int test_norm_function( normal_func func, int mtype, long *cycles )
 190 {
 191    GLvector3f source[1], dest[1], dest2[1], ref[1], ref2[1];
 192    GLmatrix mat[1];
 193    GLfloat s[TEST_COUNT][5], d[TEST_COUNT][3], r[TEST_COUNT][3];
 194    GLfloat d2[TEST_COUNT][3], r2[TEST_COUNT][3], length[TEST_COUNT];
 195    GLfloat scale;
 196    GLfloat *m;
 197    int i, j;
 198 #ifdef  RUN_DEBUG_BENCHMARK
 199    int cycle_i;         /* the counter for the benchmarks we run */
 200 #endif
 201
 202    (void) cycles;
 203
 204    mat->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
 205    mat->inv = m = mat->m;
 206
 207    init_matrix( m );
 208
 209    scale = 1.0F + rnd () * norm_scale_types[mtype];
 210
 211    for ( i = 0 ; i < 4 ; i++ ) {
 212       for ( j = 0 ; j < 4 ; j++ ) {
 213          switch ( norm_templates[mtype][i * 4 + j] ) {
 214          case NIL:
 215             m[j * 4 + i] = 0.0;
 216             break;
 217          case ONE:
 218             m[j * 4 + i] = 1.0;
 219             break;
 220          case NEG:
 221             m[j * 4 + i] = -1.0;
 222             break;
 223          case VAR:
 224             break;
 225          default:
 226             abort();
 227          }
 228       }
 229    }
 230
 231    for ( i = 0 ; i < TEST_COUNT ; i++ ) {
 232       ASSIGN_3V( d[i],  0.0, 0.0, 0.0 );
 233       ASSIGN_3V( s[i],  0.0, 0.0, 0.0 );
 234       ASSIGN_3V( d2[i], 0.0, 0.0, 0.0 );
 235       for ( j = 0 ; j < 3 ; j++ )
 236          s[i][j] = rnd();
 237       length[i] = 1 / sqrt( LEN_SQUARED_3FV( s[i] ) );
 238    }
 239
 240    source->data = (GLfloat(*)[3])s;
 241    source->start = (GLfloat *)s;
 242    source->count = TEST_COUNT;
 243    source->stride = sizeof(s[0]);
 244    source->flags = 0;
 245
 246    dest->data = (GLfloat(*)[3])d;
 247    dest->start = (GLfloat *)d;
 248    dest->count = TEST_COUNT;
 249    dest->stride = sizeof(float[3]);
 250    dest->flags = 0;
 251
 252    dest2->data = (GLfloat(*)[3])d2;
 253    dest2->start = (GLfloat *)d2;
 254    dest2->count = TEST_COUNT;
 255    dest2->stride = sizeof(float[3]);
 256    dest2->flags = 0;
 257
 258    ref->data = (GLfloat(*)[3])r;
 259    ref->start = (GLfloat *)r;
 260    ref->count = TEST_COUNT;
 261    ref->stride = sizeof(float[3]);
 262    ref->flags = 0;
 263
 264    ref2->data = (GLfloat(*)[3])r2;
 265    ref2->start = (GLfloat *)r2;
 266    ref2->count = TEST_COUNT;
 267    ref2->stride = sizeof(float[3]);
 268    ref2->flags = 0;
 269
 270    if ( norm_normalize_types[mtype] == 0 ) {
 271       ref_norm_transform_rescale( mat, scale, source, NULL, NULL, ref );
 272    } else {
 273       ref_norm_transform_normalize( mat, scale, source, NULL, NULL, ref );
 274       ref_norm_transform_normalize( mat, scale, source, length, NULL, ref2 );
 275    }
 276
 277    if ( mesa_profile ) {
 278       BEGIN_RACE( *cycles );
 279       func( mat, scale, source, NULL, NULL, dest );
 280       END_RACE( *cycles );
 281       func( mat, scale, source, length, NULL, dest2 );
 282    } else {
 283       func( mat, scale, source, NULL, NULL, dest );
 284       func( mat, scale, source, length, NULL, dest2 );
 285    }
 286
 287    for ( i = 0 ; i < TEST_COUNT ; i++ ) {
 288       for ( j = 0 ; j < 3 ; j++ ) {
 289          if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) {
 290             printf( "-----------------------------\n" );
 291             printf( "(i = %i, j = %i)\n", i, j );
 292             printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
 293                     d[i][0], r[i][0], r[i][0]/d[i][0],
 294                     MAX_PRECISION - significand_match( d[i][0], r[i][0] ) );
 295             printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
 296                     d[i][1], r[i][1], r[i][1]/d[i][1],
 297                     MAX_PRECISION - significand_match( d[i][1], r[i][1] ) );
 298             printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
 299                     d[i][2], r[i][2], r[i][2]/d[i][2],
 300                     MAX_PRECISION - significand_match( d[i][2], r[i][2] ) );
 301             return 0;
 302          }
 303
 304          if ( norm_normalize_types[mtype] != 0 ) {
 305             if ( significand_match( d2[i][j], r2[i][j] ) < REQUIRED_PRECISION ) {
 306                printf( "------------------- precalculated length case ------\n" );
 307                printf( "(i = %i, j = %i)\n", i, j );
 308                printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
 309                        d2[i][0], r2[i][0], r2[i][0]/d2[i][0],
 310                        MAX_PRECISION - significand_match( d2[i][0], r2[i][0] ) );
 311                printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
 312                        d2[i][1], r2[i][1], r2[i][1]/d2[i][1],
 313                        MAX_PRECISION - significand_match( d2[i][1], r2[i][1] ) );
 314                printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
 315                        d2[i][2], r2[i][2], r2[i][2]/d2[i][2],
 316                        MAX_PRECISION - significand_match( d2[i][2], r2[i][2] ) );
 317                return 0;
 318             }
 319          }
 320       }
 321    }
 322
 323    ALIGN_FREE( mat->m );
 324    return 1;
 325 }
 326
 327 void _math_test_all_normal_transform_functions( char *description )
 328 {
 329    int mtype;
 330    long benchmark_tab[0xf][0x4];
 331    static int first_time = 1;
 332
 333    if ( first_time ) {
 334       first_time = 0;
 335       mesa_profile = getenv( "MESA_PROFILE" );
 336    }
 337
 338 #ifdef RUN_DEBUG_BENCHMARK
 339    if ( mesa_profile ) {
 340       if ( !counter_overhead ) {
 341          INIT_COUNTER();
 342          printf( "counter overhead: %ld cycles\n\n", counter_overhead );
 343       }
 344       printf( "normal transform results after hooking in %s functions:\n",
 345               description );
 346       printf( "\n-------------------------------------------------------\n" );
 347    }
 348 #endif
 349
 350    for ( mtype = 0 ; mtype < 8 ; mtype++ ) {
 351       normal_func func = _mesa_normal_tab[norm_types[mtype]][0];
 352       long *cycles = &(benchmark_tab[mtype][0]);
 353
 354       if ( test_norm_function( func, mtype, cycles ) == 0 ) {
 355          char buf[100];
 356          sprintf( buf, "_mesa_normal_tab[0][%s] failed test (%s)",
 357                   norm_strings[mtype], description );
 358          _mesa_problem( NULL, buf );
 359       }
 360
 361 #ifdef RUN_DEBUG_BENCHMARK
 362       if ( mesa_profile ) {
 363          printf( " %li\t", benchmark_tab[mtype][0] );
 364          printf( " | [%s]\n", norm_strings[mtype] );
 365       }
 366 #endif
 367    }
 368 #ifdef RUN_DEBUG_BENCHMARK
 369    if ( mesa_profile ) {
 370       printf( "\n" );
 371       fflush( stdout );
 372    }
 373 #endif
 374 }
 375
 376
 377 #endif /* DEBUG */