ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-19 06:09:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Enable -Werror for GCC/Clang builds (#786)

Browse Source 
* Enable -Werror for GCC/Clang builds

Fixes many of the errors this produces, and disables a handful that
didn't have solutions that were obvious (to me).

* Check for `-W*` flags empirically

* Remove cl_APPLE_fp64_basic_ops support

* Undo NAN conversion fix

* Add comments to warning override flags

* Remove unneeded STRINGIFY definition

* Fix tautological compare issue in basic

* Use ABS_ERROR macro in image tests

* Use fabs for ABS_ERROR macro

* Move ABS_ERROR definition to common header
This commit is contained in:
James Price
2020-05-27 14:13:11 -04:00
committed by GitHub
parent 094cc04e16
commit 944b0a8178
27 changed files with 398 additions and 367 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
test_conformance/images/kernel_read_write/test_common.h
View File

@@ -1,5 +1,7 @@
#include "../testBase.h"
#define ABS_ERROR(result, expected) (fabs(expected - result))
extern cl_sampler create_sampler(cl_context context, image_sampler_data *sdata, bool test_mipmaps, cl_int *error);

86
test_conformance/images/kernel_read_write/test_iterations.cpp
View File

@@ -85,8 +85,6 @@ static const char *lodOffsetSource =
static const char *offsetSource =
" int offset = tidY*get_image_width(input) + tidX;\n";
#define ABS_ERROR( result, expected ) ( fabsf( (float)expected - (float)result ) )
extern void read_image_pixel_float( void *imageData, image_descriptor *imageInfo,
int x, int y, int z, float *outData );
template <class T> int determine_validation_error( void *imagePtr, image_descriptor *imageInfo, image_sampler_data *imageSampler,
@@ -453,7 +451,7 @@ int validate_image_2D_depth_results(void *imageValues, void *resultValues, doubl
xOffsetValues[ j ], yOffsetValues[ j ], 0.0f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, &containsDenormals );
float err1 = fabsf( resultPtr[0] - expected[0] );
float err1 = ABS_ERROR(resultPtr[0], expected[0]);
// Clamp to the minimum absolute error for the format
if (err1 > 0 && err1 < formatAbsoluteError) { err1 = 0.0f; }
float maxErr1 = MAX( maxErr * maxPixel.p[0], FLT_MIN );
@@ -472,7 +470,7 @@ int validate_image_2D_depth_results(void *imageValues, void *resultValues, doubl
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, NULL );
err1 = fabsf( resultPtr[0] - expected[0] );
err1 = ABS_ERROR(resultPtr[0], expected[0]);
}
}
@@ -505,7 +503,7 @@ int validate_image_2D_depth_results(void *imageValues, void *resultValues, doubl
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, &containsDenormals );
float err1 = fabsf( resultPtr[0] - expected[0] );
float err1 = ABS_ERROR(resultPtr[0], expected[0]);
float maxErr1 = MAX( maxErr * maxPixel.p[0], FLT_MIN );
@@ -520,7 +518,7 @@ int validate_image_2D_depth_results(void *imageValues, void *resultValues, doubl
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, NULL );
err1 = fabsf( resultPtr[0] - expected[0] );
err1 = ABS_ERROR(resultPtr[0], expected[0]);
}
}
if( ! (err1 <= maxErr1) )
@@ -611,10 +609,10 @@ int validate_image_2D_results(void *imageValues, void *resultValues, double form
xOffsetValues[ j ], yOffsetValues[ j ], 0.0f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, &containsDenormals );
float err1 = fabsf( resultPtr[0] - expected[0] );
float err2 = fabsf( resultPtr[1] - expected[1] );
float err3 = fabsf( resultPtr[2] - expected[2] );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 = ABS_ERROR(resultPtr[0], expected[0]);
float err2 = ABS_ERROR(resultPtr[1], expected[1]);
float err3 = ABS_ERROR(resultPtr[2], expected[2]);
float err4 = ABS_ERROR(resultPtr[3], expected[3]);
// Clamp to the minimum absolute error for the format
if (err1 > 0 && err1 < formatAbsoluteError) { err1 = 0.0f; }
if (err2 > 0 && err2 < formatAbsoluteError) { err2 = 0.0f; }
@@ -648,10 +646,10 @@ int validate_image_2D_results(void *imageValues, void *resultValues, double form
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, NULL );
err1 = fabsf( resultPtr[0] - expected[0] );
err2 = fabsf( resultPtr[1] - expected[1] );
err3 = fabsf( resultPtr[2] - expected[2] );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(resultPtr[0], expected[0]);
err2 = ABS_ERROR(resultPtr[1], expected[1]);
err3 = ABS_ERROR(resultPtr[2], expected[2]);
err4 = ABS_ERROR(resultPtr[3], expected[3]);
}
}
@@ -689,10 +687,10 @@ int validate_image_2D_results(void *imageValues, void *resultValues, double form
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, &containsDenormals );
float err1 = fabsf( resultPtr[0] - expected[0] );
float err2 = fabsf( resultPtr[1] - expected[1] );
float err3 = fabsf( resultPtr[2] - expected[2] );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 = ABS_ERROR(resultPtr[0], expected[0]);
float err2 = ABS_ERROR(resultPtr[1], expected[1]);
float err3 = ABS_ERROR(resultPtr[2], expected[2]);
float err4 = ABS_ERROR(resultPtr[3], expected[3]);
float maxErr1 = MAX( maxErr * maxPixel.p[0], FLT_MIN );
float maxErr2 = MAX( maxErr * maxPixel.p[1], FLT_MIN );
float maxErr3 = MAX( maxErr * maxPixel.p[2], FLT_MIN );
@@ -719,10 +717,10 @@ int validate_image_2D_results(void *imageValues, void *resultValues, double form
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, NULL );
err1 = fabsf( resultPtr[0] - expected[0] );
err2 = fabsf( resultPtr[1] - expected[1] );
err3 = fabsf( resultPtr[2] - expected[2] );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(resultPtr[0], expected[0]);
err2 = ABS_ERROR(resultPtr[1], expected[1]);
err3 = ABS_ERROR(resultPtr[2], expected[2]);
err4 = ABS_ERROR(resultPtr[3], expected[3]);
}
}
if( ! (err1 <= maxErr1) || ! (err2 <= maxErr2) ||
@@ -1008,10 +1006,13 @@ int validate_image_2D_sRGB_results(void *imageValues, void *resultValues, double
maxPixel = sample_image_pixel_float_offset( imageValues, imageInfo,
xOffsetValues[ j ], yOffsetValues[ j ], 0.0f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, &containsDenormals );
float err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
float err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
float err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 = ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
float err2 = ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
float err3 = ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
float err4 = ABS_ERROR(resultPtr[3], expected[3]);
float maxErr = 0.5;
// Check if the result matches.
@@ -1034,10 +1035,13 @@ int validate_image_2D_sRGB_results(void *imageValues, void *resultValues, double
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, NULL );
err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
err2 = ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
err3 = ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
err4 = ABS_ERROR(resultPtr[3], expected[3]);
}
}
@@ -1075,10 +1079,13 @@ int validate_image_2D_sRGB_results(void *imageValues, void *resultValues, double
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, &containsDenormals );
float err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
float err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
float err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 = ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
float err2 = ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
float err3 = ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
float err4 = ABS_ERROR(resultPtr[3], expected[3]);
float maxErr = 0.6;
if( ! (err1 <= maxErr) || ! (err2 <= maxErr) ||
@@ -1099,10 +1106,13 @@ int validate_image_2D_sRGB_results(void *imageValues, void *resultValues, double
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, NULL );
err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
err2 = ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
err3 = ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
err4 = ABS_ERROR(resultPtr[3], expected[3]);
}
}
if( ! (err1 <= maxErr) || ! (err2 <= maxErr) ||

88
test_conformance/images/kernel_read_write/test_read_1D.cpp
View File

@@ -66,8 +66,6 @@ const char *float1DKernelSource =
static const char *samplerKernelArg = " sampler_t imageSampler,";
#define ABS_ERROR( result, expected ) ( fabsf( (float)expected - (float)result ) )
extern void read_image_pixel_float( void *imageData, image_descriptor *imageInfo,
int x, int y, int z, float *outData );
template <class T> int determine_validation_error_1D( void *imagePtr, image_descriptor *imageInfo, image_sampler_data *imageSampler,
@@ -522,10 +520,13 @@ int test_read_image_1D( cl_context context, cl_command_queue queue, cl_kernel ke
xOffsetValues[ j ], 0.0f, 0.0f, norm_offset_x, 0.0f, 0.0f,
imageSampler, expected, 0, &containsDenormals, lod );
float err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
float err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
float err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 = ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
float err2 = ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
float err3 = ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
float err4 = ABS_ERROR(resultPtr[3], expected[3]);
float maxErr = 0.5;
@@ -544,10 +545,13 @@ int test_read_image_1D( cl_context context, cl_command_queue queue, cl_kernel ke
xOffsetValues[ j ], 0.0f, 0.0f, norm_offset_x, 0.0f, 0.0f,
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
err2 = ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
err3 = ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
err4 = ABS_ERROR(resultPtr[3], expected[3]);
}
}
@@ -576,10 +580,14 @@ int test_read_image_1D( cl_context context, cl_command_queue queue, cl_kernel ke
xOffsetValues[ j ], 0.0f, 0.0f, norm_offset_x, 0.0f, 0.0f,
imageSampler, expected, 0, &containsDenormals, lod );
float err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
float err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
float err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 = ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
float err2 = ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
float err3 = ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
float err4 =
ABS_ERROR(resultPtr[3], expected[3]);
float maxErr = 0.6;
@@ -597,10 +605,14 @@ int test_read_image_1D( cl_context context, cl_command_queue queue, cl_kernel ke
xOffsetValues[ j ], 0.0f, 0.0f, norm_offset_x, 0.0f, 0.0f,
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
err2 = ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
err3 = ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
err4 = ABS_ERROR(resultPtr[3],
expected[3]);
}
}
if( ! (err1 <= maxErr) || ! (err2 <= maxErr) ||
@@ -667,10 +679,10 @@ int test_read_image_1D( cl_context context, cl_command_queue queue, cl_kernel ke
xOffsetValues[ j ], 0.0f, 0.0f, norm_offset_x, 0.0f, 0.0f,
imageSampler, expected, 0, &containsDenormals, lod );
float err1 = fabsf( resultPtr[0] - expected[0] );
float err2 = fabsf( resultPtr[1] - expected[1] );
float err3 = fabsf( resultPtr[2] - expected[2] );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 = ABS_ERROR(resultPtr[0], expected[0]);
float err2 = ABS_ERROR(resultPtr[1], expected[1]);
float err3 = ABS_ERROR(resultPtr[2], expected[2]);
float err4 = ABS_ERROR(resultPtr[3], expected[3]);
// Clamp to the minimum absolute error for the format
if (err1 > 0 && err1 < formatAbsoluteError) { err1 = 0.0f; }
if (err2 > 0 && err2 < formatAbsoluteError) { err2 = 0.0f; }
@@ -699,10 +711,10 @@ int test_read_image_1D( cl_context context, cl_command_queue queue, cl_kernel ke
xOffsetValues[ j ], 0.0f, 0.0f, norm_offset_x, 0.0f, 0.0f,
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( resultPtr[0] - expected[0] );
err2 = fabsf( resultPtr[1] - expected[1] );
err3 = fabsf( resultPtr[2] - expected[2] );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(resultPtr[0], expected[0]);
err2 = ABS_ERROR(resultPtr[1], expected[1]);
err3 = ABS_ERROR(resultPtr[2], expected[2]);
err4 = ABS_ERROR(resultPtr[3], expected[3]);
}
}
@@ -731,10 +743,14 @@ int test_read_image_1D( cl_context context, cl_command_queue queue, cl_kernel ke
xOffsetValues[ j ], 0.0f, 0.0f, norm_offset_x, 0.0f, 0.0f,
imageSampler, expected, 0, &containsDenormals, lod );
float err1 = fabsf( resultPtr[0] - expected[0] );
float err2 = fabsf( resultPtr[1] - expected[1] );
float err3 = fabsf( resultPtr[2] - expected[2] );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 =
ABS_ERROR(resultPtr[0], expected[0]);
float err2 =
ABS_ERROR(resultPtr[1], expected[1]);
float err3 =
ABS_ERROR(resultPtr[2], expected[2]);
float err4 =
ABS_ERROR(resultPtr[3], expected[3]);
float maxErr1 = MAX( maxErr * maxPixel.p[0], FLT_MIN );
float maxErr2 = MAX( maxErr * maxPixel.p[1], FLT_MIN );
float maxErr3 = MAX( maxErr * maxPixel.p[2], FLT_MIN );
@@ -756,10 +772,14 @@ int test_read_image_1D( cl_context context, cl_command_queue queue, cl_kernel ke
xOffsetValues[ j ], 0.0f, 0.0f, norm_offset_x, 0.0f, 0.0f,
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( resultPtr[0] - expected[0] );
err2 = fabsf( resultPtr[1] - expected[1] );
err3 = fabsf( resultPtr[2] - expected[2] );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(resultPtr[0],
expected[0]);
err2 = ABS_ERROR(resultPtr[1],
expected[1]);
err3 = ABS_ERROR(resultPtr[2],
expected[2]);
err4 = ABS_ERROR(resultPtr[3],
expected[3]);
}
}
if( ! (err1 <= maxErr1) || ! (err2 <= maxErr2) ||

88
test_conformance/images/kernel_read_write/test_read_1D_array.cpp
View File

@@ -73,8 +73,6 @@ const char *floatKernelSource1DArray =
static const char *samplerKernelArg = " sampler_t imageSampler,";
#define ABS_ERROR( result, expected ) ( fabsf( (float)expected - (float)result ) )
extern void read_image_pixel_float( void *imageData, image_descriptor *imageInfo,
int x, int y, int z, float *outData );
@@ -618,10 +616,13 @@ int test_read_image_1D_array( cl_context context, cl_command_queue queue, cl_ker
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, &containsDenormals, lod );
float err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
float err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
float err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 = ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
float err2 = ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
float err3 = ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
float err4 = ABS_ERROR(resultPtr[3], expected[3]);
float maxErr = 0.5;
// Check if the result matches.
@@ -639,10 +640,13 @@ int test_read_image_1D_array( cl_context context, cl_command_queue queue, cl_ker
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
err2 = ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
err3 = ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
err4 = ABS_ERROR(resultPtr[3], expected[3]);
}
}
@@ -674,10 +678,14 @@ int test_read_image_1D_array( cl_context context, cl_command_queue queue, cl_ker
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, &containsDenormals, lod );
float err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
float err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
float err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 = ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
float err2 = ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
float err3 = ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
float err4 =
ABS_ERROR(resultPtr[3], expected[3]);
float maxErr = 0.6;
@@ -695,10 +703,14 @@ int test_read_image_1D_array( cl_context context, cl_command_queue queue, cl_ker
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
err2 = ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
err3 = ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
err4 = ABS_ERROR(resultPtr[3],
expected[3]);
}
}
if( ! (err1 <= maxErr) || ! (err2 <= maxErr) ||
@@ -772,10 +784,10 @@ int test_read_image_1D_array( cl_context context, cl_command_queue queue, cl_ker
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, &containsDenormals, lod );
float err1 = fabsf( resultPtr[0] - expected[0] );
float err2 = fabsf( resultPtr[1] - expected[1] );
float err3 = fabsf( resultPtr[2] - expected[2] );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 = ABS_ERROR(resultPtr[0], expected[0]);
float err2 = ABS_ERROR(resultPtr[1], expected[1]);
float err3 = ABS_ERROR(resultPtr[2], expected[2]);
float err4 = ABS_ERROR(resultPtr[3], expected[3]);
// Clamp to the minimum absolute error for the format
if (err1 > 0 && err1 < formatAbsoluteError) { err1 = 0.0f; }
if (err2 > 0 && err2 < formatAbsoluteError) { err2 = 0.0f; }
@@ -804,10 +816,10 @@ int test_read_image_1D_array( cl_context context, cl_command_queue queue, cl_ker
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( resultPtr[0] - expected[0] );
err2 = fabsf( resultPtr[1] - expected[1] );
err3 = fabsf( resultPtr[2] - expected[2] );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(resultPtr[0], expected[0]);
err2 = ABS_ERROR(resultPtr[1], expected[1]);
err3 = ABS_ERROR(resultPtr[2], expected[2]);
err4 = ABS_ERROR(resultPtr[3], expected[3]);
}
}
@@ -839,10 +851,14 @@ int test_read_image_1D_array( cl_context context, cl_command_queue queue, cl_ker
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, &containsDenormals, lod );
float err1 = fabsf( resultPtr[0] - expected[0] );
float err2 = fabsf( resultPtr[1] - expected[1] );
float err3 = fabsf( resultPtr[2] - expected[2] );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 =
ABS_ERROR(resultPtr[0], expected[0]);
float err2 =
ABS_ERROR(resultPtr[1], expected[1]);
float err3 =
ABS_ERROR(resultPtr[2], expected[2]);
float err4 =
ABS_ERROR(resultPtr[3], expected[3]);
float maxErr1 = MAX( maxErr * maxPixel.p[0], FLT_MIN );
float maxErr2 = MAX( maxErr * maxPixel.p[1], FLT_MIN );
float maxErr3 = MAX( maxErr * maxPixel.p[2], FLT_MIN );
@@ -864,10 +880,14 @@ int test_read_image_1D_array( cl_context context, cl_command_queue queue, cl_ker
xOffsetValues[ j ], yOffsetValues[ j ], 0.f, norm_offset_x, norm_offset_y, 0.0f,
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( resultPtr[0] - expected[0] );
err2 = fabsf( resultPtr[1] - expected[1] );
err3 = fabsf( resultPtr[2] - expected[2] );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(resultPtr[0],
expected[0]);
err2 = ABS_ERROR(resultPtr[1],
expected[1]);
err3 = ABS_ERROR(resultPtr[2],
expected[2]);
err4 = ABS_ERROR(resultPtr[3],
expected[3]);
}
}
if( ! (err1 <= maxErr1) || ! (err2 <= maxErr2) ||

122
test_conformance/images/kernel_read_write/test_read_2D_array.cpp
View File

@@ -88,8 +88,6 @@ const char *float2DArrayUnnormalizedCoordKernelSource =
static const char *samplerKernelArg = " sampler_t imageSampler,";
#define ABS_ERROR( result, expected ) ( fabsf( (float)expected - (float)result ) )
extern void read_image_pixel_float( void *imageData, image_descriptor *imageInfo, int x, int y, int z, float *outData );
template <class T> int determine_validation_error_offset_2D_array( void *imagePtr, image_descriptor *imageInfo, image_sampler_data *imageSampler,
T *resultPtr, T * expected, float error,
@@ -622,7 +620,8 @@ int test_read_image_2D_array( cl_context context, cl_command_queue queue, cl_ker
norm_offset_x, norm_offset_y, norm_offset_z,
imageSampler, expected, 0, &hasDenormals, lod );
float err1 = fabsf( resultPtr[0] - expected[0] );
float err1 =
ABS_ERROR(resultPtr[0], expected[0]);
// Clamp to the minimum absolute error for the format
if (err1 > 0 && err1 < formatAbsoluteError) { err1 = 0.0f; }
float maxErr1 = MAX( maxErr * maxPixel.p[0], FLT_MIN );
@@ -641,7 +640,8 @@ int test_read_image_2D_array( cl_context context, cl_command_queue queue, cl_ker
norm_offset_x, norm_offset_y, norm_offset_z,
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( resultPtr[0] - expected[0] );
err1 = ABS_ERROR(resultPtr[0],
expected[0]);
}
}
@@ -666,7 +666,8 @@ int test_read_image_2D_array( cl_context context, cl_command_queue queue, cl_ker
norm_offset_x, norm_offset_y, norm_offset_z,
imageSampler, expected, 0, &hasDenormals, lod );
float err1 = fabsf( resultPtr[0] - expected[0] );
float err1 = ABS_ERROR(resultPtr[0],
expected[0]);
float maxErr1 = MAX( maxErr * maxPixel.p[0], FLT_MIN );
@@ -681,7 +682,8 @@ int test_read_image_2D_array( cl_context context, cl_command_queue queue, cl_ker
xOffsetValues[ j ], yOffsetValues[ j ], zOffsetValues[ j ],
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( resultPtr[0] - expected[0] );
err1 = ABS_ERROR(resultPtr[0],
expected[0]);
}
}
@@ -757,10 +759,17 @@ int test_read_image_2D_array( cl_context context, cl_command_queue queue, cl_ker
norm_offset_x, norm_offset_y, norm_offset_z,
imageSampler, expected, 0, &hasDenormals, lod );
float err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
float err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
float err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 =
ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
float err2 =
ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
float err3 =
ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
float err4 =
ABS_ERROR(resultPtr[3], expected[3]);
float maxErr = 0.5;
if( ! (err1 <= maxErr) || ! (err2 <= maxErr) || ! (err3 <= maxErr) || ! (err4 <= maxErr) )
@@ -777,10 +786,17 @@ int test_read_image_2D_array( cl_context context, cl_command_queue queue, cl_ker
norm_offset_x, norm_offset_y, norm_offset_z,
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 =
ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
err2 =
ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
err3 =
ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
err4 = ABS_ERROR(resultPtr[3],
expected[3]);
}
}
@@ -805,10 +821,17 @@ int test_read_image_2D_array( cl_context context, cl_command_queue queue, cl_ker
norm_offset_x, norm_offset_y, norm_offset_z,
imageSampler, expected, 0, &hasDenormals, lod );
float err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
float err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
float err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 =
ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
float err2 =
ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
float err3 =
ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
float err4 = ABS_ERROR(resultPtr[3],
expected[3]);
float maxErr = 0.6;
if( ! (err1 <= maxErr) || ! (err2 <= maxErr) || ! (err3 <= maxErr) || ! (err4 <= maxErr) )
@@ -824,10 +847,17 @@ int test_read_image_2D_array( cl_context context, cl_command_queue queue, cl_ker
xOffsetValues[ j ], yOffsetValues[ j ], zOffsetValues[ j ],
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(
sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
err2 = ABS_ERROR(
sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
err3 = ABS_ERROR(
sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
err4 = ABS_ERROR(resultPtr[3],
expected[3]);
}
}
@@ -906,10 +936,14 @@ int test_read_image_2D_array( cl_context context, cl_command_queue queue, cl_ker
norm_offset_x, norm_offset_y, norm_offset_z,
imageSampler, expected, 0, &hasDenormals, lod );
float err1 = fabsf( resultPtr[0] - expected[0] );
float err2 = fabsf( resultPtr[1] - expected[1] );
float err3 = fabsf( resultPtr[2] - expected[2] );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 =
ABS_ERROR(resultPtr[0], expected[0]);
float err2 =
ABS_ERROR(resultPtr[1], expected[1]);
float err3 =
ABS_ERROR(resultPtr[2], expected[2]);
float err4 =
ABS_ERROR(resultPtr[3], expected[3]);
// Clamp to the minimum absolute error for the format
if (err1 > 0 && err1 < formatAbsoluteError) { err1 = 0.0f; }
if (err2 > 0 && err2 < formatAbsoluteError) { err2 = 0.0f; }
@@ -937,10 +971,14 @@ int test_read_image_2D_array( cl_context context, cl_command_queue queue, cl_ker
norm_offset_x, norm_offset_y, norm_offset_z,
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( resultPtr[0] - expected[0] );
err2 = fabsf( resultPtr[1] - expected[1] );
err3 = fabsf( resultPtr[2] - expected[2] );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(resultPtr[0],
expected[0]);
err2 = ABS_ERROR(resultPtr[1],
expected[1]);
err3 = ABS_ERROR(resultPtr[2],
expected[2]);
err4 = ABS_ERROR(resultPtr[3],
expected[3]);
}
}
@@ -965,10 +1003,14 @@ int test_read_image_2D_array( cl_context context, cl_command_queue queue, cl_ker
norm_offset_x, norm_offset_y, norm_offset_z,
imageSampler, expected, 0, &hasDenormals, lod );
float err1 = fabsf( resultPtr[0] - expected[0] );
float err2 = fabsf( resultPtr[1] - expected[1] );
float err3 = fabsf( resultPtr[2] - expected[2] );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 = ABS_ERROR(resultPtr[0],
expected[0]);
float err2 = ABS_ERROR(resultPtr[1],
expected[1]);
float err3 = ABS_ERROR(resultPtr[2],
expected[2]);
float err4 = ABS_ERROR(resultPtr[3],
expected[3]);
float maxErr1 = MAX( maxErr * maxPixel.p[0], FLT_MIN );
float maxErr2 = MAX( maxErr * maxPixel.p[1], FLT_MIN );
float maxErr3 = MAX( maxErr * maxPixel.p[2], FLT_MIN );
@@ -989,10 +1031,14 @@ int test_read_image_2D_array( cl_context context, cl_command_queue queue, cl_ker
xOffsetValues[ j ], yOffsetValues[ j ], zOffsetValues[ j ],
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( resultPtr[0] - expected[0] );
err2 = fabsf( resultPtr[1] - expected[1] );
err3 = fabsf( resultPtr[2] - expected[2] );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(resultPtr[0],
expected[0]);
err2 = ABS_ERROR(resultPtr[1],
expected[1]);
err3 = ABS_ERROR(resultPtr[2],
expected[2]);
err4 = ABS_ERROR(resultPtr[3],
expected[3]);
}
}

