mirror of
https://github.com/KhronosGroup/OpenCL-CTS.git
synced 2026-03-19 06:09:01 +00:00
3320035581
- Remove the requirement to detail values for device queries and list extensions in the submission template. They are printed by computeinfo. - Require that tests skipped in accordance with the conformance process be listed in the submission template. - Remove support for OPENCL_1_0_DEVICE. This variable doesn't control anything anymore and the updated conformance process no longer refers to it. - Require that implementations running via a loader document the loader that was used. Signed-off-by: Kevin Petit <kevin.petit@arm.com>
1102 lines
36 KiB
C++
1102 lines
36 KiB
C++
//
|
|
// Copyright (c) 2017-2019 The Khronos Group Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
#include "testHarness.h"
|
|
#include "compat.h"
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <cassert>
|
|
#include <stdexcept>
|
|
#include <vector>
|
|
#include "threadTesting.h"
|
|
#include "errorHelpers.h"
|
|
#include "kernelHelpers.h"
|
|
#include "fpcontrol.h"
|
|
#include "typeWrappers.h"
|
|
#include "imageHelpers.h"
|
|
#include "parseParameters.h"
|
|
|
|
#if !defined(_WIN32)
|
|
#include <sys/utsname.h>
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#if defined(__APPLE__)
|
|
#include <sys/sysctl.h>
|
|
#endif
|
|
|
|
#include <time.h>
|
|
|
|
#if !defined (__APPLE__)
|
|
#include <CL/cl.h>
|
|
#endif
|
|
|
|
int gTestsPassed = 0;
|
|
int gTestsFailed = 0;
|
|
int gFailCount;
|
|
int gTestCount;
|
|
cl_uint gRandomSeed = 0;
|
|
cl_uint gReSeed = 0;
|
|
|
|
int gFlushDenormsToZero = 0;
|
|
int gInfNanSupport = 1;
|
|
int gIsEmbedded = 0;
|
|
int gHasLong = 1;
|
|
bool gCoreILProgram = true;
|
|
|
|
#define DEFAULT_NUM_ELEMENTS 0x4000
|
|
|
|
int runTestHarness( int argc, const char *argv[], int testNum, test_definition testList[],
|
|
int imageSupportRequired, int forceNoContextCreation, cl_command_queue_properties queueProps )
|
|
{
|
|
return runTestHarnessWithCheck( argc, argv, testNum, testList, forceNoContextCreation, queueProps,
|
|
( imageSupportRequired ) ? verifyImageSupport : NULL );
|
|
}
|
|
|
|
int skip_init_info(int count) {
|
|
log_info("Test skipped while initialization\n");
|
|
log_info("SKIPPED %d of %d tests.\n", count, count);
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
int fail_init_info(int count) {
|
|
log_info("Test failed while initialization\n");
|
|
log_info("FAILED %d of %d tests.\n", count, count);
|
|
return EXIT_FAILURE;
|
|
}
|
|
void version_expected_info(const char *test_name, const char *api_name,
|
|
const char *expected_version,
|
|
const char *device_version)
|
|
{
|
|
log_info("%s skipped (requires at least %s version %s, but the device "
|
|
"reports %s version %s)\n",
|
|
test_name, api_name, expected_version, api_name, device_version);
|
|
}
|
|
int runTestHarnessWithCheck( int argc, const char *argv[], int testNum, test_definition testList[],
|
|
int forceNoContextCreation, cl_command_queue_properties queueProps,
|
|
DeviceCheckFn deviceCheckFn )
|
|
{
|
|
test_start();
|
|
|
|
cl_device_type device_type = CL_DEVICE_TYPE_DEFAULT;
|
|
cl_uint num_platforms = 0;
|
|
cl_platform_id *platforms;
|
|
cl_device_id device;
|
|
int num_elements = DEFAULT_NUM_ELEMENTS;
|
|
cl_uint num_devices = 0;
|
|
cl_device_id *devices = NULL;
|
|
cl_uint choosen_device_index = 0;
|
|
cl_uint choosen_platform_index = 0;
|
|
|
|
int err, ret;
|
|
char *endPtr;
|
|
int based_on_env_var = 0;
|
|
|
|
|
|
/* Check for environment variable to set device type */
|
|
char *env_mode = getenv( "CL_DEVICE_TYPE" );
|
|
if( env_mode != NULL )
|
|
{
|
|
based_on_env_var = 1;
|
|
if( strcmp( env_mode, "gpu" ) == 0 || strcmp( env_mode, "CL_DEVICE_TYPE_GPU" ) == 0 )
|
|
device_type = CL_DEVICE_TYPE_GPU;
|
|
else if( strcmp( env_mode, "cpu" ) == 0 || strcmp( env_mode, "CL_DEVICE_TYPE_CPU" ) == 0 )
|
|
device_type = CL_DEVICE_TYPE_CPU;
|
|
else if( strcmp( env_mode, "accelerator" ) == 0 || strcmp( env_mode, "CL_DEVICE_TYPE_ACCELERATOR" ) == 0 )
|
|
device_type = CL_DEVICE_TYPE_ACCELERATOR;
|
|
else if( strcmp( env_mode, "default" ) == 0 || strcmp( env_mode, "CL_DEVICE_TYPE_DEFAULT" ) == 0 )
|
|
device_type = CL_DEVICE_TYPE_DEFAULT;
|
|
else
|
|
{
|
|
log_error( "Unknown CL_DEVICE_TYPE env variable setting: %s.\nAborting...\n", env_mode );
|
|
abort();
|
|
}
|
|
}
|
|
|
|
#if defined( __APPLE__ )
|
|
{
|
|
// report on any unusual library search path indirection
|
|
char *libSearchPath = getenv( "DYLD_LIBRARY_PATH");
|
|
if( libSearchPath )
|
|
log_info( "*** DYLD_LIBRARY_PATH = \"%s\"\n", libSearchPath );
|
|
|
|
// report on any unusual framework search path indirection
|
|
char *frameworkSearchPath = getenv( "DYLD_FRAMEWORK_PATH");
|
|
if( libSearchPath )
|
|
log_info( "*** DYLD_FRAMEWORK_PATH = \"%s\"\n", frameworkSearchPath );
|
|
}
|
|
#endif
|
|
|
|
env_mode = getenv( "CL_DEVICE_INDEX" );
|
|
if( env_mode != NULL )
|
|
{
|
|
choosen_device_index = atoi(env_mode);
|
|
}
|
|
|
|
env_mode = getenv( "CL_PLATFORM_INDEX" );
|
|
if( env_mode != NULL )
|
|
{
|
|
choosen_platform_index = atoi(env_mode);
|
|
}
|
|
|
|
/* Process the command line arguments */
|
|
|
|
argc = parseCustomParam(argc, argv);
|
|
if (argc == -1)
|
|
{
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
/* Special case: just list the tests */
|
|
if( ( argc > 1 ) && (!strcmp( argv[ 1 ], "-list" ) || !strcmp( argv[ 1 ], "-h" ) || !strcmp( argv[ 1 ], "--help" )))
|
|
{
|
|
char *fileName = getenv("CL_CONFORMANCE_RESULTS_FILENAME");
|
|
|
|
log_info( "Usage: %s [<test name>*] [pid<num>] [id<num>] [<device type>]\n", argv[0] );
|
|
log_info( "\t<test name>\tOne or more of: (wildcard character '*') (default *)\n");
|
|
log_info( "\tpid<num>\tIndicates platform at index <num> should be used (default 0).\n" );
|
|
log_info( "\tid<num>\t\tIndicates device at index <num> should be used (default 0).\n" );
|
|
log_info( "\t<device_type>\tcpu|gpu|accelerator|<CL_DEVICE_TYPE_*> (default CL_DEVICE_TYPE_DEFAULT)\n" );
|
|
log_info( "\n" );
|
|
log_info( "\tNOTE: You may pass environment variable CL_CONFORMANCE_RESULTS_FILENAME (currently '%s')\n",
|
|
fileName != NULL ? fileName : "<undefined>" );
|
|
log_info( "\t to save results to JSON file.\n" );
|
|
|
|
log_info( "\n" );
|
|
log_info( "Test names:\n" );
|
|
for( int i = 0; i < testNum; i++ )
|
|
{
|
|
log_info( "\t%s\n", testList[i].name );
|
|
}
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
/* How are we supposed to seed the random # generators? */
|
|
if( argc > 1 && strcmp( argv[ argc - 1 ], "randomize" ) == 0 )
|
|
{
|
|
gRandomSeed = (cl_uint) time( NULL );
|
|
log_info( "Random seed: %u.\n", gRandomSeed );
|
|
gReSeed = 1;
|
|
argc--;
|
|
}
|
|
else
|
|
{
|
|
log_info(" Initializing random seed to 0.\n");
|
|
}
|
|
|
|
/* Do we have an integer to specify the number of elements to pass to tests? */
|
|
if( argc > 1 )
|
|
{
|
|
ret = (int)strtol( argv[ argc - 1 ], &endPtr, 10 );
|
|
if( endPtr != argv[ argc - 1 ] && *endPtr == 0 )
|
|
{
|
|
/* By spec, this means the entire string was a valid integer, so we treat it as a num_elements spec */
|
|
/* (hence why we stored the result in ret first) */
|
|
num_elements = ret;
|
|
log_info( "Testing with num_elements of %d\n", num_elements );
|
|
argc--;
|
|
}
|
|
}
|
|
|
|
/* Do we have a CPU/GPU specification? */
|
|
if( argc > 1 )
|
|
{
|
|
if( strcmp( argv[ argc - 1 ], "gpu" ) == 0 || strcmp( argv[ argc - 1 ], "CL_DEVICE_TYPE_GPU" ) == 0 )
|
|
{
|
|
device_type = CL_DEVICE_TYPE_GPU;
|
|
argc--;
|
|
}
|
|
else if( strcmp( argv[ argc - 1 ], "cpu" ) == 0 || strcmp( argv[ argc - 1 ], "CL_DEVICE_TYPE_CPU" ) == 0 )
|
|
{
|
|
device_type = CL_DEVICE_TYPE_CPU;
|
|
argc--;
|
|
}
|
|
else if( strcmp( argv[ argc - 1 ], "accelerator" ) == 0 || strcmp( argv[ argc - 1 ], "CL_DEVICE_TYPE_ACCELERATOR" ) == 0 )
|
|
{
|
|
device_type = CL_DEVICE_TYPE_ACCELERATOR;
|
|
argc--;
|
|
}
|
|
else if( strcmp( argv[ argc - 1 ], "CL_DEVICE_TYPE_DEFAULT" ) == 0 )
|
|
{
|
|
device_type = CL_DEVICE_TYPE_DEFAULT;
|
|
argc--;
|
|
}
|
|
}
|
|
|
|
/* Did we choose a specific device index? */
|
|
if( argc > 1 )
|
|
{
|
|
if( strlen( argv[ argc - 1 ] ) >= 3 && argv[ argc - 1 ][0] == 'i' && argv[ argc - 1 ][1] == 'd' )
|
|
{
|
|
choosen_device_index = atoi( &(argv[ argc - 1 ][2]) );
|
|
argc--;
|
|
}
|
|
}
|
|
|
|
/* Did we choose a specific platform index? */
|
|
if( argc > 1 )
|
|
{
|
|
if( strlen( argv[ argc - 1 ] ) >= 3 && argv[ argc - 1 ][0] == 'p' && argv[ argc - 1 ][1] == 'i' && argv[ argc - 1 ][2] == 'd')
|
|
{
|
|
choosen_platform_index = atoi( &(argv[ argc - 1 ][3]) );
|
|
argc--;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
switch (device_type)
|
|
{
|
|
case CL_DEVICE_TYPE_GPU: log_info("Requesting GPU device "); break;
|
|
case CL_DEVICE_TYPE_CPU: log_info("Requesting CPU device "); break;
|
|
case CL_DEVICE_TYPE_ACCELERATOR: log_info("Requesting Accelerator device "); break;
|
|
case CL_DEVICE_TYPE_DEFAULT: log_info("Requesting Default device "); break;
|
|
default: log_error("Requesting unknown device "); return EXIT_FAILURE;
|
|
}
|
|
log_info(based_on_env_var ? "based on environment variable " : "based on command line ");
|
|
log_info("for platform index %d and device index %d\n", choosen_platform_index, choosen_device_index);
|
|
|
|
#if defined( __APPLE__ )
|
|
#if defined( __i386__ ) || defined( __x86_64__ )
|
|
#define kHasSSE3 0x00000008
|
|
#define kHasSupplementalSSE3 0x00000100
|
|
#define kHasSSE4_1 0x00000400
|
|
#define kHasSSE4_2 0x00000800
|
|
/* check our environment for a hint to disable SSE variants */
|
|
{
|
|
const char *env = getenv( "CL_MAX_SSE" );
|
|
if( env )
|
|
{
|
|
extern int _cpu_capabilities;
|
|
int mask = 0;
|
|
if( 0 == strcasecmp( env, "SSE4.1" ) )
|
|
mask = kHasSSE4_2;
|
|
else if( 0 == strcasecmp( env, "SSSE3" ) )
|
|
mask = kHasSSE4_2 | kHasSSE4_1;
|
|
else if( 0 == strcasecmp( env, "SSE3" ) )
|
|
mask = kHasSSE4_2 | kHasSSE4_1 | kHasSupplementalSSE3;
|
|
else if( 0 == strcasecmp( env, "SSE2" ) )
|
|
mask = kHasSSE4_2 | kHasSSE4_1 | kHasSupplementalSSE3 | kHasSSE3;
|
|
else
|
|
{
|
|
log_error( "Error: Unknown CL_MAX_SSE setting: %s\n", env );
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
log_info( "*** Environment: CL_MAX_SSE = %s ***\n", env );
|
|
_cpu_capabilities &= ~mask;
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
/* Get the platform */
|
|
err = clGetPlatformIDs(0, NULL, &num_platforms);
|
|
if (err) {
|
|
print_error(err, "clGetPlatformIDs failed");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
platforms = (cl_platform_id *) malloc( num_platforms * sizeof( cl_platform_id ) );
|
|
if (!platforms || choosen_platform_index >= num_platforms) {
|
|
log_error( "platform index out of range -- choosen_platform_index (%d) >= num_platforms (%d)\n", choosen_platform_index, num_platforms );
|
|
return EXIT_FAILURE;
|
|
}
|
|
BufferOwningPtr<cl_platform_id> platformsBuf(platforms);
|
|
|
|
err = clGetPlatformIDs(num_platforms, platforms, NULL);
|
|
if (err) {
|
|
print_error(err, "clGetPlatformIDs failed");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
/* Get the number of requested devices */
|
|
err = clGetDeviceIDs(platforms[choosen_platform_index], device_type, 0, NULL, &num_devices );
|
|
if (err) {
|
|
print_error(err, "clGetDeviceIDs failed");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
devices = (cl_device_id *) malloc( num_devices * sizeof( cl_device_id ) );
|
|
if (!devices || choosen_device_index >= num_devices) {
|
|
log_error( "device index out of range -- choosen_device_index (%d) >= num_devices (%d)\n", choosen_device_index, num_devices );
|
|
return EXIT_FAILURE;
|
|
}
|
|
BufferOwningPtr<cl_device_id> devicesBuf(devices);
|
|
|
|
|
|
/* Get the requested device */
|
|
err = clGetDeviceIDs(platforms[choosen_platform_index], device_type, num_devices, devices, NULL );
|
|
if (err) {
|
|
print_error(err, "clGetDeviceIDs failed");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
device = devices[choosen_device_index];
|
|
|
|
err = clGetDeviceInfo( device, CL_DEVICE_TYPE, sizeof(gDeviceType), &gDeviceType, NULL );
|
|
if( err )
|
|
{
|
|
print_error( err, "Unable to get device type" );
|
|
return TEST_FAIL;
|
|
}
|
|
|
|
if( printDeviceHeader( device ) != CL_SUCCESS )
|
|
{
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
cl_device_fp_config fpconfig = 0;
|
|
err = clGetDeviceInfo( device, CL_DEVICE_SINGLE_FP_CONFIG, sizeof( fpconfig ), &fpconfig, NULL );
|
|
if (err) {
|
|
print_error(err, "clGetDeviceInfo for CL_DEVICE_SINGLE_FP_CONFIG failed");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
gFlushDenormsToZero = ( 0 == (fpconfig & CL_FP_DENORM));
|
|
log_info( "Supports single precision denormals: %s\n", gFlushDenormsToZero ? "NO" : "YES" );
|
|
log_info( "sizeof( void*) = %d (host)\n", (int) sizeof( void* ) );
|
|
|
|
//detect whether profile of the device is embedded
|
|
char profile[1024] = "";
|
|
err = clGetDeviceInfo(device, CL_DEVICE_PROFILE, sizeof(profile), profile, NULL);
|
|
if (err)
|
|
{
|
|
print_error(err, "clGetDeviceInfo for CL_DEVICE_PROFILE failed\n" );
|
|
return EXIT_FAILURE;
|
|
}
|
|
gIsEmbedded = NULL != strstr(profile, "EMBEDDED_PROFILE");
|
|
|
|
//detect the floating point capabilities
|
|
cl_device_fp_config floatCapabilities = 0;
|
|
err = clGetDeviceInfo(device, CL_DEVICE_SINGLE_FP_CONFIG, sizeof(floatCapabilities), &floatCapabilities, NULL);
|
|
if (err)
|
|
{
|
|
print_error(err, "clGetDeviceInfo for CL_DEVICE_SINGLE_FP_CONFIG failed\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
// Check for problems that only embedded will have
|
|
if( gIsEmbedded )
|
|
{
|
|
//If the device is embedded, we need to detect if the device supports Infinity and NaN
|
|
if ((floatCapabilities & CL_FP_INF_NAN) == 0)
|
|
gInfNanSupport = 0;
|
|
|
|
// check the extensions list to see if ulong and long are supported
|
|
if( !is_extension_available(device, "cles_khr_int64" ))
|
|
gHasLong = 0;
|
|
}
|
|
|
|
cl_uint device_address_bits = 0;
|
|
if( (err = clGetDeviceInfo( device, CL_DEVICE_ADDRESS_BITS, sizeof( device_address_bits ), &device_address_bits, NULL ) ))
|
|
{
|
|
print_error( err, "Unable to obtain device address bits" );
|
|
return EXIT_FAILURE;
|
|
}
|
|
if( device_address_bits )
|
|
log_info( "sizeof( void*) = %d (device)\n", device_address_bits/8 );
|
|
else
|
|
{
|
|
log_error("Invalid device address bit size returned by device.\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
if (gCompilationMode == kSpir_v)
|
|
{
|
|
test_status spirv_readiness = check_spirv_compilation_readiness(device);
|
|
if (spirv_readiness != TEST_PASS)
|
|
{
|
|
switch (spirv_readiness)
|
|
{
|
|
case TEST_PASS: break;
|
|
case TEST_FAIL: return fail_init_info(testNum);
|
|
case TEST_SKIP: return skip_init_info(testNum);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* If we have a device checking function, run it */
|
|
if( ( deviceCheckFn != NULL ) )
|
|
{
|
|
test_status status = deviceCheckFn( device );
|
|
switch (status)
|
|
{
|
|
case TEST_PASS:
|
|
break;
|
|
case TEST_FAIL:
|
|
return fail_init_info(testNum);
|
|
case TEST_SKIP:
|
|
return skip_init_info(testNum);
|
|
}
|
|
}
|
|
|
|
if (num_elements <= 0)
|
|
num_elements = DEFAULT_NUM_ELEMENTS;
|
|
|
|
// On most platforms which support denorm, default is FTZ off. However,
|
|
// on some hardware where the reference is computed, default might be flush denorms to zero e.g. arm.
|
|
// This creates issues in result verification. Since spec allows the implementation to either flush or
|
|
// not flush denorms to zero, an implementation may choose not be flush i.e. return denorm result whereas
|
|
// reference result may be zero (flushed denorm). Hence we need to disable denorm flushing on host side
|
|
// where reference is being computed to make sure we get non-flushed reference result. If implementation
|
|
// returns flushed result, we correctly take care of that in verification code.
|
|
#if defined(__APPLE__) && defined(__arm__)
|
|
FPU_mode_type oldMode;
|
|
DisableFTZ( &oldMode );
|
|
#endif
|
|
|
|
int error = parseAndCallCommandLineTests( argc, argv, device, testNum, testList, forceNoContextCreation, queueProps, num_elements );
|
|
|
|
#if defined(__APPLE__) && defined(__arm__)
|
|
// Restore the old FP mode before leaving.
|
|
RestoreFPState( &oldMode );
|
|
#endif
|
|
|
|
return (error == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
|
|
}
|
|
|
|
static int find_matching_tests( test_definition testList[], unsigned char selectedTestList[], int testNum,
|
|
const char *argument, bool isWildcard )
|
|
{
|
|
int found_tests = 0;
|
|
size_t wildcard_length = strlen( argument ) - 1; /* -1 for the asterisk */
|
|
|
|
for( int i = 0; i < testNum; i++ )
|
|
{
|
|
if( ( !isWildcard && strcmp( testList[i].name, argument ) == 0 ) ||
|
|
( isWildcard && strncmp( testList[i].name, argument, wildcard_length ) == 0 ) )
|
|
{
|
|
if( selectedTestList[i] )
|
|
{
|
|
log_error( "ERROR: Test '%s' has already been selected.\n", testList[i].name );
|
|
return EXIT_FAILURE;
|
|
}
|
|
else if( testList[i].func == NULL )
|
|
{
|
|
log_error( "ERROR: Test '%s' is missing implementation.\n", testList[i].name );
|
|
return EXIT_FAILURE;
|
|
}
|
|
else
|
|
{
|
|
selectedTestList[i] = 1;
|
|
found_tests = 1;
|
|
if( !isWildcard )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !found_tests )
|
|
{
|
|
log_error( "ERROR: The argument '%s' did not match any test names.\n", argument );
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
static int saveResultsToJson( const char *fileName, const char *suiteName, test_definition testList[],
|
|
unsigned char selectedTestList[], test_status resultTestList[], int testNum )
|
|
{
|
|
FILE *file = fopen( fileName, "w" );
|
|
if( NULL == file )
|
|
{
|
|
log_error( "ERROR: Failed to open '%s' for writing results.\n", fileName );
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
const char *save_map[] = { "success", "failure" };
|
|
const char *result_map[] = { "pass", "fail", "skip" };
|
|
const char *linebreak[] = { "", ",\n" };
|
|
int add_linebreak = 0;
|
|
|
|
fprintf( file, "{\n" );
|
|
fprintf( file, "\t\"cmd\": \"%s\",\n", suiteName );
|
|
fprintf( file, "\t\"results\": {\n" );
|
|
|
|
for( int i = 0; i < testNum; ++i )
|
|
{
|
|
if( selectedTestList[i] )
|
|
{
|
|
fprintf( file, "%s\t\t\"%s\": \"%s\"", linebreak[add_linebreak], testList[i].name, result_map[(int)resultTestList[i]] );
|
|
add_linebreak = 1;
|
|
}
|
|
}
|
|
fprintf( file, "\n");
|
|
|
|
fprintf( file, "\t}\n" );
|
|
fprintf( file, "}\n" );
|
|
|
|
int ret = fclose( file ) ? 1 : 0;
|
|
|
|
log_info( "Saving results to %s: %s!\n", fileName, save_map[ret] );
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void print_results( int failed, int count, const char* name )
|
|
{
|
|
if( count < failed )
|
|
{
|
|
count = failed;
|
|
}
|
|
|
|
if( failed == 0 )
|
|
{
|
|
if( count > 1 )
|
|
{
|
|
log_info( "PASSED %d of %d %ss.\n", count, count, name );
|
|
}
|
|
else
|
|
{
|
|
log_info( "PASSED %s.\n", name );
|
|
}
|
|
}
|
|
else if( failed > 0 )
|
|
{
|
|
if( count > 1 )
|
|
{
|
|
log_error( "FAILED %d of %d %ss.\n", failed, count, name );
|
|
}
|
|
else
|
|
{
|
|
log_error( "FAILED %s.\n", name );
|
|
}
|
|
}
|
|
}
|
|
|
|
int parseAndCallCommandLineTests( int argc, const char *argv[], cl_device_id device, int testNum,
|
|
test_definition testList[], int forceNoContextCreation,
|
|
cl_command_queue_properties queueProps, int num_elements )
|
|
{
|
|
int ret = EXIT_SUCCESS;
|
|
|
|
unsigned char *selectedTestList = ( unsigned char* ) calloc( testNum, 1 );
|
|
test_status *resultTestList = NULL;
|
|
|
|
if( argc == 1 )
|
|
{
|
|
/* No actual arguments, all tests will be run. */
|
|
memset( selectedTestList, 1, testNum );
|
|
}
|
|
else
|
|
{
|
|
for( int i = 1; i < argc; i++ )
|
|
{
|
|
if( strchr( argv[i], '*' ) != NULL )
|
|
{
|
|
ret = find_matching_tests( testList, selectedTestList, testNum, argv[i], true );
|
|
}
|
|
else
|
|
{
|
|
if( strcmp( argv[i], "all" ) == 0 )
|
|
{
|
|
memset( selectedTestList, 1, testNum );
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
ret = find_matching_tests( testList, selectedTestList, testNum, argv[i], false );
|
|
}
|
|
}
|
|
|
|
if( ret == EXIT_FAILURE )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( ret == EXIT_SUCCESS )
|
|
{
|
|
resultTestList = ( test_status* ) calloc( testNum, sizeof(*resultTestList) );
|
|
|
|
callTestFunctions( testList, selectedTestList, resultTestList, testNum, device,
|
|
forceNoContextCreation, num_elements, queueProps );
|
|
|
|
print_results( gFailCount, gTestCount, "sub-test" );
|
|
print_results( gTestsFailed, gTestsFailed + gTestsPassed, "test" );
|
|
|
|
char *filename = getenv( "CL_CONFORMANCE_RESULTS_FILENAME" );
|
|
if( filename != NULL )
|
|
{
|
|
ret = saveResultsToJson( filename, argv[0], testList, selectedTestList, resultTestList, testNum );
|
|
}
|
|
}
|
|
|
|
free( selectedTestList );
|
|
free( resultTestList );
|
|
|
|
return ret;
|
|
}
|
|
|
|
void callTestFunctions( test_definition testList[], unsigned char selectedTestList[], test_status resultTestList[],
|
|
int testNum, cl_device_id deviceToUse, int forceNoContextCreation, int numElementsToUse,
|
|
cl_command_queue_properties queueProps )
|
|
{
|
|
for( int i = 0; i < testNum; ++i )
|
|
{
|
|
if( selectedTestList[i] )
|
|
{
|
|
resultTestList[i] = callSingleTestFunction( testList[i], deviceToUse, forceNoContextCreation,
|
|
numElementsToUse, queueProps );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CL_CALLBACK notify_callback(const char *errinfo, const void *private_info, size_t cb, void *user_data)
|
|
{
|
|
log_info( "%s\n", errinfo );
|
|
}
|
|
|
|
// Actual function execution
|
|
test_status callSingleTestFunction( test_definition test, cl_device_id deviceToUse, int forceNoContextCreation,
|
|
int numElementsToUse, const cl_queue_properties queueProps )
|
|
{
|
|
test_status status;
|
|
cl_int error;
|
|
cl_context context = NULL;
|
|
cl_command_queue queue = NULL;
|
|
|
|
log_info( "%s...\n", test.name );
|
|
fflush( stdout );
|
|
|
|
const Version device_version = get_device_cl_version(deviceToUse);
|
|
if (test.min_version > device_version)
|
|
{
|
|
version_expected_info(test.name, "OpenCL",
|
|
test.min_version.to_string().c_str(),
|
|
device_version.to_string().c_str());
|
|
return TEST_SKIP;
|
|
}
|
|
|
|
/* Create a context to work with, unless we're told not to */
|
|
if( !forceNoContextCreation )
|
|
{
|
|
context = clCreateContext(NULL, 1, &deviceToUse, notify_callback, NULL, &error );
|
|
if (!context)
|
|
{
|
|
print_error( error, "Unable to create testing context" );
|
|
return TEST_FAIL;
|
|
}
|
|
|
|
if (device_version < Version(2, 0)) {
|
|
queue = clCreateCommandQueue(context, deviceToUse, queueProps, &error);
|
|
} else {
|
|
const cl_command_queue_properties cmd_queueProps = (queueProps)?CL_QUEUE_PROPERTIES:0;
|
|
cl_command_queue_properties queueCreateProps[] = {cmd_queueProps, queueProps, 0};
|
|
queue = clCreateCommandQueueWithProperties( context, deviceToUse, &queueCreateProps[0], &error );
|
|
}
|
|
|
|
if( queue == NULL )
|
|
{
|
|
print_error( error, "Unable to create testing command queue" );
|
|
return TEST_FAIL;
|
|
}
|
|
}
|
|
|
|
/* Run the test and print the result */
|
|
error = check_functions_for_offline_compiler(test.name, deviceToUse);
|
|
test_missing_support_offline_cmpiler(error, test.name);
|
|
|
|
if( test.func == NULL )
|
|
{
|
|
// Skip unimplemented test, can happen when all of the tests are selected
|
|
log_info("%s test currently not implemented\n", test.name);
|
|
status = TEST_SKIP;
|
|
}
|
|
else
|
|
{
|
|
int ret = test.func(deviceToUse, context, queue, numElementsToUse); //test_threaded_function( ptr_basefn_list[i], group, context, num_elements);
|
|
if( ret == TEST_NOT_IMPLEMENTED )
|
|
{
|
|
/* Tests can also let us know they're not implemented yet */
|
|
log_info("%s test currently not implemented\n", test.name);
|
|
status = TEST_SKIP;
|
|
}
|
|
else if (ret == TEST_SKIPPED_ITSELF)
|
|
{
|
|
/* Tests can also let us know they're not supported by the implementation */
|
|
log_info("%s test not supported\n", test.name);
|
|
status = TEST_SKIP;
|
|
}
|
|
else
|
|
{
|
|
/* Print result */
|
|
if( ret == 0 ) {
|
|
log_info( "%s passed\n", test.name );
|
|
gTestsPassed++;
|
|
status = TEST_PASS;
|
|
}
|
|
else
|
|
{
|
|
log_error( "%s FAILED\n", test.name );
|
|
gTestsFailed++;
|
|
status = TEST_FAIL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Release the context */
|
|
if( !forceNoContextCreation )
|
|
{
|
|
int error = clFinish(queue);
|
|
if (error) {
|
|
log_error("clFinish failed: %d", error);
|
|
status = TEST_FAIL;
|
|
}
|
|
clReleaseCommandQueue( queue );
|
|
clReleaseContext( context );
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
#if ! defined( __APPLE__ )
|
|
void memset_pattern4(void *dest, const void *src_pattern, size_t bytes )
|
|
{
|
|
uint32_t pat = ((uint32_t*) src_pattern)[0];
|
|
size_t count = bytes / 4;
|
|
size_t i;
|
|
uint32_t *d = (uint32_t*)dest;
|
|
|
|
for( i = 0; i < count; i++ )
|
|
d[i] = pat;
|
|
|
|
d += i;
|
|
|
|
bytes &= 3;
|
|
if( bytes )
|
|
memcpy( d, src_pattern, bytes );
|
|
}
|
|
#endif
|
|
|
|
cl_device_type GetDeviceType( cl_device_id d )
|
|
{
|
|
cl_device_type result = -1;
|
|
cl_int err = clGetDeviceInfo( d, CL_DEVICE_TYPE, sizeof( result ), &result, NULL );
|
|
if( CL_SUCCESS != err )
|
|
log_error( "ERROR: Unable to get device type for device %p\n", d );
|
|
return result;
|
|
}
|
|
|
|
|
|
cl_device_id GetOpposingDevice( cl_device_id device )
|
|
{
|
|
cl_int error;
|
|
cl_device_id *otherDevices;
|
|
cl_uint actualCount;
|
|
cl_platform_id plat;
|
|
|
|
// Get the platform of the device to use for getting a list of devices
|
|
error = clGetDeviceInfo( device, CL_DEVICE_PLATFORM, sizeof( plat ), &plat, NULL );
|
|
if( error != CL_SUCCESS )
|
|
{
|
|
print_error( error, "Unable to get device's platform" );
|
|
return NULL;
|
|
}
|
|
|
|
// Get a list of all devices
|
|
error = clGetDeviceIDs( plat, CL_DEVICE_TYPE_ALL, 0, NULL, &actualCount );
|
|
if( error != CL_SUCCESS )
|
|
{
|
|
print_error( error, "Unable to get list of devices size" );
|
|
return NULL;
|
|
}
|
|
otherDevices = (cl_device_id *)malloc(actualCount*sizeof(cl_device_id));
|
|
if (NULL == otherDevices) {
|
|
print_error( error, "Unable to allocate list of other devices." );
|
|
return NULL;
|
|
}
|
|
BufferOwningPtr<cl_device_id> otherDevicesBuf(otherDevices);
|
|
|
|
error = clGetDeviceIDs( plat, CL_DEVICE_TYPE_ALL, actualCount, otherDevices, NULL );
|
|
if( error != CL_SUCCESS )
|
|
{
|
|
print_error( error, "Unable to get list of devices" );
|
|
return NULL;
|
|
}
|
|
|
|
if( actualCount == 1 )
|
|
{
|
|
return device; // NULL means error, returning self means we couldn't find another one
|
|
}
|
|
|
|
// Loop and just find one that isn't the one we were given
|
|
cl_uint i;
|
|
for( i = 0; i < actualCount; i++ )
|
|
{
|
|
if( otherDevices[ i ] != device )
|
|
{
|
|
cl_device_type newType;
|
|
error = clGetDeviceInfo( otherDevices[ i ], CL_DEVICE_TYPE, sizeof( newType ), &newType, NULL );
|
|
if( error != CL_SUCCESS )
|
|
{
|
|
print_error( error, "Unable to get device type for other device" );
|
|
return NULL;
|
|
}
|
|
cl_device_id result = otherDevices[ i ];
|
|
return result;
|
|
}
|
|
}
|
|
|
|
// Should never get here
|
|
return NULL;
|
|
}
|
|
|
|
Version get_device_cl_version(cl_device_id device)
|
|
{
|
|
size_t str_size;
|
|
cl_int err = clGetDeviceInfo(device, CL_DEVICE_VERSION, 0, NULL, &str_size);
|
|
ASSERT_SUCCESS(err, "clGetDeviceInfo");
|
|
|
|
std::vector<char> str(str_size);
|
|
err = clGetDeviceInfo(device, CL_DEVICE_VERSION, str_size, str.data(), NULL);
|
|
ASSERT_SUCCESS(err, "clGetDeviceInfo");
|
|
|
|
if (strstr(str.data(), "OpenCL 1.0") != NULL)
|
|
return Version(1, 0);
|
|
else if (strstr(str.data(), "OpenCL 1.1") != NULL)
|
|
return Version(1, 1);
|
|
else if (strstr(str.data(), "OpenCL 1.2") != NULL)
|
|
return Version(1, 2);
|
|
else if (strstr(str.data(), "OpenCL 2.0") != NULL)
|
|
return Version(2, 0);
|
|
else if (strstr(str.data(), "OpenCL 2.1") != NULL)
|
|
return Version(2, 1);
|
|
else if (strstr(str.data(), "OpenCL 2.2") != NULL)
|
|
return Version(2, 2);
|
|
else if (strstr(str.data(), "OpenCL 3.0") != NULL)
|
|
return Version(3, 0);
|
|
|
|
throw std::runtime_error(std::string("Unknown OpenCL version: ") + str.data());
|
|
}
|
|
|
|
bool check_device_spirv_version_reported(cl_device_id device)
|
|
{
|
|
size_t str_size;
|
|
cl_int err;
|
|
std::vector<char> str;
|
|
if (gCoreILProgram)
|
|
{
|
|
err = clGetDeviceInfo(device, CL_DEVICE_IL_VERSION, 0, NULL, &str_size);
|
|
if (err != CL_SUCCESS)
|
|
{
|
|
log_error(
|
|
"clGetDeviceInfo: cannot read CL_DEVICE_IL_VERSION size;");
|
|
return false;
|
|
}
|
|
|
|
str.resize(str_size);
|
|
err = clGetDeviceInfo(device, CL_DEVICE_IL_VERSION, str_size,
|
|
str.data(), NULL);
|
|
if (err != CL_SUCCESS)
|
|
{
|
|
log_error(
|
|
"clGetDeviceInfo: cannot read CL_DEVICE_IL_VERSION value;");
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cl_int err = clGetDeviceInfo(device, CL_DEVICE_IL_VERSION_KHR, 0, NULL,
|
|
&str_size);
|
|
if (err != CL_SUCCESS)
|
|
{
|
|
log_error(
|
|
"clGetDeviceInfo: cannot read CL_DEVICE_IL_VERSION_KHR size;");
|
|
return false;
|
|
}
|
|
|
|
str.resize(str_size);
|
|
err = clGetDeviceInfo(device, CL_DEVICE_IL_VERSION_KHR, str_size,
|
|
str.data(), NULL);
|
|
if (err != CL_SUCCESS)
|
|
{
|
|
log_error(
|
|
"clGetDeviceInfo: cannot read CL_DEVICE_IL_VERSION_KHR value;");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (strstr(str.data(), "SPIR-V") == NULL)
|
|
{
|
|
log_info("This device does not support SPIR-V offline compilation.\n");
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
Version spirv_version = get_device_spirv_il_version(device);
|
|
log_info("This device supports SPIR-V offline compilation. SPIR-V "
|
|
"version is %s\n",
|
|
spirv_version.to_string().c_str());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
Version get_device_spirv_il_version(cl_device_id device)
|
|
{
|
|
size_t str_size;
|
|
cl_int err;
|
|
std::vector<char> str;
|
|
if (gCoreILProgram)
|
|
{
|
|
err = clGetDeviceInfo(device, CL_DEVICE_IL_VERSION, 0, NULL, &str_size);
|
|
ASSERT_SUCCESS(err, "clGetDeviceInfo");
|
|
|
|
str.resize(str_size);
|
|
err = clGetDeviceInfo(device, CL_DEVICE_IL_VERSION, str_size,
|
|
str.data(), NULL);
|
|
ASSERT_SUCCESS(err, "clGetDeviceInfo");
|
|
}
|
|
else
|
|
{
|
|
err = clGetDeviceInfo(device, CL_DEVICE_IL_VERSION_KHR, 0, NULL,
|
|
&str_size);
|
|
ASSERT_SUCCESS(err, "clGetDeviceInfo");
|
|
|
|
str.resize(str_size);
|
|
err = clGetDeviceInfo(device, CL_DEVICE_IL_VERSION_KHR, str_size,
|
|
str.data(), NULL);
|
|
ASSERT_SUCCESS(err, "clGetDeviceInfo");
|
|
}
|
|
|
|
if (strstr(str.data(), "SPIR-V_1.0") != NULL)
|
|
return Version(1, 0);
|
|
else if (strstr(str.data(), "SPIR-V_1.1") != NULL)
|
|
return Version(1, 1);
|
|
else if (strstr(str.data(), "SPIR-V_1.2") != NULL)
|
|
return Version(1, 2);
|
|
else if (strstr(str.data(), "SPIR-V_1.3") != NULL)
|
|
return Version(1, 3);
|
|
else if (strstr(str.data(), "SPIR-V_1.4") != NULL)
|
|
return Version(1, 4);
|
|
else if (strstr(str.data(), "SPIR-V_1.5") != NULL)
|
|
return Version(1, 5);
|
|
|
|
throw std::runtime_error(std::string("Unknown SPIR-V version: ")
|
|
+ str.data());
|
|
}
|
|
|
|
test_status check_spirv_compilation_readiness(cl_device_id device)
|
|
{
|
|
auto ocl_version = get_device_cl_version(device);
|
|
auto ocl_expected_min_version = Version(2, 1);
|
|
|
|
if (ocl_version < ocl_expected_min_version)
|
|
{
|
|
if (is_extension_available(device, "cl_khr_il_program"))
|
|
{
|
|
gCoreILProgram = false;
|
|
bool spirv_supported = check_device_spirv_version_reported(device);
|
|
if (spirv_supported == false)
|
|
{
|
|
log_error("SPIR-V intermediate language not supported !!! "
|
|
"OpenCL %s requires support.\n",
|
|
ocl_version.to_string().c_str());
|
|
return TEST_FAIL;
|
|
}
|
|
else
|
|
{
|
|
return TEST_PASS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
log_error("SPIR-V intermediate language support on OpenCL version "
|
|
"%s requires cl_khr_il_program extension.\n",
|
|
ocl_version.to_string().c_str());
|
|
return TEST_SKIP;
|
|
}
|
|
}
|
|
|
|
bool spirv_supported = check_device_spirv_version_reported(device);
|
|
if (ocl_version >= ocl_expected_min_version && ocl_version <= Version(2, 2))
|
|
{
|
|
if (spirv_supported == false)
|
|
{
|
|
log_error("SPIR-V intermediate language not supported !!! OpenCL "
|
|
"%s requires support.\n",
|
|
ocl_version.to_string().c_str());
|
|
return TEST_FAIL;
|
|
}
|
|
}
|
|
|
|
if (ocl_version > Version(2, 2))
|
|
{
|
|
if (spirv_supported == false)
|
|
{
|
|
log_info("SPIR-V intermediate language not supported in OpenCL %s. "
|
|
"Test skipped.\n",
|
|
ocl_version.to_string().c_str());
|
|
return TEST_SKIP;
|
|
}
|
|
}
|
|
return TEST_PASS;
|
|
}
|
|
|
|
void PrintArch( void )
|
|
{
|
|
vlog( "sizeof( void*) = %ld\n", sizeof( void *) );
|
|
#if defined( __ppc__ )
|
|
vlog( "ARCH:\tppc\n" );
|
|
#elif defined( __ppc64__ )
|
|
vlog( "ARCH:\tppc64\n" );
|
|
#elif defined( __PPC__ )
|
|
vlog( "ARCH:\tppc\n" );
|
|
#elif defined( __i386__ )
|
|
vlog( "ARCH:\ti386\n" );
|
|
#elif defined( __x86_64__ )
|
|
vlog( "ARCH:\tx86_64\n" );
|
|
#elif defined( __arm__ )
|
|
vlog( "ARCH:\tarm\n" );
|
|
#elif defined(__aarch64__)
|
|
vlog( "ARCH:\taarch64\n" );
|
|
#elif defined (_WIN32)
|
|
vlog( "ARCH:\tWindows\n" );
|
|
#else
|
|
#error unknown arch
|
|
#endif
|
|
|
|
#if defined( __APPLE__ )
|
|
|
|
int type = 0;
|
|
size_t typeSize = sizeof( type );
|
|
sysctlbyname( "hw.cputype", &type, &typeSize, NULL, 0 );
|
|
vlog( "cpu type:\t%d\n", type );
|
|
typeSize = sizeof( type );
|
|
sysctlbyname( "hw.cpusubtype", &type, &typeSize, NULL, 0 );
|
|
vlog( "cpu subtype:\t%d\n", type );
|
|
|
|
#elif defined( __linux__ )
|
|
struct utsname buffer;
|
|
|
|
if (uname(&buffer) != 0) {
|
|
vlog("uname error");
|
|
}
|
|
else {
|
|
vlog("system name = %s\n", buffer.sysname);
|
|
vlog("node name = %s\n", buffer.nodename);
|
|
vlog("release = %s\n", buffer.release);
|
|
vlog("version = %s\n", buffer.version);
|
|
vlog("machine = %s\n", buffer.machine);
|
|
}
|
|
#endif
|
|
}
|
|
|