void vbo_exec_vtx_destroy( struct vbo_exec_context *exec ) { /* using a real VBO for vertex data */ GLcontext *ctx = exec->ctx; unsigned i; /* True VBOs should already be unmapped */ if (exec->vtx.buffer_map) { ASSERT(exec->vtx.bufferobj->Name == 0 || exec->vtx.bufferobj->Name == IMM_BUFFER_NAME); if (exec->vtx.bufferobj->Name == 0) { ALIGN_FREE(exec->vtx.buffer_map); exec->vtx.buffer_map = NULL; exec->vtx.buffer_ptr = NULL; } } /* Drop any outstanding reference to the vertex buffer */ for (i = 0; i < Elements(exec->vtx.arrays); i++) { _mesa_reference_buffer_object(ctx, &exec->vtx.arrays[i].BufferObj, NULL); } /* Free the vertex buffer: */ _mesa_reference_buffer_object(ctx, &exec->vtx.bufferobj, NULL); }
void _tnl_free_vertices( GLcontext *ctx ) { struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); struct tnl_clipspace_fastpath *fp, *tmp; if (vtx->vertex_buf) { ALIGN_FREE(vtx->vertex_buf); vtx->vertex_buf = NULL; } for (fp = vtx->fastpath ; fp ; fp = tmp) { tmp = fp->next; FREE(fp->attr); /* KW: At the moment, fp->func is constrained to be allocated by * _mesa_exec_alloc(), as the hardwired fastpaths in * t_vertex_generic.c are handled specially. It would be nice * to unify them, but this probably won't change until this * module gets another overhaul. */ _mesa_exec_free((void *) fp->func); FREE(fp); } vtx->fastpath = NULL; }
static void free_funcs( struct _tnl_dynfn *l ) { struct _tnl_dynfn *f, *tmp; foreach_s (f, tmp, l) { remove_from_list( f ); ALIGN_FREE( f->code ); FREE( f ); }
void ffbFreeVB( GLcontext *ctx ) { ffbContextPtr fmesa = FFB_CONTEXT(ctx); if (fmesa->verts) { ALIGN_FREE(fmesa->verts); fmesa->verts = 0; } }
void i810FreeVB( GLcontext *ctx ) { i810ContextPtr imesa = I810_CONTEXT(ctx); if (imesa->verts) { ALIGN_FREE(imesa->verts); imesa->verts = 0; } }
void mach64FreeVB( GLcontext *ctx ) { mach64ContextPtr mmesa = MACH64_CONTEXT(ctx); if (mmesa->verts) { ALIGN_FREE(mmesa->verts); mmesa->verts = 0; } }
void _tnl_free_vertices( GLcontext *ctx ) { struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); if (vtx->vertex_buf) { ALIGN_FREE(vtx->vertex_buf); vtx->vertex_buf = 0; } }
void tdfxFreeVB( GLcontext *ctx ) { tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx); if (fxMesa->verts) { ALIGN_FREE(fxMesa->verts); fxMesa->verts = 0; } }
void gammaFreeVB( GLcontext *ctx ) { gammaContextPtr gmesa = GAMMA_CONTEXT(ctx); if (gmesa->verts) { ALIGN_FREE(gmesa->verts); gmesa->verts = 0; } }
void fxFreeVB( GLcontext *ctx ) { fxMesaContext fxMesa = FX_CONTEXT(ctx); if (fxMesa->verts) { ALIGN_FREE(fxMesa->verts); fxMesa->verts = 0; } }
void s3vFreeVB( GLcontext *ctx ) { s3vContextPtr vmesa = S3V_CONTEXT(ctx); if (vmesa->verts) { ALIGN_FREE(vmesa->verts); vmesa->verts = 0; } if (vmesa->UbyteSecondaryColor.Ptr) { ALIGN_FREE((void *)vmesa->UbyteSecondaryColor.Ptr); vmesa->UbyteSecondaryColor.Ptr = 0; } if (vmesa->UbyteColor.Ptr) { ALIGN_FREE((void *)vmesa->UbyteColor.Ptr); vmesa->UbyteColor.Ptr = 0; } }
void gammaFreeVB( GLcontext *ctx ) { gammaContextPtr gmesa = GAMMA_CONTEXT(ctx); if (gmesa->verts) { ALIGN_FREE(gmesa->verts); gmesa->verts = 0; } if (gmesa->UbyteSecondaryColor.Ptr) { ALIGN_FREE(gmesa->UbyteSecondaryColor.Ptr); gmesa->UbyteSecondaryColor.Ptr = 0; } if (gmesa->UbyteColor.Ptr) { ALIGN_FREE(gmesa->UbyteColor.Ptr); gmesa->UbyteColor.Ptr = 0; } }
void i830FreeVB( GLcontext *ctx ) { i830ContextPtr imesa = I830_CONTEXT(ctx); if (imesa->verts) { ALIGN_FREE(imesa->verts); imesa->verts = 0; } if (imesa->UbyteSecondaryColor.Ptr) { ALIGN_FREE(imesa->UbyteSecondaryColor.Ptr); imesa->UbyteSecondaryColor.Ptr = 0; } if (imesa->UbyteColor.Ptr) { ALIGN_FREE(imesa->UbyteColor.Ptr); imesa->UbyteColor.Ptr = 0; } }
void mgaFreeVB( GLcontext *ctx ) { mgaContextPtr mmesa = MGA_CONTEXT(ctx); if (mmesa->verts) { ALIGN_FREE(mmesa->verts); mmesa->verts = 0; } if (mmesa->UbyteSecondaryColor.Ptr) { ALIGN_FREE(mmesa->UbyteSecondaryColor.Ptr); mmesa->UbyteSecondaryColor.Ptr = 0; } if (mmesa->UbyteColor.Ptr) { ALIGN_FREE(mmesa->UbyteColor.Ptr); mmesa->UbyteColor.Ptr = 0; } }
void _swsetup_DestroyContext( GLcontext *ctx ) { SScontext *swsetup = SWSETUP_CONTEXT(ctx); if (swsetup) { if (swsetup->verts) ALIGN_FREE(swsetup->verts); if (swsetup->ChanSecondaryColor.Ptr) ALIGN_FREE(swsetup->ChanSecondaryColor.Ptr); if (swsetup->ChanColor.Ptr) ALIGN_FREE(swsetup->ChanColor.Ptr); FREE(swsetup); ctx->swsetup_context = 0; } }
static void real_free_immediate( struct immediate *IM ) { static int freed = 0; GLuint j; if (IM->Material) { FREE( IM->Material ); FREE( IM->MaterialMask ); IM->Material = 0; IM->MaterialMask = 0; } for (j = 1; j < IM->MaxTextureUnits; j++) ALIGN_FREE( IM->TexCoord[j] ); if (IM->NormalLengthPtr) ALIGN_FREE( IM->NormalLengthPtr ); ALIGN_FREE( IM ); freed++; /* printf("outstanding %d\n", id - freed); */ }
/** * Destructor for this pipeline stage. */ static void dtr( struct tnl_pipeline_stage *stage ) { struct vp_stage_data *store = VP_STAGE_DATA(stage); if (store) { GLuint i; /* free the vertex program result arrays */ for (i = 0; i < VERT_RESULT_MAX; i++) _mesa_vector4f_free( &store->attribs[i] ); /* free misc arrays */ _mesa_vector4f_free( &store->ndcCoords ); ALIGN_FREE( store->clipmask ); FREE( store ); stage->privatePtr = NULL; } }
/* Destroy the device specific context. */ void mach64DestroyContext( __DRIcontextPrivate *driContextPriv ) { mach64ContextPtr mmesa = (mach64ContextPtr) driContextPriv->driverPrivate; assert(mmesa); /* should never be null */ if ( mmesa ) { GLboolean release_texture_heaps; release_texture_heaps = (mmesa->glCtx->Shared->RefCount == 1); _swsetup_DestroyContext( mmesa->glCtx ); _tnl_DestroyContext( mmesa->glCtx ); _vbo_DestroyContext( mmesa->glCtx ); _swrast_DestroyContext( mmesa->glCtx ); if (release_texture_heaps) { /* This share group is about to go away, free our private * texture object data. */ int i; for ( i = mmesa->firstTexHeap ; i < mmesa->lastTexHeap ; i++ ) { driDestroyTextureHeap( mmesa->texture_heaps[i] ); mmesa->texture_heaps[i] = NULL; } assert( is_empty_list( & mmesa->swapped ) ); } mach64FreeVB( mmesa->glCtx ); /* Free the vertex buffer */ if ( mmesa->vert_buf ) ALIGN_FREE( mmesa->vert_buf ); /* free the Mesa context */ mmesa->glCtx->DriverCtx = NULL; _mesa_destroy_context(mmesa->glCtx); FREE( mmesa ); } }
/* May be called after tnl is destroyed. */ void _tnl_free_immediate( GLcontext *ctx, struct immediate *IM ) { TNLcontext *tnl = TNL_CONTEXT(ctx); ASSERT(IM->ref_count == 0); if (IM->NormalLengthPtr) { ALIGN_FREE(IM->NormalLengthPtr); IM->NormalLengthPtr = NULL; } if (!tnl) { real_free_immediate( IM ); } else { if (tnl->freed_immediate) real_free_immediate( tnl->freed_immediate ); tnl->freed_immediate = IM; } }
static int test_norm_function( normal_func func, int mtype, int masked, long *cycles ) { GLvector3f source[1], dest[1], dest2[1], ref[1], ref2[1]; GLmatrix mat[1]; GLfloat s[TEST_COUNT][5], d[TEST_COUNT][3], r[TEST_COUNT][3]; GLfloat d2[TEST_COUNT][3], r2[TEST_COUNT][3], length[TEST_COUNT]; GLfloat scale; GLfloat *m; GLubyte mask[TEST_COUNT]; int i, j; #ifdef RUN_XFORM_BENCHMARK int cycle_i; /* the counter for the benchmarks we run */ #endif (void) cycles; mat->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 ); mat->inv = m = mat->m; m[0] = 63.0; m[4] = 43.0; m[ 8] = 29.0; m[12] = 43.0; m[1] = 55.0; m[5] = 17.0; m[ 9] = 31.0; m[13] = 7.0; m[2] = 44.0; m[6] = 9.0; m[10] = 7.0; m[14] = 3.0; m[3] = 11.0; m[7] = 23.0; m[11] = 91.0; m[15] = 9.0; scale = 1.0F + rnd () * norm_scale_types[mtype]; for ( i = 0 ; i < 4 ; i++ ) { for ( j = 0 ; j < 4 ; j++ ) { switch ( norm_templates[mtype][i * 4 + j] ) { case NIL: m[j * 4 + i] = 0.0; break; case ONE: m[j * 4 + i] = 1.0; break; case NEG: m[j * 4 + i] = -1.0; break; case VAR: break; default: abort(); } } } for ( i = 0 ; i < TEST_COUNT ; i++ ) { mask[i] = i % 2; /* mask every 2nd element */ d[i][0] = s[i][0] = d2[i][0] = 0.0; d[i][1] = s[i][1] = d2[i][1] = 0.0; d[i][2] = s[i][2] = d2[i][2] = 0.0; for ( j = 0 ; j < 3 ; j++ ) s[i][j] = rnd(); length[i] = 1 / sqrt( s[i][0]*s[i][0] + s[i][1]*s[i][1] + s[i][2]*s[i][2] ); } source->data = (GLfloat(*)[3])s; source->start = (GLfloat *)s; source->count = TEST_COUNT; source->stride = sizeof(s[0]); source->flags = 0; dest->data = (GLfloat(*)[3])d; dest->start = (GLfloat *)d; dest->count = TEST_COUNT; dest->stride = sizeof(float[3]); dest->flags = 0; dest2->data = (GLfloat(*)[3])d2; dest2->start = (GLfloat *)d2; dest2->count = TEST_COUNT; dest2->stride = sizeof(float[3]); dest2->flags = 0; ref->data = (GLfloat(*)[3])r; ref->start = (GLfloat *)r; ref->count = TEST_COUNT; ref->stride = sizeof(float[3]); ref->flags = 0; ref2->data = (GLfloat(*)[3])r2; ref2->start = (GLfloat *)r2; ref2->count = TEST_COUNT; ref2->stride = sizeof(float[3]); ref2->flags = 0; if ( norm_normalize_types[mtype] == 0 ) { ref_norm_transform_rescale( mat, scale, source, NULL, NULL, ref ); } else { ref_norm_transform_normalize( mat, scale, source, NULL, NULL, ref ); ref_norm_transform_normalize( mat, scale, source, length, NULL, ref2 ); } if ( mesa_profile ) { if ( masked ) { BEGIN_RACE( *cycles ); func( mat, scale, source, NULL, mask, dest ); END_RACE( *cycles ); func( mat, scale, source, length, mask, dest2 ); } else { BEGIN_RACE( *cycles ); func( mat, scale, source, NULL, NULL, dest ); END_RACE( *cycles ); func( mat, scale, source, length, NULL, dest2 ); } } else { if ( masked ) { func( mat, scale, source, NULL, mask, dest ); func( mat, scale, source, length, mask, dest2 ); } else { func( mat, scale, source, NULL, NULL, dest ); func( mat, scale, source, length, NULL, dest2 ); } } for ( i = 0 ; i < TEST_COUNT ; i++ ) { if ( masked && !(mask[i] & 1) ) continue; for ( j = 0 ; j < 3 ; j++ ) { if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) { printf( "-----------------------------\n" ); printf( "(i = %i, j = %i)\n", i, j ); printf( "%f \t %f \t [ratio = %e - %i bit missed]\n", d[i][0], r[i][0], r[i][0]/d[i][0], MAX_PRECISION - significand_match( d[i][0], r[i][0] ) ); printf( "%f \t %f \t [ratio = %e - %i bit missed]\n", d[i][1], r[i][1], r[i][1]/d[i][1], MAX_PRECISION - significand_match( d[i][1], r[i][1] ) ); printf( "%f \t %f \t [ratio = %e - %i bit missed]\n", d[i][2], r[i][2], r[i][2]/d[i][2], MAX_PRECISION - significand_match( d[i][2], r[i][2] ) ); return 0; } if ( norm_normalize_types[mtype] != 0 ) { if ( significand_match( d2[i][j], r2[i][j] ) < REQUIRED_PRECISION ) { printf( "------------------- precalculated length case ------\n" ); printf( "(i = %i, j = %i)\n", i, j ); printf( "%f \t %f \t [ratio = %e - %i bit missed]\n", d2[i][0], r2[i][0], r2[i][0]/d2[i][0], MAX_PRECISION - significand_match( d2[i][0], r2[i][0] ) ); printf( "%f \t %f \t [ratio = %e - %i bit missed]\n", d2[i][1], r2[i][1], r2[i][1]/d2[i][1], MAX_PRECISION - significand_match( d2[i][1], r2[i][1] ) ); printf( "%f \t %f \t [ratio = %e - %i bit missed]\n", d2[i][2], r2[i][2], r2[i][2]/d2[i][2], MAX_PRECISION - significand_match( d2[i][2], r2[i][2] ) ); return 0; } } } } ALIGN_FREE( mat->m ); return 1; }
static int test_transform_function( transform_func func, int psize, int mtype, int masked, long *cycles ) { GLvector4f source[1], dest[1], ref[1]; GLmatrix mat[1]; GLfloat *m; GLubyte mask[TEST_COUNT]; int i, j; #ifdef RUN_XFORM_BENCHMARK int cycle_i; /* the counter for the benchmarks we run */ #endif (void) cycles; if ( psize > 4 ) { gl_problem( NULL, "test_transform_function called with psize > 4\n" ); return 0; } mat->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 ); mat->type = mtypes[mtype]; m = mat->m; m[0] = 63.0; m[4] = 43.0; m[ 8] = 29.0; m[12] = 43.0; m[1] = 55.0; m[5] = 17.0; m[ 9] = 31.0; m[13] = 7.0; m[2] = 44.0; m[6] = 9.0; m[10] = 7.0; m[14] = 3.0; m[3] = 11.0; m[7] = 23.0; m[11] = 91.0; m[15] = 9.0; for ( i = 0 ; i < 4 ; i++ ) { for ( j = 0 ; j < 4 ; j++ ) { switch ( templates[mtype][i * 4 + j] ) { case NIL: m[j * 4 + i] = 0.0; break; case ONE: m[j * 4 + i] = 1.0; break; case NEG: m[j * 4 + i] = -1.0; break; case VAR: break; default: abort(); } } } for ( i = 0 ; i < TEST_COUNT ; i++) { mask[i] = i % 2; /* mask every 2nd element */ d[i][0] = s[i][0] = 0.0; d[i][1] = s[i][1] = 0.0; d[i][2] = s[i][2] = 0.0; d[i][3] = s[i][3] = 1.0; for ( j = 0 ; j < psize ; j++ ) s[i][j] = rnd(); } source->data = (GLfloat(*)[4])s; source->start = (GLfloat *)s; source->count = TEST_COUNT; source->stride = sizeof(s[0]); source->size = 4; source->flags = 0; dest->data = (GLfloat(*)[4])d; dest->start = (GLfloat *)d; dest->count = TEST_COUNT; dest->stride = sizeof(float[4]); dest->size = 0; dest->flags = 0; ref->data = (GLfloat(*)[4])r; ref->start = (GLfloat *)r; ref->count = TEST_COUNT; ref->stride = sizeof(float[4]); ref->size = 0; ref->flags = 0; ref_transform( ref, mat, source, NULL, 0 ); if ( mesa_profile ) { if ( masked ) { BEGIN_RACE( *cycles ); func( dest, mat->m, source, mask, 1 ); END_RACE( *cycles ); } else { BEGIN_RACE( *cycles ); func( dest, mat->m, source, NULL, 0 ); END_RACE( *cycles ); } } else { if ( masked ) { func( dest, mat->m, source, mask, 1 ); } else { func( dest, mat->m, source, NULL, 0 ); } } for ( i = 0 ; i < TEST_COUNT ; i++ ) { if ( masked && (mask[i] & 1) ) continue; for ( j = 0 ; j < 4 ; j++ ) { if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) { printf( "-----------------------------\n" ); printf( "(i = %i, j = %i)\n", i, j ); printf( "%f \t %f \t [diff = %e - %i bit missed]\n", d[i][0], r[i][0], r[i][0]-d[i][0], MAX_PRECISION - significand_match( d[i][0], r[i][0] ) ); printf( "%f \t %f \t [diff = %e - %i bit missed]\n", d[i][1], r[i][1], r[i][1]-d[i][1], MAX_PRECISION - significand_match( d[i][1], r[i][1] ) ); printf( "%f \t %f \t [diff = %e - %i bit missed]\n", d[i][2], r[i][2], r[i][2]-d[i][2], MAX_PRECISION - significand_match( d[i][2], r[i][2] ) ); printf( "%f \t %f \t [diff = %e - %i bit missed]\n", d[i][3], r[i][3], r[i][3]-d[i][3], MAX_PRECISION - significand_match( d[i][3], r[i][3] ) ); return 0; } } } ALIGN_FREE( mat->m ); return 1; }
static int test_transform_function( transform_func func, int psize, int mtype, unsigned long *cycles ) { GLvector4f source[1], dest[1], ref[1]; GLmatrix mat[1]; GLfloat *m; int i, j; #ifdef RUN_DEBUG_BENCHMARK int cycle_i; /* the counter for the benchmarks we run */ #endif (void) cycles; if ( psize > 4 ) { _mesa_problem( NULL, "test_transform_function called with psize > 4\n" ); return 0; } mat->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 ); mat->type = mtypes[mtype]; m = mat->m; ASSERT( ((long)m & 15) == 0 ); init_matrix( m ); for ( i = 0 ; i < 4 ; i++ ) { for ( j = 0 ; j < 4 ; j++ ) { switch ( templates[mtype][i * 4 + j] ) { case NIL: m[j * 4 + i] = 0.0; break; case ONE: m[j * 4 + i] = 1.0; break; case NEG: m[j * 4 + i] = -1.0; break; case VAR: break; default: ASSERT(0); return 0; } } } for ( i = 0 ; i < TEST_COUNT ; i++) { ASSIGN_4V( d[i], 0.0, 0.0, 0.0, 1.0 ); ASSIGN_4V( s[i], 0.0, 0.0, 0.0, 1.0 ); for ( j = 0 ; j < psize ; j++ ) s[i][j] = rnd(); } source->data = (GLfloat(*)[4])s; source->start = (GLfloat *)s; source->count = TEST_COUNT; source->stride = sizeof(s[0]); source->size = 4; source->flags = 0; dest->data = (GLfloat(*)[4])d; dest->start = (GLfloat *)d; dest->count = TEST_COUNT; dest->stride = sizeof(float[4]); dest->size = 0; dest->flags = 0; ref->data = (GLfloat(*)[4])r; ref->start = (GLfloat *)r; ref->count = TEST_COUNT; ref->stride = sizeof(float[4]); ref->size = 0; ref->flags = 0; ref_transform( ref, mat, source ); if ( mesa_profile ) { BEGIN_RACE( *cycles ); func( dest, mat->m, source ); END_RACE( *cycles ); } else { func( dest, mat->m, source ); } for ( i = 0 ; i < TEST_COUNT ; i++ ) { for ( j = 0 ; j < 4 ; j++ ) { if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) { _mesa_printf("-----------------------------\n" ); _mesa_printf("(i = %i, j = %i)\n", i, j ); _mesa_printf("%f \t %f \t [diff = %e - %i bit missed]\n", d[i][0], r[i][0], r[i][0]-d[i][0], MAX_PRECISION - significand_match( d[i][0], r[i][0] ) ); _mesa_printf("%f \t %f \t [diff = %e - %i bit missed]\n", d[i][1], r[i][1], r[i][1]-d[i][1], MAX_PRECISION - significand_match( d[i][1], r[i][1] ) ); _mesa_printf("%f \t %f \t [diff = %e - %i bit missed]\n", d[i][2], r[i][2], r[i][2]-d[i][2], MAX_PRECISION - significand_match( d[i][2], r[i][2] ) ); _mesa_printf("%f \t %f \t [diff = %e - %i bit missed]\n", d[i][3], r[i][3], r[i][3]-d[i][3], MAX_PRECISION - significand_match( d[i][3], r[i][3] ) ); return 0; } } } ALIGN_FREE( mat->m ); return 1; }
static int test_norm_function( normal_func func, int mtype, long *cycles ) { GLvector4f source[1], dest[1], dest2[1], ref[1], ref2[1]; GLmatrix mat[1]; GLfloat s[TEST_COUNT][5], d[TEST_COUNT][4], r[TEST_COUNT][4]; GLfloat d2[TEST_COUNT][4], r2[TEST_COUNT][4], length[TEST_COUNT]; GLfloat scale; GLfloat *m; int i, j; #ifdef RUN_DEBUG_BENCHMARK int cycle_i; /* the counter for the benchmarks we run */ #endif (void) cycles; mat->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 ); mat->inv = m = mat->m; init_matrix( m ); scale = 1.0F + rnd () * norm_scale_types[mtype]; for ( i = 0 ; i < 4 ; i++ ) { for ( j = 0 ; j < 4 ; j++ ) { switch ( norm_templates[mtype][i * 4 + j] ) { case NIL: m[j * 4 + i] = 0.0; break; case ONE: m[j * 4 + i] = 1.0; break; case NEG: m[j * 4 + i] = -1.0; break; case VAR: break; default: _mesa_exit(1); } } } for ( i = 0 ; i < TEST_COUNT ; i++ ) { ASSIGN_3V( d[i], 0.0, 0.0, 0.0 ); ASSIGN_3V( s[i], 0.0, 0.0, 0.0 ); ASSIGN_3V( d2[i], 0.0, 0.0, 0.0 ); for ( j = 0 ; j < 3 ; j++ ) s[i][j] = rnd(); length[i] = 1 / SQRTF( LEN_SQUARED_3FV( s[i] ) ); } source->data = (GLfloat(*)[4]) s; source->start = (GLfloat *) s; source->count = TEST_COUNT; source->stride = sizeof(s[0]); source->flags = 0; dest->data = d; dest->start = (GLfloat *) d; dest->count = TEST_COUNT; dest->stride = sizeof(float[4]); dest->flags = 0; dest2->data = d2; dest2->start = (GLfloat *) d2; dest2->count = TEST_COUNT; dest2->stride = sizeof(float[4]); dest2->flags = 0; ref->data = r; ref->start = (GLfloat *) r; ref->count = TEST_COUNT; ref->stride = sizeof(float[4]); ref->flags = 0; ref2->data = r2; ref2->start = (GLfloat *) r2; ref2->count = TEST_COUNT; ref2->stride = sizeof(float[4]); ref2->flags = 0; if ( norm_normalize_types[mtype] == 0 ) { ref_norm_transform_rescale( mat, scale, source, NULL, ref ); } else { ref_norm_transform_normalize( mat, scale, source, NULL, ref ); ref_norm_transform_normalize( mat, scale, source, length, ref2 ); } if ( mesa_profile ) { BEGIN_RACE( *cycles ); func( mat, scale, source, NULL, dest ); END_RACE( *cycles ); func( mat, scale, source, length, dest2 ); } else { func( mat, scale, source, NULL, dest ); func( mat, scale, source, length, dest2 ); } for ( i = 0 ; i < TEST_COUNT ; i++ ) { for ( j = 0 ; j < 3 ; j++ ) { if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) { _mesa_printf( "-----------------------------\n" ); _mesa_printf( "(i = %i, j = %i)\n", i, j ); _mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n", d[i][0], r[i][0], r[i][0]/d[i][0], MAX_PRECISION - significand_match( d[i][0], r[i][0] ) ); _mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n", d[i][1], r[i][1], r[i][1]/d[i][1], MAX_PRECISION - significand_match( d[i][1], r[i][1] ) ); _mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n", d[i][2], r[i][2], r[i][2]/d[i][2], MAX_PRECISION - significand_match( d[i][2], r[i][2] ) ); return 0; } if ( norm_normalize_types[mtype] != 0 ) { if ( significand_match( d2[i][j], r2[i][j] ) < REQUIRED_PRECISION ) { _mesa_printf( "------------------- precalculated length case ------\n" ); _mesa_printf( "(i = %i, j = %i)\n", i, j ); _mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n", d2[i][0], r2[i][0], r2[i][0]/d2[i][0], MAX_PRECISION - significand_match( d2[i][0], r2[i][0] ) ); _mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n", d2[i][1], r2[i][1], r2[i][1]/d2[i][1], MAX_PRECISION - significand_match( d2[i][1], r2[i][1] ) ); _mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n", d2[i][2], r2[i][2], r2[i][2]/d2[i][2], MAX_PRECISION - significand_match( d2[i][2], r2[i][2] ) ); return 0; } } } } ALIGN_FREE( mat->m ); return 1; }