114
test_conformance/images/kernel_read_write/test_read_3D.cpp
View File

@@ -88,8 +88,6 @@ const char *float3DUnnormalizedCoordKernelSource =
static const char *samplerKernelArg = " sampler_t imageSampler,";
#define ABS_ERROR( result, expected ) ( fabsf( (float)expected - (float)result ) )
extern void read_image_pixel_float( void *imageData, image_descriptor *imageInfo, int x, int y, int z, float *outData );
template <class T> int determine_validation_error_offset( void *imagePtr, image_descriptor *imageInfo, image_sampler_data *imageSampler,
T *resultPtr, T * expected, float error,
@@ -638,10 +636,17 @@ int test_read_image_3D( cl_context context, cl_command_queue queue, cl_kernel ke
norm_offset_x, norm_offset_y, norm_offset_z,
imageSampler, expected, 0, &hasDenormals, lod );
float err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
float err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
float err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 =
ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
float err2 =
ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
float err3 =
ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
float err4 =
ABS_ERROR(resultPtr[3], expected[3]);
// Clamp to the minimum absolute error for the format
if (err1 > 0 && err1 < formatAbsoluteError) { err1 = 0.0f; }
if (err2 > 0 && err2 < formatAbsoluteError) { err2 = 0.0f; }
@@ -663,10 +668,17 @@ int test_read_image_3D( cl_context context, cl_command_queue queue, cl_kernel ke
norm_offset_x, norm_offset_y, norm_offset_z,
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 =
ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
err2 =
ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
err3 =
ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
err4 = ABS_ERROR(resultPtr[3],
expected[3]);
}
}
@@ -691,10 +703,17 @@ int test_read_image_3D( cl_context context, cl_command_queue queue, cl_kernel ke
norm_offset_x, norm_offset_y, norm_offset_z,
imageSampler, expected, 0, &hasDenormals, lod );
float err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
float err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
float err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 =
ABS_ERROR(sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
float err2 =
ABS_ERROR(sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
float err3 =
ABS_ERROR(sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
float err4 = ABS_ERROR(resultPtr[3],
expected[3]);
float maxErr = 0.6;
if( ! (err1 <= maxErr) || ! (err2 <= maxErr) || ! (err3 <= maxErr) || ! (err4 <= maxErr) )
@@ -710,10 +729,17 @@ int test_read_image_3D( cl_context context, cl_command_queue queue, cl_kernel ke
xOffsetValues[ j ], yOffsetValues[ j ], zOffsetValues[ j ],
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( sRGBmap( resultPtr[0] ) - sRGBmap( expected[0] ) );
err2 = fabsf( sRGBmap( resultPtr[1] ) - sRGBmap( expected[1] ) );
err3 = fabsf( sRGBmap( resultPtr[2] ) - sRGBmap( expected[2] ) );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(
sRGBmap(resultPtr[0]),
sRGBmap(expected[0]));
err2 = ABS_ERROR(
sRGBmap(resultPtr[1]),
sRGBmap(expected[1]));
err3 = ABS_ERROR(
sRGBmap(resultPtr[2]),
sRGBmap(expected[2]));
err4 = ABS_ERROR(resultPtr[3],
expected[3]);
}
}
@@ -792,10 +818,14 @@ int test_read_image_3D( cl_context context, cl_command_queue queue, cl_kernel ke
norm_offset_x, norm_offset_y, norm_offset_z,
imageSampler, expected, 0, &hasDenormals, lod );
float err1 = fabsf( resultPtr[0] - expected[0] );
float err2 = fabsf( resultPtr[1] - expected[1] );
float err3 = fabsf( resultPtr[2] - expected[2] );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 =
ABS_ERROR(resultPtr[0], expected[0]);
float err2 =
ABS_ERROR(resultPtr[1], expected[1]);
float err3 =
ABS_ERROR(resultPtr[2], expected[2]);
float err4 =
ABS_ERROR(resultPtr[3], expected[3]);
// Clamp to the minimum absolute error for the format
if (err1 > 0 && err1 < formatAbsoluteError) { err1 = 0.0f; }
if (err2 > 0 && err2 < formatAbsoluteError) { err2 = 0.0f; }
@@ -823,10 +853,14 @@ int test_read_image_3D( cl_context context, cl_command_queue queue, cl_kernel ke
norm_offset_x, norm_offset_y, norm_offset_z,
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( resultPtr[0] - expected[0] );
err2 = fabsf( resultPtr[1] - expected[1] );
err3 = fabsf( resultPtr[2] - expected[2] );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(resultPtr[0],
expected[0]);
err2 = ABS_ERROR(resultPtr[1],
expected[1]);
err3 = ABS_ERROR(resultPtr[2],
expected[2]);
err4 = ABS_ERROR(resultPtr[3],
expected[3]);
}
}
@@ -851,10 +885,14 @@ int test_read_image_3D( cl_context context, cl_command_queue queue, cl_kernel ke
norm_offset_x, norm_offset_y, norm_offset_z,
imageSampler, expected, 0, &hasDenormals, lod );
float err1 = fabsf( resultPtr[0] - expected[0] );
float err2 = fabsf( resultPtr[1] - expected[1] );
float err3 = fabsf( resultPtr[2] - expected[2] );
float err4 = fabsf( resultPtr[3] - expected[3] );
float err1 = ABS_ERROR(resultPtr[0],
expected[0]);
float err2 = ABS_ERROR(resultPtr[1],
expected[1]);
float err3 = ABS_ERROR(resultPtr[2],
expected[2]);
float err4 = ABS_ERROR(resultPtr[3],
expected[3]);
float maxErr1 = MAX( maxErr * maxPixel.p[0], FLT_MIN );
float maxErr2 = MAX( maxErr * maxPixel.p[1], FLT_MIN );
float maxErr3 = MAX( maxErr * maxPixel.p[2], FLT_MIN );
@@ -875,10 +913,14 @@ int test_read_image_3D( cl_context context, cl_command_queue queue, cl_kernel ke
xOffsetValues[ j ], yOffsetValues[ j ], zOffsetValues[ j ],
imageSampler, expected, 0, NULL, lod );
err1 = fabsf( resultPtr[0] - expected[0] );
err2 = fabsf( resultPtr[1] - expected[1] );
err3 = fabsf( resultPtr[2] - expected[2] );
err4 = fabsf( resultPtr[3] - expected[3] );
err1 = ABS_ERROR(resultPtr[0],
expected[0]);
err2 = ABS_ERROR(resultPtr[1],
expected[1]);
err3 = ABS_ERROR(resultPtr[2],
expected[2]);
err4 = ABS_ERROR(resultPtr[3],
expected[3]);
}
}
@@ -1311,7 +1353,3 @@ int test_read_image_set_3D( cl_device_id device, cl_context context, cl_command_
return 0;
}