src/mesa/math/m_debug_norm.c

   1 /* $Id: m_debug_norm.c,v 1.8 2002/01/05 20:51:12 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  4.1
   6  *
   7  * Copyright (C) 1999-2002  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 GLvector4f *in,
 123                                         const GLfloat *lengths,
 124                                         GLvector4f *dest )
 125 {
 126    GLuint i;
 127    const GLfloat *s = in->start;
 128    const GLfloat *m = mat->inv;
 129    GLfloat (*out)[4] = (GLfloat (*)[4]) dest->start;
 130
 131    (void) lengths;
 132
 133    for ( i = 0 ; i < in->count ; i++ ) {
 134       GLfloat t[3];
 135
 136       TRANSFORM_NORMAL( t, s, m );
 137       SCALE_SCALAR_3V( out[i], scale, t );
 138
 139       s = (GLfloat *)((char *)s + in->stride);
 140    }
 141 }
 142
 143 static void ref_norm_transform_normalize( const GLmatrix *mat,
 144                                           GLfloat scale,
 145                                           const GLvector4f *in,
 146                                           const GLfloat *lengths,
 147                                           GLvector4f *dest )
 148 {
 149    GLuint i;
 150    const GLfloat *s = in->start;
 151    const GLfloat *m = mat->inv;
 152    GLfloat (*out)[4] = (GLfloat (*)[4]) dest->start;
 153
 154    for ( i = 0 ; i < in->count ; i++ ) {
 155       GLfloat t[3];
 156
 157       TRANSFORM_NORMAL( t, s, m );
 158
 159       if ( !lengths ) {
 160          GLfloat len = LEN_SQUARED_3FV( t );
 161          if ( len > 1e-20 ) {
 162             /* Hmmm, don't know how we could test the precalculated
 163              * length case...
 164              */
 165             scale = 1.0 / sqrt( len );
 166             SCALE_SCALAR_3V( out[i], scale, t );
 167          } else {
 168             out[i][0] = out[i][1] = out[i][2] = 0;
 169          }
 170       } else {
 171          scale = lengths[i];;
 172          SCALE_SCALAR_3V( out[i], scale, t );
 173       }
 174
 175       s = (GLfloat *)((char *)s + in->stride);
 176    }
 177 }
 178
 179
 180 /* =============================================================
 181  * Normal transformation tests
 182  */
 183
 184 static int test_norm_function( normal_func func, int mtype, long *cycles )
 185 {
 186    GLvector4f source[1], dest[1], dest2[1], ref[1], ref2[1];
 187    GLmatrix mat[1];
 188    GLfloat s[TEST_COUNT][5], d[TEST_COUNT][4], r[TEST_COUNT][4];
 189    GLfloat d2[TEST_COUNT][4], r2[TEST_COUNT][4], length[TEST_COUNT];
 190    GLfloat scale;
 191    GLfloat *m;
 192    int i, j;
 193 #ifdef  RUN_DEBUG_BENCHMARK
 194    int cycle_i;         /* the counter for the benchmarks we run */
 195 #endif
 196
 197    (void) cycles;
 198
 199    mat->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
 200    mat->inv = m = mat->m;
 201
 202    init_matrix( m );
 203
 204    scale = 1.0F + rnd () * norm_scale_types[mtype];
 205
 206    for ( i = 0 ; i < 4 ; i++ ) {
 207       for ( j = 0 ; j < 4 ; j++ ) {
 208          switch ( norm_templates[mtype][i * 4 + j] ) {
 209          case NIL:
 210             m[j * 4 + i] = 0.0;
 211             break;
 212          case ONE:
 213             m[j * 4 + i] = 1.0;
 214             break;
 215          case NEG:
 216             m[j * 4 + i] = -1.0;
 217             break;
 218          case VAR:
 219             break;
 220          default:
 221             abort();
 222          }
 223       }
 224    }
 225
 226    for ( i = 0 ; i < TEST_COUNT ; i++ ) {
 227       ASSIGN_3V( d[i],  0.0, 0.0, 0.0 );
 228       ASSIGN_3V( s[i],  0.0, 0.0, 0.0 );
 229       ASSIGN_3V( d2[i], 0.0, 0.0, 0.0 );
 230       for ( j = 0 ; j < 3 ; j++ )
 231          s[i][j] = rnd();
 232       length[i] = 1 / sqrt( LEN_SQUARED_3FV( s[i] ) );
 233    }
 234
 235    source->data = (GLfloat(*)[4]) s;
 236    source->start = (GLfloat *) s;
 237    source->count = TEST_COUNT;
 238    source->stride = sizeof(s[0]);
 239    source->flags = 0;
 240
 241    dest->data = d;
 242    dest->start = (GLfloat *) d;
 243    dest->count = TEST_COUNT;
 244    dest->stride = sizeof(float[4]);
 245    dest->flags = 0;
 246
 247    dest2->data = d2;
 248    dest2->start = (GLfloat *) d2;
 249    dest2->count = TEST_COUNT;
 250    dest2->stride = sizeof(float[4]);
 251    dest2->flags = 0;
 252
 253    ref->data = r;
 254    ref->start = (GLfloat *) r;
 255    ref->count = TEST_COUNT;
 256    ref->stride = sizeof(float[4]);
 257    ref->flags = 0;
 258
 259    ref2->data = r2;
 260    ref2->start = (GLfloat *) r2;
 261    ref2->count = TEST_COUNT;
 262    ref2->stride = sizeof(float[4]);
 263    ref2->flags = 0;
 264
 265    if ( norm_normalize_types[mtype] == 0 ) {
 266       ref_norm_transform_rescale( mat, scale, source, NULL, ref );
 267    } else {
 268       ref_norm_transform_normalize( mat, scale, source, NULL, ref );
 269       ref_norm_transform_normalize( mat, scale, source, length, ref2 );
 270    }
 271
 272    if ( mesa_profile ) {
 273       BEGIN_RACE( *cycles );
 274       func( mat, scale, source, NULL, dest );
 275       END_RACE( *cycles );
 276       func( mat, scale, source, length, dest2 );
 277    } else {
 278       func( mat, scale, source, NULL, dest );
 279       func( mat, scale, source, length, dest2 );
 280    }
 281
 282    for ( i = 0 ; i < TEST_COUNT ; i++ ) {
 283       for ( j = 0 ; j < 3 ; j++ ) {
 284          if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) {
 285             printf( "-----------------------------\n" );
 286             printf( "(i = %i, j = %i)\n", i, j );
 287             printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
 288                     d[i][0], r[i][0], r[i][0]/d[i][0],
 289                     MAX_PRECISION - significand_match( d[i][0], r[i][0] ) );
 290             printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
 291                     d[i][1], r[i][1], r[i][1]/d[i][1],
 292                     MAX_PRECISION - significand_match( d[i][1], r[i][1] ) );
 293             printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
 294                     d[i][2], r[i][2], r[i][2]/d[i][2],
 295                     MAX_PRECISION - significand_match( d[i][2], r[i][2] ) );
 296             return 0;
 297          }
 298
 299          if ( norm_normalize_types[mtype] != 0 ) {
 300             if ( significand_match( d2[i][j], r2[i][j] ) < REQUIRED_PRECISION ) {
 301                printf( "------------------- precalculated length case ------\n" );
 302                printf( "(i = %i, j = %i)\n", i, j );
 303                printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
 304                        d2[i][0], r2[i][0], r2[i][0]/d2[i][0],
 305                        MAX_PRECISION - significand_match( d2[i][0], r2[i][0] ) );
 306                printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
 307                        d2[i][1], r2[i][1], r2[i][1]/d2[i][1],
 308                        MAX_PRECISION - significand_match( d2[i][1], r2[i][1] ) );
 309                printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
 310                        d2[i][2], r2[i][2], r2[i][2]/d2[i][2],
 311                        MAX_PRECISION - significand_match( d2[i][2], r2[i][2] ) );
 312                return 0;
 313             }
 314          }
 315       }
 316    }
 317
 318    ALIGN_FREE( mat->m );
 319    return 1;
 320 }
 321
 322 void _math_test_all_normal_transform_functions( char *description )
 323 {
 324    int mtype;
 325    long benchmark_tab[0xf];
 326    static int first_time = 1;
 327
 328    if ( first_time ) {
 329       first_time = 0;
 330       mesa_profile = getenv( "MESA_PROFILE" );
 331    }
 332
 333 #ifdef RUN_DEBUG_BENCHMARK
 334    if ( mesa_profile ) {
 335       if ( !counter_overhead ) {
 336          INIT_COUNTER();
 337          printf( "counter overhead: %ld cycles\n\n", counter_overhead );
 338       }
 339       printf( "normal transform results after hooking in %s functions:\n",
 340               description );
 341       printf( "\n-------------------------------------------------------\n" );
 342    }
 343 #endif
 344
 345    for ( mtype = 0 ; mtype < 8 ; mtype++ ) {
 346       normal_func func = _mesa_normal_tab[norm_types[mtype]];
 347       long *cycles = &benchmark_tab[mtype];
 348
 349       if ( test_norm_function( func, mtype, cycles ) == 0 ) {
 350          char buf[100];
 351          sprintf( buf, "_mesa_normal_tab[0][%s] failed test (%s)",
 352                   norm_strings[mtype], description );
 353          _mesa_problem( NULL, buf );
 354       }
 355
 356 #ifdef RUN_DEBUG_BENCHMARK
 357       if ( mesa_profile ) {
 358          printf( " %li\t", benchmark_tab[mtype] );
 359          printf( " | [%s]\n", norm_strings[mtype] );
 360       }
 361 #endif
 362    }
 363 #ifdef RUN_DEBUG_BENCHMARK
 364    if ( mesa_profile ) {
 365       printf( "\n" );
 366       fflush( stdout );
 367    }
 368 #endif
 369 }
 370
 371
 372 #endif /* DEBUG */