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

Synchronise with Khronos-private Gitlab branch

Browse Source 
The maintenance of the conformance tests is moving to Github.

This commit contains all the changes that have been done in
Gitlab since the first public release of the conformance tests.

Signed-off-by: Kevin Petit kevin.petit@arm.com
This commit is contained in:
Kevin Petit
2019-02-20 16:19:45 +00:00
committed by Kévin Petit
parent ba975e4112
commit 05a11d8e49
785 changed files with 18699 additions and 1070 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
test_conformance/CMakeLists.txt
View File

@@ -48,8 +48,9 @@ add_subdirectory( SVM )
add_subdirectory( generic_address_space )
add_subdirectory( subgroups )
add_subdirectory( workgroups )
add_subdirectory( pipes )
add_subdirectory( pipes )
add_subdirectory( device_timer )
add_subdirectory( spirv_new )
install_files(
opencl_conformance_tests_conversions.csv

1
test_conformance/SVM/CMakeLists.txt
View File

@@ -1,3 +1,4 @@
set(CMAKE_CXX_STANDARD 11)
set(MODULE_NAME SVM)
set(${MODULE_NAME}_SOURCES

2
test_conformance/SVM/main.cpp
View File

@@ -227,7 +227,7 @@ cl_int create_cl_objects(cl_device_id device_from_harness, const char** ppCodeSt
}
error = clGetDeviceInfo(devices[i], CL_DEVICE_SVM_CAPABILITIES, sizeof(cl_device_svm_capabilities), &caps, NULL);
test_error(error,"clGetDeviceInfo failed for CL_DEVICE_MEM_SHARING");
test_error(error,"clGetDeviceInfo failed for CL_DEVICE_SVM_CAPABILITIES");
if(caps & (~(CL_DEVICE_SVM_COARSE_GRAIN_BUFFER | CL_DEVICE_SVM_FINE_GRAIN_BUFFER | CL_DEVICE_SVM_FINE_GRAIN_SYSTEM | CL_DEVICE_SVM_ATOMICS)))
{
log_error("clGetDeviceInfo returned an invalid cl_device_svm_capabilities value");

4
test_conformance/SVM/test_allocate_shared_buffer.cpp
View File

@@ -97,6 +97,10 @@ int test_allocate_shared_buffer(cl_device_id deviceID, cl_context context2, cl_c
log_error("SVM pointer returned by clEnqueueMapBuffer doesn't match pointer returned by clSVMalloc");
return -1;
}
err = clEnqueueUnmapMemObject(queues[0], buf, pBufData2, 0, NULL, NULL);
test_error(err, "clEnqueueUnmapMemObject failed");
err = clFinish(queues[0]);
test_error(err, "clFinish failed");
}
}

13
test_conformance/SVM/test_enqueue_api.cpp
View File

@@ -17,10 +17,15 @@
#include "../../test_common/harness/mt19937.h"
#include <vector>
#include <atomic>
#if !defined(_WIN32)
#include <unistd.h>
#endif
typedef struct
{
cl_uint status;
std::atomic<cl_uint> status;
cl_uint num_svm_pointers;
std::vector<void *> svm_pointers;
} CallbackData;
@@ -62,7 +67,7 @@ void CL_CALLBACK callback_svm_free(cl_command_queue queue, cl_uint num_svm_point
clSVMFree(context, svm_pointers[i]);
}
data->status = 1;
data->status.store(1, std::memory_order_release);
}
int test_enqueue_api(cl_device_id deviceID, cl_context c, cl_command_queue queue, int num_elements)
@@ -231,7 +236,9 @@ int test_enqueue_api(cl_device_id deviceID, cl_context c, cl_command_queue queue
test_error(error, "clFinish failed");
//wait for the callback
while(data.status == 0) { }
while(data.status.load(std::memory_order_acquire) == 0) {
usleep(1);
}
//check if number of SVM pointers returned in the callback matches with expected
if (data.num_svm_pointers != buffers.size())

2
test_conformance/api/test_api_min_max.c
View File

@@ -1307,7 +1307,6 @@ int test_min_max_constant_buffer_size(cl_device_id deviceID, cl_context context,
int error;
clProgramWrapper program;
clKernelWrapper kernel;
clMemWrapper streams[3];
size_t threads[1], localThreads[1];
cl_int *constantData, *resultData;
cl_ulong maxSize, stepSize, currentSize;
@@ -1349,6 +1348,7 @@ int test_min_max_constant_buffer_size(cl_device_id deviceID, cl_context context,
for(i=0; i<(int)(numberOfInts); i++)
constantData[i] = (int)genrand_int32(d);
clMemWrapper streams[3];
streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeToAllocate, constantData, &error);
test_error( error, "Creating test array failed" );
streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeToAllocate, NULL, &error);

1
test_conformance/api/test_clone_kernel.cpp
View File

@@ -18,6 +18,7 @@
#include "../../test_common/harness/conversions.h"
#include <sstream>
#include <string>
#include <cmath>
using namespace std;

2
test_conformance/api/test_zero_sized_enqueue.cpp
View File

@@ -190,7 +190,7 @@ int test_zero_sized_enqueue(cl_device_id deviceID, cl_context context, cl_comman
cl_int error = clGetDeviceInfo(deviceID, CL_DEVICE_QUEUE_PROPERTIES, sizeof(cl_command_queue_properties), &props, NULL);
test_error( error, "clGetDeviceInfo failed.");
if (props | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE)
if (props & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE)
{
// test out of order queue
cl_queue_properties queue_prop_def[] =

0
test_conformance/basic/run_array Normal file → Executable file
View File

0
test_conformance/basic/run_array_image_copy Normal file → Executable file
View File

0
test_conformance/basic/run_image Normal file → Executable file
View File

0
test_conformance/basic/run_multi_read_image Normal file → Executable file
View File

7
test_conformance/basic/test_async_strided_copy.cpp
View File

@@ -209,14 +209,13 @@ int test_strided_copy(cl_device_id deviceID, cl_context context, cl_command_queu
log_error( "ERROR: Results of copy did not validate!\n" );
sprintf(values + strlen( values), "%d -> [", i);
for (int j=0; j<(int)elementSize; j++)
sprintf(values + strlen( values), "%2x ", inchar[i*elementSize+j]);
sprintf(values + strlen( values), "%2x ", inchar[j]);
sprintf(values + strlen(values), "] != [");
for (int j=0; j<(int)elementSize; j++)
sprintf(values + strlen( values), "%2x ", outchar[i*elementSize+j]);
sprintf(values + strlen( values), "%2x ", outchar[j]);
sprintf(values + strlen(values), "]");
log_error("%s\n", values);
return -1;
return -1;
}
}

87
test_conformance/basic/test_progvar.cpp
View File

@@ -864,12 +864,14 @@ static int l_write_read_for_type( cl_device_id device, cl_context context, cl_co
// We need to create 5 random values of the given type,
// and read 4 of them back.
cl_uchar CL_ALIGNED(ALIGNMENT) write_data[NUM_TESTED_VALUES * sizeof(cl_ulong16)];
cl_uchar CL_ALIGNED(ALIGNMENT) read_data[ (NUM_TESTED_VALUES-1) * sizeof(cl_ulong16)];
const size_t write_data_size = NUM_TESTED_VALUES * sizeof(cl_ulong16);
const size_t read_data_size = (NUM_TESTED_VALUES - 1) * sizeof(cl_ulong16);
cl_uchar* write_data = (cl_uchar*)align_malloc(write_data_size, ALIGNMENT);
cl_uchar* read_data = (cl_uchar*)align_malloc(read_data_size, ALIGNMENT);
clMemWrapper write_mem( clCreateBuffer( context, CL_MEM_USE_HOST_PTR, sizeof(write_data), write_data, &status ) );
clMemWrapper write_mem( clCreateBuffer( context, CL_MEM_USE_HOST_PTR, write_data_size, write_data, &status ) );
test_error_ret(status,"Failed to allocate write buffer",status);
clMemWrapper read_mem( clCreateBuffer( context, CL_MEM_USE_HOST_PTR, sizeof(read_data), read_data, &status ) );
clMemWrapper read_mem( clCreateBuffer( context, CL_MEM_USE_HOST_PTR, read_data_size, read_data, &status ) );
test_error_ret(status,"Failed to allocate read buffer",status);
status = clSetKernelArg(writer,0,sizeof(cl_mem),&write_mem); test_error_ret(status,"set arg",status);
@@ -884,7 +886,7 @@ static int l_write_read_for_type( cl_device_id device, cl_context context, cl_co
// Generate new random data to push through.
// Generate 5 * 128 bytes all the time, even though the test for many types use less than all that.
cl_uchar *write_ptr = (cl_uchar *)clEnqueueMapBuffer(queue, write_mem, CL_TRUE, CL_MAP_WRITE, 0, sizeof(write_data), 0, 0, 0, 0);
cl_uchar *write_ptr = (cl_uchar *)clEnqueueMapBuffer(queue, write_mem, CL_TRUE, CL_MAP_WRITE, 0, write_data_size, 0, 0, 0, 0);
if ( ti.is_bool() ) {
// For boolean, random data cast to bool isn't very random.
@@ -896,7 +898,7 @@ static int l_write_read_for_type( cl_device_id device, cl_context context, cl_co
}
bool_iter++;
} else {
l_set_randomly( write_data, sizeof(write_data), rand_state );
l_set_randomly( write_data, write_data_size, rand_state );
}
status = clSetKernelArg(writer,1,sizeof(cl_uint),&iptr_idx); test_error_ret(status,"set arg",status);
@@ -905,7 +907,7 @@ static int l_write_read_for_type( cl_device_id device, cl_context context, cl_co
status = clSetKernelArg(reader,1,ti.get_size(),write_data + (NUM_TESTED_VALUES-1)*ti.get_size()); test_error_ret(status,"set arg",status);
// Determine the expected values.
cl_uchar expected[ (NUM_TESTED_VALUES-1) * sizeof(cl_ulong16)];
cl_uchar expected[read_data_size];
memset( expected, -1, sizeof(expected) );
l_copy( expected, 0, write_data, 0, ti );
l_copy( expected, 1, write_data, 1, ti );
@@ -922,8 +924,8 @@ static int l_write_read_for_type( cl_device_id device, cl_context context, cl_co
for ( unsigned i = 0; i < NUM_TESTED_VALUES-1 ; i++ ) expected[i] = (bool)expected[i];
}
cl_uchar *read_ptr = (cl_uchar *)clEnqueueMapBuffer(queue, read_mem, CL_TRUE, CL_MAP_READ, 0, sizeof(read_data), 0, 0, 0, 0);
memset( read_data, -1, sizeof(read_data) );
cl_uchar *read_ptr = (cl_uchar *)clEnqueueMapBuffer(queue, read_mem, CL_TRUE, CL_MAP_READ, 0, read_data_size, 0, 0, 0, 0);
memset(read_data, -1, read_data_size);
clEnqueueUnmapMemObject(queue, read_mem, read_ptr, 0, 0, 0);
// Now run the kernel
@@ -932,7 +934,7 @@ static int l_write_read_for_type( cl_device_id device, cl_context context, cl_co
status = clEnqueueNDRangeKernel(queue,reader,1,0,&one,0,0,0,0); test_error_ret(status,"enqueue reader",status);
status = clFinish(queue); test_error_ret(status,"finish",status);
read_ptr = (cl_uchar *)clEnqueueMapBuffer(queue, read_mem, CL_TRUE, CL_MAP_READ, 0, sizeof(read_data), 0, 0, 0, 0);
read_ptr = (cl_uchar *)clEnqueueMapBuffer(queue, read_mem, CL_TRUE, CL_MAP_READ, 0, read_data_size, 0, 0, 0, 0);
if ( ti.is_bool() ) {
// Collapse down to one bit.
@@ -951,7 +953,8 @@ static int l_write_read_for_type( cl_device_id device, cl_context context, cl_co
}
if ( CL_SUCCESS == err ) { log_info("OK\n"); FLUSH; }
align_free(write_data);
align_free(read_data);
return err;
}
@@ -1008,12 +1011,14 @@ static int l_init_write_read_for_type( cl_device_id device, cl_context context,
// We need to create 5 random values of the given type,
// and read 4 of them back.
cl_uchar CL_ALIGNED(ALIGNMENT) write_data[NUM_TESTED_VALUES * sizeof(cl_ulong16)];
cl_uchar CL_ALIGNED(ALIGNMENT) read_data[ (NUM_TESTED_VALUES-1) * sizeof(cl_ulong16)];
const size_t write_data_size = NUM_TESTED_VALUES * sizeof(cl_ulong16);
const size_t read_data_size = (NUM_TESTED_VALUES-1) * sizeof(cl_ulong16);
clMemWrapper write_mem( clCreateBuffer( context, CL_MEM_USE_HOST_PTR, sizeof(write_data), write_data, &status ) );
cl_uchar* write_data = (cl_uchar*)align_malloc(write_data_size, ALIGNMENT);
cl_uchar* read_data = (cl_uchar*)align_malloc(read_data_size, ALIGNMENT);
clMemWrapper write_mem( clCreateBuffer( context, CL_MEM_USE_HOST_PTR, write_data_size, write_data, &status ) );
test_error_ret(status,"Failed to allocate write buffer",status);
clMemWrapper read_mem( clCreateBuffer( context, CL_MEM_USE_HOST_PTR, sizeof(read_data), read_data, &status ) );
clMemWrapper read_mem( clCreateBuffer( context, CL_MEM_USE_HOST_PTR, read_data_size, read_data, &status ) );
test_error_ret(status,"Failed to allocate read buffer",status);
status = clSetKernelArg(writer,0,sizeof(cl_mem),&write_mem); test_error_ret(status,"set arg",status);
@@ -1033,7 +1038,7 @@ static int l_init_write_read_for_type( cl_device_id device, cl_context context,
// Generate new random data to push through.
// Generate 5 * 128 bytes all the time, even though the test for many types use less than all that.
cl_uchar *write_ptr = (cl_uchar *)clEnqueueMapBuffer(queue, write_mem, CL_TRUE, CL_MAP_WRITE, 0, sizeof(write_data), 0, 0, 0, 0);
cl_uchar *write_ptr = (cl_uchar *)clEnqueueMapBuffer(queue, write_mem, CL_TRUE, CL_MAP_WRITE, 0, write_data_size, 0, 0, 0, 0);
if ( ti.is_bool() ) {
// For boolean, random data cast to bool isn't very random.
@@ -1045,7 +1050,7 @@ static int l_init_write_read_for_type( cl_device_id device, cl_context context,
}
bool_iter++;
} else {
l_set_randomly( write_data, sizeof(write_data), rand_state );
l_set_randomly( write_data, write_data_size, rand_state );
}
status = clSetKernelArg(writer,1,sizeof(cl_uint),&iptr_idx); test_error_ret(status,"set arg",status);
@@ -1061,7 +1066,7 @@ static int l_init_write_read_for_type( cl_device_id device, cl_context context,
status = clSetKernelArg(reader,1,ti.get_size(),write_data + (NUM_TESTED_VALUES-1)*ti.get_size()); test_error_ret(status,"set arg",status);
// Determine the expected values.
cl_uchar expected[ (NUM_TESTED_VALUES-1) * sizeof(cl_ulong16)];
cl_uchar expected[read_data_size];
memset( expected, -1, sizeof(expected) );
if ( iteration ) {
l_copy( expected, 0, write_data, 0, ti );
@@ -1092,8 +1097,8 @@ static int l_init_write_read_for_type( cl_device_id device, cl_context context,
clEnqueueUnmapMemObject(queue, write_mem, write_ptr, 0, 0, 0);
cl_uchar *read_ptr = (cl_uchar *)clEnqueueMapBuffer(queue, read_mem, CL_TRUE, CL_MAP_READ, 0, sizeof(read_data), 0, 0, 0, 0);
memset( read_data, -1, sizeof(read_data) );
cl_uchar *read_ptr = (cl_uchar *)clEnqueueMapBuffer(queue, read_mem, CL_TRUE, CL_MAP_READ, 0, read_data_size, 0, 0, 0, 0);
memset( read_data, -1, read_data_size );
clEnqueueUnmapMemObject(queue, read_mem, read_ptr, 0, 0, 0);
// Now run the kernel
@@ -1107,7 +1112,7 @@ static int l_init_write_read_for_type( cl_device_id device, cl_context context,
status = clEnqueueNDRangeKernel(queue,reader,1,0,&one,0,0,0,0); test_error_ret(status,"enqueue reader",status);
status = clFinish(queue); test_error_ret(status,"finish",status);
read_ptr = (cl_uchar *)clEnqueueMapBuffer(queue, read_mem, CL_TRUE, CL_MAP_READ, 0, sizeof(read_data), 0, 0, 0, 0);
read_ptr = (cl_uchar *)clEnqueueMapBuffer(queue, read_mem, CL_TRUE, CL_MAP_READ, 0, read_data_size, 0, 0, 0, 0);
if ( ti.is_bool() ) {
// Collapse down to one bit.
@@ -1129,6 +1134,8 @@ static int l_init_write_read_for_type( cl_device_id device, cl_context context,
}
if ( CL_SUCCESS == err ) { log_info("OK\n"); FLUSH; }
align_free(write_data);
align_free(read_data);
return err;
}
@@ -1340,6 +1347,13 @@ static int l_user_type( cl_device_id device, cl_context context, cl_command_queu
print_build_log(program, 1, &device, ksrc.num_str(), ksrc.strs(), ksrc.lengths(), OPTIONS);
return status;
}
status = clBuildProgram(program, 1, &device, OPTIONS, 0, 0);
if(check_error(status, "Failed to compile program for user type test (%s)", IGetErrorString(status)))
{
print_build_log(program, 1, &device, ksrc.num_str(), ksrc.strs(), ksrc.lengths(), OPTIONS);
return status;
}
}
@@ -1360,12 +1374,12 @@ static int l_user_type( cl_device_id device, cl_context context, cl_command_queu
test_error_ret(status,"Failed to create reader kernel for user type test",status);
// Set up data.
cl_uchar CL_ALIGNED(ALIGNMENT) uchar_data;
cl_uint CL_ALIGNED(ALIGNMENT) uint_data;
cl_uchar* uchar_data = (cl_uchar*)align_malloc(sizeof(cl_uchar), ALIGNMENT);
cl_uint* uint_data = (cl_uint*)align_malloc(sizeof(cl_uint), ALIGNMENT);
clMemWrapper uchar_mem( clCreateBuffer( context, CL_MEM_USE_HOST_PTR, sizeof(uchar_data), &uchar_data, &status ) );
clMemWrapper uchar_mem( clCreateBuffer( context, CL_MEM_USE_HOST_PTR, sizeof(cl_uchar), uchar_data, &status ) );
test_error_ret(status,"Failed to allocate uchar buffer",status);
clMemWrapper uint_mem( clCreateBuffer( context, CL_MEM_USE_HOST_PTR, sizeof(uint_data), &uint_data, &status ) );
clMemWrapper uint_mem( clCreateBuffer( context, CL_MEM_USE_HOST_PTR, sizeof(cl_uint), uint_data, &status ) );
test_error_ret(status,"Failed to allocate uint buffer",status);
status = clSetKernelArg(reader,0,sizeof(cl_mem),&uchar_mem); test_error_ret(status,"set arg",status);
@@ -1375,18 +1389,18 @@ static int l_user_type( cl_device_id device, cl_context context, cl_command_queu
cl_uint expected_uint = 42;
for ( unsigned iter = 0; iter < 5 ; iter++ ) { // Must go around at least twice
// Read back data
uchar_data = -1;
uint_data = -1;
*uchar_data = -1;
*uint_data = -1;
const size_t one = 1;
status = clEnqueueNDRangeKernel(queue,reader,1,0,&one,0,0,0,0); test_error_ret(status,"enqueue reader",status);
status = clFinish(queue); test_error_ret(status,"finish",status);
cl_uchar *uint_data_ptr = (cl_uchar *)clEnqueueMapBuffer(queue, uint_mem, CL_TRUE, CL_MAP_READ, 0, sizeof(uint_data), 0, 0, 0, 0);
cl_uchar *uchar_data_ptr = (cl_uchar *)clEnqueueMapBuffer(queue, uchar_mem, CL_TRUE, CL_MAP_READ, 0, sizeof(uchar_data), 0, 0, 0, 0);
cl_uchar *uint_data_ptr = (cl_uchar *)clEnqueueMapBuffer(queue, uint_mem, CL_TRUE, CL_MAP_READ, 0, sizeof(cl_uint), 0, 0, 0, 0);
cl_uchar *uchar_data_ptr = (cl_uchar *)clEnqueueMapBuffer(queue, uchar_mem, CL_TRUE, CL_MAP_READ, 0, sizeof(cl_uchar), 0, 0, 0, 0);
if ( expected_uchar != uchar_data || expected_uint != uint_data ) {
if ( expected_uchar != *uchar_data || expected_uint != *uint_data ) {
log_error("FAILED: Iteration %d Got (0x%2x,%d) but expected (0x%2x,%d)\n",
iter, (int)uchar_data, uint_data, (int)expected_uchar, expected_uint );
iter, (int)*uchar_data, *uint_data, (int)expected_uchar, expected_uint );
err |= 1;
}
@@ -1398,16 +1412,17 @@ static int l_user_type( cl_device_id device, cl_context context, cl_command_queu
expected_uint++;
// Write the new values into persistent store.
uchar_data = expected_uchar;
uint_data = expected_uint;
status = clSetKernelArg(writer,0,sizeof(uchar_data),&uchar_data); test_error_ret(status,"set arg",status);
status = clSetKernelArg(writer,1,sizeof(uint_data),&uint_data); test_error_ret(status,"set arg",status);
*uchar_data = expected_uchar;
*uint_data = expected_uint;
status = clSetKernelArg(writer,0,sizeof(cl_uchar),uchar_data); test_error_ret(status,"set arg",status);
status = clSetKernelArg(writer,1,sizeof(cl_uint),uint_data); test_error_ret(status,"set arg",status);
status = clEnqueueNDRangeKernel(queue,writer,1,0,&one,0,0,0,0); test_error_ret(status,"enqueue writer",status);
status = clFinish(queue); test_error_ret(status,"finish",status);
}
if ( CL_SUCCESS == err ) { log_info("OK\n"); FLUSH; }
align_free(uchar_data);
align_free(uint_data);
return err;
}

2
test_conformance/basic/test_sizeof.c
View File

@@ -50,7 +50,7 @@ cl_int get_type_size( cl_context context, cl_command_queue queue, const char *ty
sizeof_kernel_code[0] = "#pragma OPENCL EXTENSION cl_khr_fp16 : enable\n";
}
cl_int err = create_single_kernel_helper( context, &p, &k, 4, sizeof_kernel_code, "test_sizeof" );
cl_int err = create_single_kernel_helper_with_build_options(context, &p, &k, 4, sizeof_kernel_code, "test_sizeof", "-cl-std=CL2.0");
if( err )
return err;

14
test_conformance/build_script_binary.py
View File

@@ -1,7 +1,7 @@
# Script parameters:
# 1 - input file
# 2 - output file
# 3 - architecture: 32 or 64
# 4 - one of the strings: binary, source, spir_v
# 5 - OpenCL version: 12, 20
# 6 - build options
# Script parameters:
# 1 - input file
# 2 - output file
# 3 - architecture: 32 or 64
# 4 - one of the strings: binary, source, spir_v
# 5 - OpenCL version: 12, 20
# 6 - build options

14
test_conformance/build_script_source.py
View File

@@ -1,7 +1,7 @@
# Script parameters:
# 1 - input file
# 2 - output file
# 3 - architecture: 32 or 64
# 4 - one of the strings: binary, source, spir_v
# 5 - OpenCL version: 12, 20
# 6 - build options
# Script parameters:
# 1 - input file
# 2 - output file
# 3 - architecture: 32 or 64
# 4 - one of the strings: binary, source, spir_v
# 5 - OpenCL version: 12, 20
# 6 - build options

84
test_conformance/build_script_spirv.py
View File

@@ -1,43 +1,43 @@
# Script parameters:
# 1 - input file
# 2 - output file
# 3 - architecture: 32 or 64
# 4 - one of the strings: binary, source, spir_v
# 5 - OpenCL version: 12, 20
# 6 - build options
import os
import sys
if len(sys.argv)<5:
print 'Usage: "build_script_spirv.py <input> <output> <arch> <output_type> <opencl_version> [build_options]"'
exit(1)
input_file = sys.argv[1]
output_file = sys.argv[2]
arch = sys.argv[3]
output_type = sys.argv[4]
ocl_version = sys.argv[5]
build_options = ''
if len(sys.argv) == 5:
build_options = sys.argv[6]
if arch == '32':
arch_string = ''
spir_arch = '__i386__'
else:
arch_string = '64'
spir_arch = '__x86_64__'
if ocl_version == '20':
oclc_version = '200'
spir_version = '2.0'
else:
oclc_version = '120'
spir_version = '1.2'
command = '%LLVMPATH%\\bin\\clang.exe -cc1 -include headers\\opencl_SPIR-' + spir_version + '.h -cl-std=CL' + spir_version +' -D__OPENCL_C_VERSION__=' + oclc_version + ' -fno-validate-pch -D__OPENCL_VERSION__=' + oclc_version + ' -x cl -cl-kernel-arg-info -O0 -emit-llvm-bc -triple spir' + arch_string + '-unknown-unknown -D' + spir_arch + ' -Dcl_khr_3d_image_writes -Dcl_khr_byte_addressable_store -Dcl_khr_d3d10_sharing -Dcl_khr_d3d11_sharing -Dcl_khr_depth_images -Dcl_khr_dx9_media_sharing -Dcl_khr_fp64 -Dcl_khr_global_int32_base_atomics -Dcl_khr_global_int32_extended_atomics -Dcl_khr_gl_depth_images -Dcl_khr_gl_event -Dcl_khr_gl_msaa_sharing -Dcl_khr_gl_sharing -Dcl_khr_icd -Dcl_khr_image2d_from_buffer -Dcl_khr_local_int32_base_atomics -Dcl_khr_local_int32_extended_atomics -Dcl_khr_mipmap_image -Dcl_khr_mipmap_image_writes -Dcl_khr_fp16 ' + build_options + ' -Dcl_khr_spir ' + input_file + ' -o intermediate.spir'
os.system(command)
command = '%LLVMPATH%\\bin\\llvm-spirv.exe intermediate.spir -o ' + output_file
# Script parameters:
# 1 - input file
# 2 - output file
# 3 - architecture: 32 or 64
# 4 - one of the strings: binary, source, spir_v
# 5 - OpenCL version: 12, 20
# 6 - build options
import os
import sys
if len(sys.argv)<5:
print 'Usage: "build_script_spirv.py <input> <output> <arch> <output_type> <opencl_version> [build_options]"'
exit(1)
input_file = sys.argv[1]
output_file = sys.argv[2]
arch = sys.argv[3]
output_type = sys.argv[4]
ocl_version = sys.argv[5]
build_options = ''
if len(sys.argv) == 5:
build_options = sys.argv[6]
if arch == '32':
arch_string = ''
spir_arch = '__i386__'
else:
arch_string = '64'
spir_arch = '__x86_64__'
if ocl_version == '20':
oclc_version = '200'
spir_version = '2.0'
else:
oclc_version = '120'
spir_version = '1.2'
command = '%LLVMPATH%\\bin\\clang.exe -cc1 -include headers\\opencl_SPIR-' + spir_version + '.h -cl-std=CL' + spir_version +' -D__OPENCL_C_VERSION__=' + oclc_version + ' -fno-validate-pch -D__OPENCL_VERSION__=' + oclc_version + ' -x cl -cl-kernel-arg-info -O0 -emit-llvm-bc -triple spir' + arch_string + '-unknown-unknown -D' + spir_arch + ' -Dcl_khr_3d_image_writes -Dcl_khr_byte_addressable_store -Dcl_khr_d3d10_sharing -Dcl_khr_d3d11_sharing -Dcl_khr_depth_images -Dcl_khr_dx9_media_sharing -Dcl_khr_fp64 -Dcl_khr_global_int32_base_atomics -Dcl_khr_global_int32_extended_atomics -Dcl_khr_gl_depth_images -Dcl_khr_gl_event -Dcl_khr_gl_msaa_sharing -Dcl_khr_gl_sharing -Dcl_khr_icd -Dcl_khr_image2d_from_buffer -Dcl_khr_local_int32_base_atomics -Dcl_khr_local_int32_extended_atomics -Dcl_khr_mipmap_image -Dcl_khr_mipmap_image_writes -Dcl_khr_fp16 ' + build_options + ' -Dcl_khr_spir ' + input_file + ' -o intermediate.spir'
os.system(command)
command = '%LLVMPATH%\\bin\\llvm-spirv.exe intermediate.spir -o ' + output_file
os.system(command)

5
test_conformance/c11_atomics/test_atomics.cpp
View File

@@ -1566,6 +1566,7 @@ public:
using CBasicTestMemOrderScope<HostAtomicType, HostDataType>::MemoryOrder;
using CBasicTestMemOrderScope<HostAtomicType, HostDataType>::MemoryScopeStr;
using CBasicTestMemOrderScope<HostAtomicType, HostDataType>::MemoryOrderScopeStr;
using CBasicTestMemOrderScope<HostAtomicType, HostDataType>::UseSVM;
using CBasicTestMemOrderScope<HostAtomicType, HostDataType>::LocalMemory;
CBasicTestFlag(TExplicitAtomicType dataType, bool useSVM) : CBasicTestMemOrderScope<HostAtomicType, HostDataType>(dataType, useSVM)
{
@@ -1606,7 +1607,7 @@ public:
program += " atomic_work_item_fence(" +
std::string(LocalMemory() ? "CLK_LOCAL_MEM_FENCE, " : "CLK_GLOBAL_MEM_FENCE, ") +
"memory_order_acquire," +
std::string(LocalMemory() ? "memory_scope_work_group" : "memory_scope_device") +
std::string(LocalMemory() ? "memory_scope_work_group" : (UseSVM() ? "memory_scope_all_svm_devices" : "memory_scope_device") ) +
");\n";
program +=
@@ -1632,7 +1633,7 @@ public:
program += " atomic_work_item_fence(" +
std::string(LocalMemory() ? "CLK_LOCAL_MEM_FENCE, " : "CLK_GLOBAL_MEM_FENCE, ") +
"memory_order_release," +
std::string(LocalMemory() ? "memory_scope_work_group" : "memory_scope_device") +
std::string(LocalMemory() ? "memory_scope_work_group" : (UseSVM() ? "memory_scope_all_svm_devices" : "memory_scope_device") ) +
");\n";
program +=

360
test_conformance/compatibility/test_common/harness/compat.h
View File

@@ -13,32 +13,63 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//
/*
Header compat.h should be used instead of stdlib.h, stdbool.h, stdint.h, float.h, fenv.h,
math.h. It provides workarounds if these headers are not available or not complete.
Important: It should be included before math.h, directly or indirectly, because Intel mathimf.h
is not compatible with Microsoft math.h. Including math.h before mathimf.h causes compile-time
error.
*/
#ifndef _COMPAT_H_
#define _COMPAT_H_
#if defined(_WIN32) && defined (_MSC_VER)
#include <Windows.h>
#include <Winbase.h>
#include <CL/cl.h>
#include <float.h>
#include <xmmintrin.h>
#include <math.h>
#define MAKE_HEX_FLOAT(x,y,z) ((float)ldexp( (float)(y), z))
#define MAKE_HEX_DOUBLE(x,y,z) ldexp( (double)(y), z)
#define MAKE_HEX_LONG(x,y,z) ((long double) ldexp( (long double)(y), z))
#define isfinite(x) _finite(x)
#if !defined(__cplusplus)
typedef char bool;
#define inline
#else
extern "C" {
#endif
#ifdef __cplusplus
#define EXTERN_C extern "C"
#else
#define EXTERN_C
#endif
//
// stdlib.h
//
#include <stdlib.h> // On Windows, _MAX_PATH defined there.
// llabs appeared in MS C v16 (VS 10/2010).
#if defined( _MSC_VER ) && _MSC_VER <= 1500
EXTERN_C inline long long llabs(long long __x) { return __x >= 0 ? __x : -__x; }
#endif
//
// stdbool.h
//
// stdbool.h appeared in MS C v18 (VS 12/2013).
#if defined( _MSC_VER ) && MSC_VER <= 1700
#if !defined(__cplusplus)
typedef char bool;
#define true 1
#define false 0
#endif
#else
#include <stdbool.h>
#endif
//
// stdint.h
//
// stdint.h appeared in MS C v16 (VS 10/2010) and Intel C v12.
#if defined( _MSC_VER ) && ( ! defined( __INTEL_COMPILER ) && _MSC_VER <= 1500 || defined( __INTEL_COMPILER ) && __INTEL_COMPILER < 1200 )
typedef unsigned char uint8_t;
typedef char int8_t;
typedef unsigned short uint16_t;
@@ -47,25 +78,83 @@ typedef unsigned int uint32_t;
typedef int int32_t;
typedef unsigned long long uint64_t;
typedef long long int64_t;
#define MAXPATHLEN MAX_PATH
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;
#else
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS
#endif
#include <stdint.h>
#endif
#define INFINITY (FLT_MAX + FLT_MAX)
//#define NAN (INFINITY | 1)
//const static int PINFBITPATT_SP32 = INFINITY;
//
// float.h
//
#include <float.h>
//
// fenv.h
//
// fenv.h appeared in MS C v18 (VS 12/2013).
#if defined( _MSC_VER ) && _MSC_VER <= 1700 && ! defined( __INTEL_COMPILER )
// reimplement fenv.h because windows doesn't have it
#define FE_INEXACT 0x0020
#define FE_UNDERFLOW 0x0010
#define FE_OVERFLOW 0x0008
#define FE_DIVBYZERO 0x0004
#define FE_INVALID 0x0001
#define FE_ALL_EXCEPT 0x003D
int fetestexcept(int excepts);
int feclearexcept(int excepts);
#else
#include <fenv.h>
#endif
//
// math.h
//
#if defined( __INTEL_COMPILER )
#include <mathimf.h>
#else
#include <math.h>
#endif
#if defined( _MSC_VER )
#ifdef __cplusplus
extern "C" {
#endif
#ifndef M_PI
#define M_PI 3.14159265358979323846264338327950288
#endif
#if ! defined( __INTEL_COMPILER )
#ifndef NAN
#define NAN (INFINITY - INFINITY)
#endif
#ifndef HUGE_VALF
#define HUGE_VALF (float)HUGE_VAL
#endif
#ifndef INFINITY
#define INFINITY (FLT_MAX + FLT_MAX)
#endif
#ifndef isfinite
#define isfinite(x) _finite(x)
#endif
#ifndef isnan
#define isnan( x ) ((x) != (x))
#endif
#ifndef isinf
#define isinf( _x) ((_x) == INFINITY || (_x) == -INFINITY)
#endif
double rint( double x);
float rintf( float x);
@@ -99,27 +188,6 @@ long double remquol( long double x, long double y, int *quo);
long double scalblnl(long double x, long n);
inline long long
llabs(long long __x) { return __x >= 0 ? __x : -__x; }
// end of math functions
uint64_t ReadTime( void );
double SubtractTime( uint64_t endTime, uint64_t startTime );
#define sleep(X) Sleep(1000*X)
#define snprintf sprintf_s
//#define hypotl _hypot
float make_nan();
float nanf( const char* str);
double nan( const char* str);
long double nanl( const char* str);
//#if defined USE_BOOST
//#include <boost/math/tr1.hpp>
//double hypot(double x, double y);
float hypotf(float x, float y);
long double hypotl(long double x, long double y) ;
double lgamma(double x);
@@ -144,67 +212,179 @@ double round(double x);
float roundf(float x);
long double roundl(long double x);
int signbit(double x);
int signbitf(float x);
int cf_signbit(double x);
int cf_signbitf(float x);
//bool signbitl(long double x) { return boost::math::tr1::signbit<long double>(x); }
//#endif // USE_BOOST
static int signbit(double x) { return cf_signbit(x); }
static int signbitf(float x) { return cf_signbitf(x); }
long int lrint (double flt);
long int lrintf (float flt);
float int2float (int32_t ix);
int32_t float2int (float fx);
#endif
#if ! defined( __INTEL_COMPILER ) || __INTEL_COMPILER < 1300
// These functions appeared in Intel C v13.
float nanf( const char* str);
double nan( const char* str);
long double nanl( const char* str);
#endif
#ifdef __cplusplus
}
#endif
#endif
#if defined( __ANDROID__ )
#define log2(X) (log(X)/log(2))
#endif
//
// stdio.h
//
#if defined( _MSC_VER )
#define snprintf sprintf_s
#endif
//
// unistd.h
//
#if defined( _MSC_VER )
EXTERN_C unsigned int sleep( unsigned int sec );
EXTERN_C int usleep( int usec );
#endif
//
// syscall.h
//
#if defined( __ANDROID__ )
// Android bionic's isn't providing SYS_sysctl wrappers.
#define SYS__sysctl __NR__sysctl
#endif
// Some tests use _malloca which defined in malloc.h.
#if !defined (__APPLE__)
#include <malloc.h>
#endif
//
// ???
//
#if defined( _MSC_VER )
#define MAXPATHLEN _MAX_PATH
EXTERN_C uint64_t ReadTime( void );
EXTERN_C double SubtractTime( uint64_t endTime, uint64_t startTime );
/** Returns the number of leading 0-bits in x,
starting at the most significant bit position.
If x is 0, the result is undefined.
*/
int __builtin_clz(unsigned int pattern);
static const double zero= 0.00000000000000000000e+00;
#define NAN (INFINITY - INFINITY)
#define HUGE_VALF (float)HUGE_VAL
int usleep(int usec);
// reimplement fenv.h because windows doesn't have it
#define FE_INEXACT 0x0020
#define FE_UNDERFLOW 0x0010
#define FE_OVERFLOW 0x0008
#define FE_DIVBYZERO 0x0004
#define FE_INVALID 0x0001
#define FE_ALL_EXCEPT 0x003D
int fetestexcept(int excepts);
int feclearexcept(int excepts);
#ifdef __cplusplus
}
#endif
#else // !((defined(_WIN32) && defined(_MSC_VER)
#if defined(__MINGW32__)
#include <windows.h>
#define sleep(X) Sleep(1000*X)
EXTERN_C int __builtin_clz(unsigned int pattern);
#endif
#if defined(__linux__) || defined(__MINGW32__) || defined(__APPLE__)
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS
#ifndef MIN
#define MIN(x,y) (((x)<(y))?(x):(y))
#endif
#include <fenv.h>
#include <math.h>
#include <float.h>
#include <stdint.h>
#ifndef MAX
#define MAX(x,y) (((x)>(y))?(x):(y))
#endif
/*
------------------------------------------------------------------------------------------------
WARNING: DO NOT USE THESE MACROS: MAKE_HEX_FLOAT, MAKE_HEX_DOUBLE, MAKE_HEX_LONG.
This is a typical usage of the macros:
double yhi = MAKE_HEX_DOUBLE(0x1.5555555555555p-2,0x15555555555555LL,-2);
(taken from math_brute_force/reference_math.c). There are two problems:
1. There is an error here. On Windows in will produce incorrect result
`0x1.5555555555555p+50'. To have a correct result it should be written as
`MAKE_HEX_DOUBLE(0x1.5555555555555p-2,0x15555555555555LL,-54)'. A proper value of the
third argument is not obvious -- sometimes it should be the same as exponent of the
first argument, but sometimes not.
2. Information is duplicated. It is easy to make a mistake.
Use HEX_FLT, HEX_DBL, HEX_LDBL macros instead (see them in the bottom of the file).
------------------------------------------------------------------------------------------------
*/
#if defined ( _MSC_VER ) && ! defined( __INTEL_COMPILER )
#define MAKE_HEX_FLOAT(x,y,z) ((float)ldexp( (float)(y), z))
#define MAKE_HEX_DOUBLE(x,y,z) ldexp( (double)(y), z)
#define MAKE_HEX_LONG(x,y,z) ((long double) ldexp( (long double)(y), z))
#else
// Do not use these macros in new code, use HEX_FLT, HEX_DBL, HEX_LDBL instead.
#define MAKE_HEX_FLOAT(x,y,z) x
#define MAKE_HEX_DOUBLE(x,y,z) x
#define MAKE_HEX_LONG(x,y,z) x
#endif // !((defined(_WIN32) && defined(_MSC_VER)
#endif
/*
------------------------------------------------------------------------------------------------
HEX_FLT, HEXT_DBL, HEX_LDBL -- Create hex floating point literal of type float, double, long
double respectively. Arguments:
sm -- sign of number,
int -- integer part of mantissa (without `0x' prefix),
fract -- fractional part of mantissa (without decimal point and `L' or `LL' suffixes),
se -- sign of exponent,
exp -- absolute value of (binary) exponent.
Example:
double yhi = HEX_DBL( +, 1, 5555555555555, -, 2 ); // == 0x1.5555555555555p-2
Note:
We have to pass signs as separate arguments because gcc pass negative integer values
(e. g. `-2') into a macro as two separate tokens, so `HEX_FLT( 1, 0, -2 )' produces result
`0x1.0p- 2' (note a space between minus and two) which is not a correct floating point
literal.
------------------------------------------------------------------------------------------------
*/
#if defined ( _MSC_VER ) && ! defined( __INTEL_COMPILER )
// If compiler does not support hex floating point literals:
#define HEX_FLT( sm, int, fract, se, exp ) sm ldexpf( (float)( 0x ## int ## fract ## UL ), se exp + ilogbf( (float) 0x ## int ) - ilogbf( ( float )( 0x ## int ## fract ## UL ) ) )
#define HEX_DBL( sm, int, fract, se, exp ) sm ldexp( (double)( 0x ## int ## fract ## ULL ), se exp + ilogb( (double) 0x ## int ) - ilogb( ( double )( 0x ## int ## fract ## ULL ) ) )
#define HEX_LDBL( sm, int, fract, se, exp ) sm ldexpl( (long double)( 0x ## int ## fract ## ULL ), se exp + ilogbl( (long double) 0x ## int ) - ilogbl( ( long double )( 0x ## int ## fract ## ULL ) ) )
#else
// If compiler supports hex floating point literals: just concatenate all the parts into a literal.
#define HEX_FLT( sm, int, fract, se, exp ) sm 0x ## int ## . ## fract ## p ## se ## exp ## F
#define HEX_DBL( sm, int, fract, se, exp ) sm 0x ## int ## . ## fract ## p ## se ## exp
#define HEX_LDBL( sm, int, fract, se, exp ) sm 0x ## int ## . ## fract ## p ## se ## exp ## L
#endif
#if defined(__MINGW32__)
#include <Windows.h>
#define sleep(sec) Sleep((sec) * 1000)
#endif
#endif // _COMPAT_H_

6
test_conformance/compatibility/test_common/harness/kernelHelpers.c
View File

@@ -475,14 +475,14 @@ size_t get_pixel_bytes( const cl_image_format *fmt )
return 0;
}
int verifyImageSupport( cl_device_id device )
test_status verifyImageSupport( cl_device_id device )
{
if( checkForImageSupport( device ) )
{
log_error( "ERROR: Device does not supported images as required by this test!\n" );
return CL_IMAGE_FORMAT_NOT_SUPPORTED;
return TEST_FAIL;
}
return 0;
return TEST_PASS;
}
int checkForImageSupport( cl_device_id device )

5
test_conformance/compatibility/test_common/harness/kernelHelpers.h
View File

@@ -17,6 +17,7 @@
#define _kernelHelpers_h
#include "compat.h"
#include "testHarness.h"
#include <stdio.h>
#include <stdlib.h>
@@ -84,8 +85,8 @@ extern int is_image_format_supported( cl_context context, cl_mem_flags flags, cl
/* Helper to get pixel size for a pixel format */
size_t get_pixel_bytes( const cl_image_format *fmt );
/* Verify the given device supports images. 0 means you're good to go, otherwise an error */
extern int verifyImageSupport( cl_device_id device );
/* Verify the given device supports images. */
extern test_status verifyImageSupport( cl_device_id device );
/* Checks that the given device supports images. Same as verify, but doesn't print an error */
extern int checkForImageSupport( cl_device_id device );

325
test_conformance/compatibility/test_common/harness/msvc9.c
View File

@@ -13,15 +13,18 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//
#if defined(_WIN32) && defined (_MSC_VER)
#include "compat.h"
#include <math.h>
#include <float.h>
#include <assert.h>
#include <CL/cl_platform.h>
#if defined ( _MSC_VER )
#include <limits.h>
#include <stdlib.h>
#include <CL/cl.h>
#include <windows.h>
#if ! defined( __INTEL_COMPILER )
///////////////////////////////////////////////////////////////////
//
@@ -387,86 +390,6 @@ long double log2l(long double x)
return 1.44269504088896340735992468100189214L * log(x);
}
///////////////////////////////////////////////////////////////////
//
// misc functions
//
///////////////////////////////////////////////////////////////////
/*
// This function is commented out because the Windows implementation should never call munmap.
// If it is calling it, we have a bug. Please file a bugzilla.
int munmap(void *addr, size_t len)
{
// FIXME: this is not correct. munmap is like free() http://www.opengroup.org/onlinepubs/7990989775/xsh/munmap.html
return (int)VirtualAlloc( (LPVOID)addr, len,
MEM_COMMIT|MEM_RESERVE, PAGE_NOACCESS );
}
*/
uint64_t ReadTime( void )
{
LARGE_INTEGER current;
QueryPerformanceCounter(&current);
return (uint64_t)current.QuadPart;
}
double SubtractTime( uint64_t endTime, uint64_t startTime )
{
static double PerformanceFrequency = 0.0;
if (PerformanceFrequency == 0.0) {
LARGE_INTEGER frequency;
QueryPerformanceFrequency(&frequency);
PerformanceFrequency = (double) frequency.QuadPart;
}
return (double)(endTime - startTime) / PerformanceFrequency * 1e9;
}
float make_nan()
{
/* This is the IEEE 754 single-precision format:
unsigned int mantissa: 22;
unsigned int quiet_nan: 1;
unsigned int exponent: 8;
unsigned int negative: 1;
*/
//const static unsigned
static const int32_t _nan = 0x7fc00000;
return *(const float*)(&_nan);
}
float nanf( const char* str)
{
cl_uint u = atoi( str );
u |= 0x7fc00000U;
return *( float*)(&u);
}
double nan( const char* str)
{
cl_ulong u = atoi( str );
u |= 0x7ff8000000000000ULL;
return *( double*)(&u);
}
// double check this implementatation
long double nanl( const char* str)
{
union
{
long double f;
struct { cl_ulong m; cl_ushort sexp; }u;
}u;
u.u.sexp = 0x7fff;
u.u.m = 0x8000000000000000ULL | atoi( str );
return u.f;
}
double trunc(double x)
{
double absx = fabs(x);
@@ -589,7 +512,165 @@ long double roundl(long double x)
return x;
}
int signbit(double x)
float cbrtf( float x )
{
float z = pow( fabs((double) x), 1.0 / 3.0 );
return copysignf( z, x );
}
double cbrt( double x )
{
return copysign( pow( fabs( x ), 1.0 / 3.0 ), x );
}
long int lrint (double x)
{
double absx = fabs(x);
if( x >= (double) LONG_MAX )
return LONG_MAX;
if( absx < 4503599627370496.0 /* 0x1.0p52 */ )
{
double magic = copysign( 4503599627370496.0 /* 0x1.0p52 */, x );
double rounded = x + magic;
rounded -= magic;
return (long int) rounded;
}
return (long int) x;
}
long int lrintf (float x)
{
float absx = fabsf(x);
if( x >= (float) LONG_MAX )
return LONG_MAX;
if( absx < 8388608.0f /* 0x1.0p23f */ )
{
float magic = copysignf( 8388608.0f /* 0x1.0p23f */, x );
float rounded = x + magic;
rounded -= magic;
return (long int) rounded;
}
return (long int) x;
}
///////////////////////////////////////////////////////////////////
//
// fenv functions
//
///////////////////////////////////////////////////////////////////
int fetestexcept(int excepts)
{
unsigned int status = _statusfp();
return excepts & (
((status & _SW_INEXACT) ? FE_INEXACT : 0) |
((status & _SW_UNDERFLOW) ? FE_UNDERFLOW : 0) |
((status & _SW_OVERFLOW) ? FE_OVERFLOW : 0) |
((status & _SW_ZERODIVIDE) ? FE_DIVBYZERO : 0) |
((status & _SW_INVALID) ? FE_INVALID : 0)
);
}
int feclearexcept(int excepts)
{
_clearfp();
return 0;
}
#endif // __INTEL_COMPILER
#if ! defined( __INTEL_COMPILER ) || __INTEL_COMPILER < 1300
float make_nan()
{
/* This is the IEEE 754 single-precision format:
unsigned int mantissa: 22;
unsigned int quiet_nan: 1;
unsigned int exponent: 8;
unsigned int negative: 1;
*/
//const static unsigned
static const int32_t _nan = 0x7fc00000;
return *(const float*)(&_nan);
}
float nanf( const char* str)
{
cl_uint u = atoi( str );
u |= 0x7fc00000U;
return *( float*)(&u);
}
double nan( const char* str)
{
cl_ulong u = atoi( str );
u |= 0x7ff8000000000000ULL;
return *( double*)(&u);
}
// double check this implementatation
long double nanl( const char* str)
{
union
{
long double f;
struct { cl_ulong m; cl_ushort sexp; }u;
}u;
u.u.sexp = 0x7fff;
u.u.m = 0x8000000000000000ULL | atoi( str );
return u.f;
}
#endif
///////////////////////////////////////////////////////////////////
//
// misc functions
//
///////////////////////////////////////////////////////////////////
/*
// This function is commented out because the Windows implementation should never call munmap.
// If it is calling it, we have a bug. Please file a bugzilla.
int munmap(void *addr, size_t len)
{
// FIXME: this is not correct. munmap is like free() http://www.opengroup.org/onlinepubs/7990989775/xsh/munmap.html
return (int)VirtualAlloc( (LPVOID)addr, len,
MEM_COMMIT|MEM_RESERVE, PAGE_NOACCESS );
}
*/
uint64_t ReadTime( void )
{
LARGE_INTEGER current;
QueryPerformanceCounter(&current);
return (uint64_t)current.QuadPart;
}
double SubtractTime( uint64_t endTime, uint64_t startTime )
{
static double PerformanceFrequency = 0.0;
if (PerformanceFrequency == 0.0) {
LARGE_INTEGER frequency;
QueryPerformanceFrequency(&frequency);
PerformanceFrequency = (double) frequency.QuadPart;
}
return (double)(endTime - startTime) / PerformanceFrequency * 1e9;
}
int cf_signbit(double x)
{
union
{
@@ -600,7 +681,7 @@ int signbit(double x)
return u.u >> 63;
}
int signbitf(float x)
int cf_signbitf(float x)
{
union
{
@@ -611,17 +692,6 @@ int signbitf(float x)
return u.u >> 31;
}
float cbrtf( float x )
{
float z = pow( fabs((double) x), 1.0 / 3.0 );
return copysignf( z, x );
}
double cbrt( double x )
{
return copysign( pow( fabs( x ), 1.0 / 3.0 ), x );
}
float int2float (int32_t ix)
{
union {
@@ -642,7 +712,7 @@ int32_t float2int (float fx)
return u.i;
}
#if defined(_MSC_VER) && !defined(_WIN64)
#if !defined(_WIN64)
/** Returns the number of leading 0-bits in x,
starting at the most significant bit position.
If x is 0, the result is undefined.
@@ -682,45 +752,10 @@ int __builtin_clz(unsigned int pattern)
return count;
}
#endif //defined(_MSC_VER) && !defined(_WIN64)
#endif // !defined(_WIN64)
#include <intrin.h>
#include <emmintrin.h>
long int lrint (double x)
{
double absx = fabs(x);
if( x >= (double) LONG_MAX )
return LONG_MAX;
if( absx < 4503599627370496.0 /* 0x1.0p52 */ )
{
double magic = copysign( 4503599627370496.0 /* 0x1.0p52 */, x );
double rounded = x + magic;
rounded -= magic;
return (long int) rounded;
}
return (long int) x;
}
long int lrintf (float x)
{
float absx = fabsf(x);
if( x >= (float) LONG_MAX )
return LONG_MAX;
if( absx < 8388608.0f /* 0x1.0p23f */ )
{
float magic = copysignf( 8388608.0f /* 0x1.0p23f */, x );
float rounded = x + magic;
rounded -= magic;
return (long int) rounded;
}
return (long int) x;
}
int usleep(int usec)
{
@@ -728,22 +763,10 @@ int usleep(int usec)
return 0;
}
int fetestexcept(int excepts)
unsigned int sleep( unsigned int sec )
{
unsigned int status = _statusfp();
return excepts & (
((status & _SW_INEXACT) ? FE_INEXACT : 0) |
((status & _SW_UNDERFLOW) ? FE_UNDERFLOW : 0) |
((status & _SW_OVERFLOW) ? FE_OVERFLOW : 0) |
((status & _SW_ZERODIVIDE) ? FE_DIVBYZERO : 0) |
((status & _SW_INVALID) ? FE_INVALID : 0)
);
}
int feclearexcept(int excepts)
{
_clearfp();
Sleep( sec * 1000 );
return 0;
}
#endif //defined(_WIN32)
#endif // defined( _MSC_VER )

14
test_conformance/compatibility/test_common/harness/testHarness.c
View File

@@ -439,10 +439,18 @@ int runTestHarnessWithCheck( int argc, const char *argv[], unsigned int num_fns,
/* If we have a device checking function, run it */
if( ( deviceCheckFn != NULL ) && deviceCheckFn( device ) != CL_SUCCESS )
if( ( deviceCheckFn != NULL ) )
{
test_finish();
return -1;
test_status status = deviceCheckFn( device );
switch (status)
{
case TEST_PASS:
break;
case TEST_FAIL:
return 1;
case TEST_SKIP:
return 0;
}
}
if (num_elements <= 0)

11
test_conformance/compatibility/test_common/harness/testHarness.h
View File

@@ -23,6 +23,13 @@
extern "C" {
#endif
typedef enum test_status
{
TEST_PASS = 0,
TEST_FAIL = 1,
TEST_SKIP = 2,
} test_status;
extern cl_uint gReSeed;
extern cl_uint gRandomSeed;
@@ -32,8 +39,8 @@ extern int runTestHarness( int argc, const char *argv[], unsigned int num_fns,
basefn fnList[], const char *fnNames[],
int imageSupportRequired, int forceNoContextCreation, cl_command_queue_properties queueProps );
// Device checking function. See runTestHarnessWithCheck. If this function returns anything other than CL_SUCCESS (0), the harness exits.
typedef int (*DeviceCheckFn)( cl_device_id device );
// Device checking function. See runTestHarnessWithCheck. If this function returns anything other than TEST_PASS, the harness exits.
typedef test_status (*DeviceCheckFn)( cl_device_id device );
// Same as runTestHarness, but also supplies a function that checks the created device for required functionality.
extern int runTestHarnessWithCheck( int argc, const char *argv[], unsigned int num_fns,

1
test_conformance/compatibility/test_conformance/api/CMakeLists.txt
View File

@@ -20,6 +20,7 @@ set(${MODULE_NAME}_SOURCES
test_mem_object_info.cpp
test_null_buffer_arg.c
test_kernel_arg_info.c
test_queue_properties.cpp
../../test_common/harness/errorHelpers.c
../../test_common/harness/threadTesting.c
../../test_common/harness/testHarness.c

2
test_conformance/compatibility/test_conformance/api/main.c
View File

@@ -113,6 +113,7 @@ basefn basefn_list[] = {
test_get_image1d_info,
test_get_image1d_array_info,
test_get_image2d_array_info,
test_queue_properties,
};
@@ -200,6 +201,7 @@ const char *basefn_names[] = {
"get_image1d_info",
"get_image1d_array_info",
"get_image2d_array_info",
"queue_properties",
};
ct_assert((sizeof(basefn_names) / sizeof(basefn_names[0])) == (sizeof(basefn_list) / sizeof(basefn_list[0])));

1
test_conformance/compatibility/test_conformance/api/procs.h
View File

@@ -105,4 +105,5 @@ extern int test_get_image1d_info( cl_device_id deviceID, cl_context context
extern int test_get_image1d_array_info( cl_device_id deviceID, cl_context context, cl_command_queue ignoreQueue, int num_elements );
extern int test_get_image2d_array_info( cl_device_id deviceID, cl_context context, cl_command_queue ignoreQueue, int num_elements );
extern int test_get_kernel_arg_info( cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements );
extern int test_queue_properties( cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements );

174
test_conformance/compatibility/test_conformance/api/test_queue_properties.cpp Normal file
View File

@@ -0,0 +1,174 @@
//
// Copyright (c) 2018 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 "testBase.h"
#include "../../test_common/harness/typeWrappers.h"
#include "../../test_common/harness/conversions.h"
#include <sstream>
#include <string>
#include <vector>
using namespace std;
/*
The test against cl_khr_create_command_queue extension. It validates if devices with Opencl 1.X can use clCreateCommandQueueWithPropertiesKHR function.
Based on device capabilities test will create queue with NULL properties, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE property and
CL_QUEUE_PROFILING_ENABLE property. Finally simple kernel will be executed on such queue.
*/
const char *queue_test_kernel[] = {
"__kernel void vec_cpy(__global int *src, __global int *dst)\n"
"{\n"
" int tid = get_global_id(0);\n"
"\n"
" dst[tid] = src[tid];\n"
"\n"
"}\n" };
int enqueue_kernel(cl_context context, const cl_queue_properties_khr *queue_prop_def, cl_device_id deviceID, clKernelWrapper& kernel, size_t num_elements)
{
clMemWrapper streams[2];
int error;
std::vector<int> buf(num_elements);
clCreateCommandQueueWithPropertiesKHR_fn clCreateCommandQueueWithPropertiesKHR = NULL;
cl_platform_id platform;
clEventWrapper event;
error = clGetDeviceInfo(deviceID, CL_DEVICE_PLATFORM, sizeof(cl_platform_id), &platform, NULL);
test_error(error, "clGetDeviceInfo for CL_DEVICE_PLATFORM failed");
clCreateCommandQueueWithPropertiesKHR = (clCreateCommandQueueWithPropertiesKHR_fn) clGetExtensionFunctionAddressForPlatform(platform, "clCreateCommandQueueWithPropertiesKHR");
if (clCreateCommandQueueWithPropertiesKHR == NULL)
{
log_error("ERROR: clGetExtensionFunctionAddressForPlatform failed\n");
return -1;
}
clCommandQueueWrapper queue = clCreateCommandQueueWithPropertiesKHR(context, deviceID, queue_prop_def, &error);
test_error(error, "clCreateCommandQueueWithPropertiesKHR failed");
for (int i = 0; i < num_elements; ++i)
{
buf[i] = i;
}
streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR, num_elements * sizeof(int), buf.data(), &error);
test_error( error, "clCreateBuffer failed." );
streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR, num_elements * sizeof(int), NULL, &error);
test_error( error, "clCreateBuffer failed." );
error = clSetKernelArg(kernel, 0, sizeof(streams[0]), &streams[0]);
test_error( error, "clSetKernelArg failed." );
error = clSetKernelArg(kernel, 1, sizeof(streams[1]), &streams[1]);
test_error( error, "clSetKernelArg failed." );
error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, &num_elements, NULL, 0, NULL, &event);
test_error( error, "clEnqueueNDRangeKernel failed." );
error = clWaitForEvents(1, &event);
test_error(error, "clWaitForEvents failed.");
error = clEnqueueReadBuffer(queue, streams[1], CL_TRUE, 0, num_elements, buf.data(), 0, NULL, NULL);
test_error( error, "clEnqueueReadBuffer failed." );
for (int i = 0; i < num_elements; ++i)
{
if (buf[i] != i)
{
log_error("ERROR: Incorrect vector copy result.");
return -1;
}
}
return 0;
}
int test_queue_properties(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
if (num_elements <= 0)
{
num_elements = 128;
}
int error = 0;
clProgramWrapper program;
clKernelWrapper kernel;
size_t strSize;
std::string strExt(0, '\0');
cl_queue_properties_khr device_props = NULL;
cl_queue_properties_khr queue_prop_def[] = { CL_QUEUE_PROPERTIES, 0, 0 };
// Query extension
error = clGetDeviceInfo(deviceID, CL_DEVICE_EXTENSIONS, 0, NULL, &strSize);
test_error(error, "clGetDeviceInfo for CL_DEVICE_EXTENSIONS failed");
strExt.resize(strSize);
error = clGetDeviceInfo(deviceID, CL_DEVICE_EXTENSIONS, strExt.size(), &strExt[0], NULL);
test_error(error, "clGetDeviceInfo for CL_DEVICE_EXTENSIONS failed");
log_info("CL_DEVICE_EXTENSIONS:\n%s\n\n", strExt.c_str());
if (strExt.find("cl_khr_create_command_queue") == string::npos)
{
log_info("extension cl_khr_create_command_queue is not supported.\n");
return 0;
}
error = create_single_kernel_helper(context, &program, &kernel, 1, queue_test_kernel, "vec_cpy");
test_error(error, "create_single_kernel_helper failed");
log_info("Queue property NULL. Testing ... \n");
error = enqueue_kernel(context, NULL,deviceID, kernel, (size_t)num_elements);
test_error(error, "enqueue_kernel failed");
error = clGetDeviceInfo(deviceID, CL_DEVICE_QUEUE_PROPERTIES, sizeof(device_props), &device_props, NULL);
test_error(error, "clGetDeviceInfo for CL_DEVICE_QUEUE_PROPERTIES failed");
if (device_props & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE)
{
log_info("Queue property CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE supported. Testing ... \n");
queue_prop_def[1] = CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
error = enqueue_kernel(context, queue_prop_def, deviceID, kernel, (size_t)num_elements);
test_error(error, "enqueue_kernel failed");
} else
{
log_info("Queue property CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE not supported \n");
}
if (device_props & CL_QUEUE_PROFILING_ENABLE)
{
log_info("Queue property CL_QUEUE_PROFILING_ENABLE supported. Testing ... \n");
queue_prop_def[1] = CL_QUEUE_PROFILING_ENABLE;
error = enqueue_kernel(context, queue_prop_def, deviceID, kernel, (size_t)num_elements);
test_error(error, "enqueue_kernel failed");
} else
{
log_info("Queue property CL_QUEUE_PROFILING_ENABLE not supported \n");
}
if (device_props & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE && device_props & CL_QUEUE_PROFILING_ENABLE)
{
log_info("Queue property CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE & CL_QUEUE_PROFILING_ENABLE supported. Testing ... \n");
queue_prop_def[1] = CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE|CL_QUEUE_PROFILING_ENABLE;
error = enqueue_kernel(context, queue_prop_def, deviceID, kernel, (size_t)num_elements);
test_error(error, "enqueue_kernel failed");
}
else
{
log_info("Queue property CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE or CL_QUEUE_PROFILING_ENABLE not supported \n");
}
return 0;
}

0
test_conformance/compatibility/test_conformance/basic/run_array Normal file → Executable file
View File

0
test_conformance/compatibility/test_conformance/basic/run_array_image_copy Normal file → Executable file
View File

0
test_conformance/compatibility/test_conformance/basic/run_image Normal file → Executable file
View File

0
test_conformance/compatibility/test_conformance/basic/run_multi_read_image Normal file → Executable file
View File

4
test_conformance/compatibility/test_conformance/basic/test_async_strided_copy.cpp
View File

@@ -202,10 +202,10 @@ int test_strided_copy(cl_device_id deviceID, cl_context context, cl_command_queu
log_error( "ERROR: Results of copy did not validate!\n" );
sprintf(values + strlen( values), "%d -> [", i);
for (int j=0; j<(int)elementSize; j++)
sprintf(values + strlen( values), "%2x ", inchar[i*elementSize+j]);
sprintf(values + strlen( values), "%2x ", inchar[j]);
sprintf(values + strlen(values), "] != [");
for (int j=0; j<(int)elementSize; j++)
sprintf(values + strlen( values), "%2x ", outchar[i*elementSize+j]);
sprintf(values + strlen( values), "%2x ", outchar[j]);
sprintf(values + strlen(values), "]");
log_error("%s\n", values);

2
test_conformance/compatibility/test_conformance/basic/test_sizeof.c
View File

@@ -133,7 +133,7 @@ const size_table vector_table[] =
const char *ptr_table[] =
{
"void*",
"global void*",
"size_t",
"sizeof(int)", // check return type of sizeof
"ptrdiff_t"

1
test_conformance/compatibility/test_conformance/images/image_helpers.h
View File

@@ -481,7 +481,6 @@ extern char *create_random_image_data( ExplicitType dataType, image_descriptor *
extern void get_sampler_kernel_code( image_sampler_data *imageSampler, char *outLine );
extern float get_max_absolute_error( cl_image_format *format, image_sampler_data *sampler);
extern float get_max_relative_error( cl_image_format *format, image_sampler_data *sampler, int is3D, int isLinearFilter );
extern int issubnormal(float);
#define errMax( _x , _y ) ( (_x) != (_x) ? (_x) : (_x) > (_y) ? (_x) : (_y) )

5
test_conformance/compiler/test_async_build.c
View File

@@ -86,9 +86,8 @@ int test_async_build_pieces(cl_device_id deviceID, cl_context context, cl_comman
return -1;
}
clReleaseProgram( program );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
return 0;
}

60
test_conformance/compiler/test_build_helpers.c
View File

@@ -172,7 +172,8 @@ int test_load_two_kernel_source(cl_device_id deviceID, cl_context context, cl_co
/* Should probably check binary here to verify the same results... */
/* All done! */
clReleaseProgram( program );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
return 0;
}
@@ -198,7 +199,8 @@ int test_load_null_terminated_source(cl_device_id deviceID, cl_context context,
/* Should probably check binary here to verify the same results... */
/* All done! */
clReleaseProgram( program );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
return 0;
}
@@ -224,7 +226,8 @@ int test_load_null_terminated_multi_line_source(cl_device_id deviceID, cl_contex
/* Should probably check binary here to verify the same results... */
/* All done! */
clReleaseProgram( program );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
return 0;
}
@@ -262,7 +265,8 @@ int test_load_discreet_length_source(cl_device_id deviceID, cl_context context,
/* Should probably check binary here to verify the same results... */
/* All done! */
clReleaseProgram( program );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
return 0;
}
@@ -297,7 +301,8 @@ int test_load_null_terminated_partial_multi_line_source(cl_device_id deviceID, c
/* Should probably check binary here to verify the same results... */
/* All done! */
clReleaseProgram( program );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
return 0;
}
@@ -393,7 +398,9 @@ int test_get_program_info(cl_device_id deviceID, cl_context context, cl_command_
return -1;
}
clReleaseProgram( program );
/* All done! */
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
return 0;
}
@@ -445,8 +452,10 @@ int test_get_program_source(cl_device_id deviceID, cl_context context, cl_comman
return -1;
}
/* if we got here, everything passed */
clReleaseProgram( program );
/* All done! */
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
return 0;
}
@@ -493,26 +502,25 @@ int test_get_program_build_info(cl_device_id deviceID, cl_context context, cl_co
error = clGetProgramBuildInfo( program, deviceID, CL_PROGRAM_BUILD_LOG, 0, NULL, &length );
test_error( error, "Unable to get program build log length" );
log_info("Build log is %ld long.\n", length);
log_info("Build log is %ld long.\n", length);
buffer = (char*)malloc(length);
buffer = (char*)malloc(length);
/* Try normal source */
error = clGetProgramBuildInfo( program, deviceID, CL_PROGRAM_BUILD_LOG, length, buffer, NULL );
test_error( error, "Unable to get program build log" );
if( buffer[length-1] != '\0' )
{
if( buffer[length-1] != '\0' )
{
log_error( "clGetProgramBuildInfo overwrote allocated space for build log! '%c'\n", buffer[length-1] );
return -1;
}
}
/* Try both at once */
error = clGetProgramBuildInfo( program, deviceID, CL_PROGRAM_BUILD_LOG, length, buffer, &newLength );
test_error( error, "Unable to get program build log" );
free(buffer);
free(buffer);
/***** Build options *****/
error = clGetProgramBuildInfo( program, deviceID, CL_PROGRAM_BUILD_OPTIONS, 0, NULL, &length );
@@ -530,8 +538,10 @@ int test_get_program_build_info(cl_device_id deviceID, cl_context context, cl_co
free(buffer);
/* Try with a valid option */
clReleaseProgram( program );
/* Try with a valid option */
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
program = clCreateProgramWithSource( context, 1, sample_kernel_code_single_line, NULL, &error );
if( program == NULL )
{
@@ -546,10 +556,10 @@ int test_get_program_build_info(cl_device_id deviceID, cl_context context, cl_co
return -1;
}
error = clGetProgramBuildInfo( program, deviceID, CL_PROGRAM_BUILD_OPTIONS, NULL, NULL, &length );
error = clGetProgramBuildInfo( program, deviceID, CL_PROGRAM_BUILD_OPTIONS, NULL, NULL, &length );
test_error( error, "Unable to get program build options" );
buffer = (char*)malloc(length);
buffer = (char*)malloc(length);
error = clGetProgramBuildInfo( program, deviceID, CL_PROGRAM_BUILD_OPTIONS, length, buffer, NULL );
test_error( error, "Unable to get program build options" );
@@ -559,13 +569,11 @@ int test_get_program_build_info(cl_device_id deviceID, cl_context context, cl_co
return -1;
}
free(buffer);
/* All done */
free( buffer );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
/* if we got here, everything passed */
clReleaseProgram( program );
return 0;
}

86
test_conformance/compiler/test_compile.c
View File

@@ -558,6 +558,9 @@ int test_large_multiple_embedded_headers(cl_context context, cl_device_id device
free( simple_kernels );
free( headers );
error = clReleaseKernel( kernel );
test_error( error, "Unable to release kernel object" );
error = clReleaseProgram( my_newly_minted_library );
test_error( error, "Unable to release program object" );
@@ -728,6 +731,9 @@ int test_large_multiple_libraries(cl_context context, cl_device_id deviceID, cl_
}
free( simple_kernels );
error = clReleaseKernel( kernel );
test_error( error, "Unable to release kernel object" );
error = clReleaseProgram( my_newly_linked_program );
test_error( error, "Unable to release program object" );
@@ -895,6 +901,9 @@ int test_large_multiple_files_multiple_libraries(cl_context context, cl_device_i
}
free( simple_kernels );
error = clReleaseKernel( kernel );
test_error( error, "Unable to release kernel object" );
error = clReleaseProgram( my_newly_linked_program );
test_error( error, "Unable to release program object" );
@@ -1032,6 +1041,9 @@ int test_large_multiple_files(cl_context context, cl_device_id deviceID, cl_comm
}
free( lines );
error = clReleaseKernel( kernel );
test_error( error, "Unable to release kernel object" );
error = clReleaseProgram( my_newly_linked_program );
test_error( error, "Unable to release program object" );
@@ -1311,6 +1323,9 @@ int test_simple_embedded_header_compile(cl_device_id deviceID, cl_context contex
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
error = clReleaseProgram( header );
test_error( error, "Unable to release program object" );
return 0;
}
@@ -1517,6 +1532,9 @@ int test_simple_embedded_header_link(cl_device_id deviceID, cl_context context,
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
error = clReleaseProgram( header );
test_error( error, "Unable to release program object" );
error = clReleaseProgram( simple_program );
test_error( error, "Unable to release program object" );
@@ -1571,7 +1589,7 @@ int test_simple_link_with_callback(cl_device_id deviceID, cl_context context, cl
simple_user_data simple_link_user_data = {when_i_pondered_weak_and_weary, link_program_completion_event};
clLinkProgram(context, 1, &deviceID, NULL, 1, &program, simple_link_callback, (void*)&simple_link_user_data, &error);
cl_program my_linked_library = clLinkProgram(context, 1, &deviceID, NULL, 1, &program, simple_link_callback, (void*)&simple_link_user_data, &error);
test_error( error, "Unable to link a simple program" );
error = clWaitForEvents(1, &link_program_completion_event);
@@ -1584,6 +1602,9 @@ int test_simple_link_with_callback(cl_device_id deviceID, cl_context context, cl
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
error = clReleaseProgram( my_linked_library );
test_error( error, "Unable to release program object" );
return 0;
}
@@ -1738,6 +1759,9 @@ int test_execute_after_simple_compile_and_link(cl_device_id deviceID, cl_context
return error;
/* All done! */
error = clReleaseKernel( kernel );
test_error( error, "Unable to release kernel object" );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
@@ -1774,6 +1798,9 @@ int test_execute_after_simple_compile_and_link_no_device_info(cl_device_id devic
return error;
/* All done! */
error = clReleaseKernel( kernel );
test_error( error, "Unable to release kernel object" );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
@@ -1810,6 +1837,9 @@ int test_execute_after_simple_compile_and_link_with_defines(cl_device_id deviceI
return error;
/* All done! */
error = clReleaseKernel( kernel );
test_error( error, "Unable to release kernel object" );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
@@ -1887,6 +1917,9 @@ int test_execute_after_serialize_reload_object(cl_device_id deviceID, cl_context
return error;
/* All done! */
error = clReleaseKernel( kernel );
test_error( error, "Unable to release kernel object" );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
@@ -1991,6 +2024,12 @@ int test_execute_after_serialize_reload_library(cl_device_id deviceID, cl_contex
return error;
/* All done! */
error = clReleaseKernel( kernel );
test_error( error, "Unable to release kernel object" );
error = clReleaseKernel( another_kernel );
test_error( error, "Unable to release another kernel object" );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
@@ -2065,7 +2104,8 @@ int test_execute_after_simple_compile_and_link_with_callbacks(cl_device_id devic
error = clWaitForEvents(1, &compile_program_completion_event);
test_error( error, "clWaitForEvents failed when waiting on compile_program_completion_event");
clReleaseEvent(compile_program_completion_event);
error = clReleaseEvent(compile_program_completion_event);
test_error( error, "Unable to release event object" );
link_program_completion_event = clCreateUserEvent(context, &error);
test_error( error, "Unable to create a user event");
@@ -2077,7 +2117,8 @@ int test_execute_after_simple_compile_and_link_with_callbacks(cl_device_id devic
error = clWaitForEvents(1, &link_program_completion_event);
test_error( error, "clWaitForEvents failed when waiting on link_program_completion_event");
clReleaseEvent(link_program_completion_event);
error = clReleaseEvent(link_program_completion_event);
test_error( error, "Unable to release event object" );
cl_kernel kernel = clCreateKernel(my_newly_linked_program, "CopyBuffer", &error);
test_error( error, "Unable to create a simple kernel" );
@@ -2087,6 +2128,9 @@ int test_execute_after_simple_compile_and_link_with_callbacks(cl_device_id devic
return error;
/* All done! */
error = clReleaseKernel( kernel );
test_error( error, "Unable to release kernel object" );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
@@ -2264,6 +2308,12 @@ int test_execute_after_simple_library_with_link(cl_device_id deviceID, cl_contex
return error;
/* All done! */
error = clReleaseKernel( kernel );
test_error( error, "Unable to release kernel object" );
error = clReleaseKernel( another_kernel );
test_error( error, "Unable to release another kernel object" );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
@@ -2368,6 +2418,12 @@ int test_execute_after_two_file_link(cl_device_id deviceID, cl_context context,
return error;
/* All done! */
error = clReleaseKernel( kernel );
test_error( error, "Unable to release kernel object" );
error = clReleaseKernel( another_kernel );
test_error( error, "Unable to release another kernel object" );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
@@ -2433,9 +2489,18 @@ int test_execute_after_embedded_header_link(cl_device_id deviceID, cl_context co
return error;
/* All done! */
error = clReleaseKernel( kernel );
test_error( error, "Unable to release kernel object" );
error = clReleaseKernel( another_kernel );
test_error( error, "Unable to release another kernel object" );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
error = clReleaseProgram( header );
test_error( error, "Unable to release program object" );
error = clReleaseProgram( simple_program );
test_error( error, "Unable to release program object" );
@@ -2563,6 +2628,12 @@ int test_execute_after_included_header_link(cl_device_id deviceID, cl_context co
return error;
/* All done! */
error = clReleaseKernel( kernel );
test_error( error, "Unable to release kernel object" );
error = clReleaseKernel( another_kernel );
test_error( error, "Unable to release another kernel object" );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
@@ -2803,6 +2874,12 @@ int test_program_binary_type(cl_device_id deviceID, cl_context context, cl_comma
return error;
/* All done! */
error = clReleaseKernel( kernel );
test_error( error, "Unable to release kernel object" );
error = clReleaseKernel( another_kernel );
test_error( error, "Unable to release another kernel object" );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );
@@ -3107,6 +3184,9 @@ int test_large_compile_and_link_status_options_log(cl_context context, cl_device
return error;
/* All done! */
error = clReleaseKernel( kernel );
test_error( error, "Unable to release kernel object" );
error = clReleaseProgram( program );
test_error( error, "Unable to release program object" );

6
test_conformance/compiler/test_compiler_defines_for_extensions.cpp
View File

@@ -55,6 +55,8 @@ const char *known_extensions[] = {
"cl_khr_egl_event",
"cl_khr_throttle_hints",
"cl_khr_priority_hints",
"cl_khr_create_command_queue",
"cl_khr_il_program",
};
size_t num_known_extensions = sizeof(known_extensions)/sizeof(char*);
@@ -413,6 +415,10 @@ int test_compiler_defines_for_extensions(cl_device_id device, cl_context context
free(extensions_supported[i]);
}
free(extensions);
if( defines ) {
error = clReleaseMemObject( defines );
test_error( error, "Unable to release memory object" );
}
if (total_errors)
return -1;

8
test_conformance/compiler/test_image_macro.c
View File

@@ -89,7 +89,13 @@ int test_image_macro(cl_device_id deviceID, cl_context context, cl_command_queue
log_info("CL_DEVICE_IMAGE_SUPPORT not set, __IMAGE_SUPPORT__ macro not set \n");
}
clReleaseProgram( program );
status = clReleaseProgram( program );
if( status )
{
log_error ("Unable to release program object, [%d] \n", status );
return status;
}
return status;
}

4
test_conformance/computeinfo/main.c
View File

@@ -227,6 +227,10 @@ config_info config_infos[] =
CONFIG_INFO( 2, 0, CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT , cl_uint),
CONFIG_INFO( 2, 0, CL_DEVICE_SVM_CAPABILITIES, cl_device_svm_capabilities),
CONFIG_INFO( 2, 1, CL_DEVICE_IL_VERSION, string),
CONFIG_INFO( 2, 1, CL_DEVICE_MAX_NUM_SUB_GROUPS, cl_uint),
CONFIG_INFO( 2, 1, CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS, cl_uint),
};
#define ENTRY(T) { T, #T }

4
test_conformance/contractions/Makefile
View File

@@ -9,11 +9,11 @@ LIBRARIES = -framework OpenCL -framework ApplicationServices -framework IOKit -I
release:
echo "Build Release"
$(CC) *.c ../../test_common/harness/rounding_mode.c ../../test_common/harness/kernelHelpers.c ../../test_common/harness/errorHelpers.c ../../test_common/harness/mt19937.c -Os $(CFLAGS) -o contractions $(LIBRARIES)
$(CC) *.c ../../test_common/harness/testHarness.c ../../test_common/harness/rounding_mode.c ../../test_common/harness/kernelHelpers.c ../../test_common/harness/errorHelpers.c ../../test_common/harness/mt19937.c -Os $(CFLAGS) -o contractions $(LIBRARIES)
debug:
echo "Build Debug"
$(CC) *.c ../../test_common/harness/rounding_mode.c ../../test_common/harness/kernelHelpers.c ../../test_common/harness/errorHelpers.c ../../test_common/harness/mt19937.c -O0 $(CFLAGS) -D_DEBUG=1 -o contractions_debug $(LIBRARIES)
$(CC) *.c ../../test_common/harness/testHarness.c ../../test_common/harness/rounding_mode.c ../../test_common/harness/kernelHelpers.c ../../test_common/harness/errorHelpers.c ../../test_common/harness/mt19937.c -O0 $(CFLAGS) -D_DEBUG=1 -o contractions_debug $(LIBRARIES)
test: release
arch -i386 ./contractions -c > cpu.log;

203
test_conformance/contractions/contractions.c
View File

@@ -35,6 +35,7 @@
#include "../../test_common/harness/kernelHelpers.h"
#include "../../test_common/harness/rounding_mode.h"
#include "../../test_common/harness/fpcontrol.h"
#include "../../test_common/harness/testHarness.h"
#include "../../test_common/harness/parseParameters.h"
#if defined( __APPLE__ )
#include <sys/sysctl.h>
@@ -93,6 +94,9 @@ int *skipTest[8];
double *buf3_double, *buf4_double, *buf5_double, *buf6_double;
double *correct_double[8];
static const char **gArgList;
static size_t gArgCount;
#define BUFFER_SIZE (1024*1024)
@@ -217,11 +221,130 @@ float ppc_mul(float a, float b)
}
#endif
int test_contractions_float_0(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return RunTest(0);
}
int test_contractions_float_1(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return RunTest(1);
}
int test_contractions_float_2(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return RunTest(2);
}
int test_contractions_float_3(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return RunTest(3);
}
int test_contractions_float_4(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return RunTest(4);
}
int test_contractions_float_5(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return RunTest(5);
}
int test_contractions_float_6(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return RunTest(6);
}
int test_contractions_float_7(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return RunTest(7);
}
int test_contractions_double_0(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return RunTest_Double(0);
}
int test_contractions_double_1(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return RunTest_Double(1);
}
int test_contractions_double_2(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return RunTest_Double(2);
}
int test_contractions_double_3(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return RunTest_Double(3);
}
int test_contractions_double_4(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return RunTest_Double(4);
}
int test_contractions_double_5(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return RunTest_Double(5);
}
int test_contractions_double_6(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return RunTest_Double(6);
}
int test_contractions_double_7(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return RunTest_Double(7);
}
basefn basefn_list[] = {
test_contractions_float_0,
test_contractions_float_1,
test_contractions_float_2,
test_contractions_float_3,
test_contractions_float_4,
test_contractions_float_5,
test_contractions_float_6,
test_contractions_float_7,
test_contractions_double_0,
test_contractions_double_1,
test_contractions_double_2,
test_contractions_double_3,
test_contractions_double_4,
test_contractions_double_5,
test_contractions_double_6,
test_contractions_double_7,
};
const char *basefn_names[] = {
"contractions_float_0",
"contractions_float_1",
"contractions_float_2",
"contractions_float_3",
"contractions_float_4",
"contractions_float_5",
"contractions_float_6",
"contractions_float_7",
"contractions_double_0",
"contractions_double_1",
"contractions_double_2",
"contractions_double_3",
"contractions_double_4",
"contractions_double_5",
"contractions_double_6",
"contractions_double_7",
};
ct_assert((sizeof(basefn_names) / sizeof(basefn_names[0])) == (sizeof(basefn_list) / sizeof(basefn_list[0])));
int num_fns = sizeof(basefn_names) / sizeof(char *);
int main( int argc, const char **argv )
{
int error = 0;
int i;
test_start();
argc = parseCustomParam(argc, argv);
if (argc == -1)
@@ -230,40 +353,30 @@ int main( int argc, const char **argv )
return -1;
}
error = ParseArgs( argc, argv );
int error = ParseArgs( argc, argv );
if( error )
return error;
goto exit;
// Init OpenCL
error = InitCL();
if( error )
return error;
goto exit;
// run the tests
log_info( "Testing floats...\n" );
for( i = 0; i < 8; i++ )
error |= RunTest( i );
error = parseAndCallCommandLineTests( gArgCount, gArgList, NULL, num_fns, basefn_list, basefn_names, true, 0, 0 );
if( gHasDouble )
exit:
if( gQueue )
{
log_info( "Testing doubles...\n" );
for( i = 0; i < 8; i++ )
error |= RunTest_Double( i );
int flush_error = clFinish( gQueue );
if( flush_error )
log_error( "clFinish failed: %d\n", flush_error );
}
int flush_error = clFinish(gQueue);
if (flush_error)
log_error("clFinish failed: %d\n", flush_error);
if( error )
vlog_error( "Contractions test FAILED.\n" );
else
vlog( "Contractions test PASSED.\n" );
ReleaseCL();
test_finish();
free( gArgList );
return error;
}
@@ -271,6 +384,17 @@ int main( int argc, const char **argv )
static int ParseArgs( int argc, const char **argv )
{
gArgList = (const char **)calloc( argc, sizeof( char*) );
if( NULL == gArgList )
{
vlog_error( "Failed to allocate memory for argList\n" );
return 1;
}
gArgList[0] = argv[0];
gArgCount = 1;
int i;
int length_of_seed = 0;
@@ -354,9 +478,6 @@ static int ParseArgs( int argc, const char **argv )
gForceFTZ ^= 1;
break;
case ' ':
break;
default:
vlog( " <-- unknown flag: %c (0x%2.2x)\n)", *arg, *arg );
PrintUsage();
@@ -374,8 +495,8 @@ static int ParseArgs( int argc, const char **argv )
gDeviceType = CL_DEVICE_TYPE_DEFAULT;
else
{
vlog( "ERROR -- unknown argument: %s\n", arg );
abort();
gArgList[gArgCount] = arg;
gArgCount++;
}
}
vlog( "\n\nTest binary built %s %s\n", __DATE__, __TIME__ );
@@ -401,6 +522,8 @@ static void PrintArch( void )
vlog( "\tARCH:\tx86_64\n" );
#elif defined( __arm__ )
vlog( "\tARCH:\tarm\n" );
#elif defined( __aarch64__ )
vlog( "\tARCH:\taarch64\n" );
#else
vlog( "\tARCH:\tunknown\n" );
#endif
@@ -443,20 +566,20 @@ static void PrintArch( void )
static void PrintUsage( void )
{
vlog( "%s [-z]: <optional: math function names>\n", appName );
vlog( "\toptions:\n" );
vlog( "\tOptions:\n" );
vlog( "\t\t-z\tToggle FTZ mode (Section 6.5.3) for all functions. (Set by device capabilities by default.)\n" );
vlog( "\t\t-sNUMBER set random seed.\n");
vlog( "\n" );
vlog( "\tTest names:\n" );
for( int i = 0; i < num_fns; i++ )
{
vlog( "\t\t%s\n", basefn_names[i] );
}
}
const char *sizeNames[] = { "float", "float2", "float4", "float8", "float16" };
const char *sizeNames_double[] = { "double", "double2", "double4", "double8", "double16" };
static void CL_CALLBACK notify_callback(const char *errinfo, const void *private_info, size_t cb, void *user_data)
{
vlog( "%s\n", errinfo );
}
static int InitCL( void )
{
cl_platform_id platform = NULL;
@@ -619,7 +742,7 @@ static int InitCL( void )
for( j = 2; j < strCount; j += 2 )
kernels[j] = sizeNames[i];
error = create_single_kernel_helper_create_program(gContext, &gProgram[i], strCount, kernels);
gProgram[i] = clCreateProgramWithSource(gContext, strCount, kernels, NULL, &error);
if( NULL == gProgram[i] )
{
vlog_error( "clCreateProgramWithSource failed\n" );
@@ -647,7 +770,7 @@ static int InitCL( void )
for( j = 2; j < strCount; j += 2 )
kernels[j] = sizeNames_double[i];
error = create_single_kernel_helper_create_program(gContext, &gProgram_double[i], strCount, kernels);
gProgram_double[i] = clCreateProgramWithSource(gContext, strCount, kernels, NULL, &error);
if( NULL == gProgram_double[i] )
{
vlog_error( "clCreateProgramWithSource failed\n" );
@@ -1108,6 +1231,12 @@ static int RunTest( int testNumber )
static int RunTest_Double( int testNumber )
{
if( !gHasDouble )
{
vlog("Double is not supported, test not run.\n");
return 0;
}
size_t i;
int error = 0;
cl_mem args[4];

7
test_conformance/conversions/basic_test_conversions.c
View File

@@ -751,16 +751,11 @@ static void ulong2uint( void *out, void *in){ ((cl_uint*) out)[0] = (cl_uint) ((
static void ulong2int( void *out, void *in){ ((cl_int*) out)[0] = (cl_int) ((cl_ulong*) in)[0]; }
static void ulong2float( void *out, void *in)
{
#if defined(_MSC_VER)
#if defined(_MSC_VER) && defined(_M_X64)
cl_ulong l = ((cl_ulong*) in)[0];
float result;
cl_long sl = ((cl_long)l < 0) ? (cl_long)((l >> 1) | (l & 1)) : (cl_long)l;
#if defined(_M_X64)
_mm_store_ss(&result, _mm_cvtsi64_ss(_mm_setzero_ps(), sl));
#else
result = sl;
#endif
((float*) out)[0] = (l == 0 ? 0.0f : (((cl_long)l < 0) ? result * 2.0f : result));
#else
cl_ulong l = ((cl_ulong*) in)[0];

13
test_conformance/conversions/test_conversions.c
View File

@@ -98,6 +98,7 @@ cl_mem gOutBuffers[ kCallStyleCount ];
size_t gComputeDevices = 0;
uint32_t gDeviceFrequency = 0;
int gWimpyMode = 0;
int gWimpyReductionFactor = 128;
int gSkipTesting = 0;
int gForceFTZ = 0;
int gMultithread = 1;
@@ -418,6 +419,9 @@ static int ParseArgs( int argc, const char **argv )
case 'w':
gWimpyMode ^= 1;
break;
case '[':
parseWimpyReductionFactor(arg, gWimpyReductionFactor);
break;
case 'z':
gForceFTZ ^= 1;
break;
@@ -520,6 +524,7 @@ static int ParseArgs( int argc, const char **argv )
vlog( "*** WARNING: Testing in Wimpy mode! ***\n" );
vlog( "*** Wimpy mode is not sufficient to verify correctness. ***\n" );
vlog( "*** It gives warm fuzzy feelings and then nevers calls. ***\n\n" );
vlog("*** Wimpy Reduction Factor: %-27u ***\n\n", gWimpyReductionFactor);
}
return 0;
@@ -546,6 +551,7 @@ static void PrintUsage( void )
vlog( "\t\t-l\tToggle link check mode. When on, testing is skipped, and we just check to see that the kernels build. (Off by default.)\n" );
vlog( "\t\t-m\tToggle Multithreading. (On by default.)\n" );
vlog( "\t\t-w\tToggle wimpy mode. When wimpy mode is on, we run a very small subset of the tests for each fn. NOT A VALID TEST! (Off by default.)\n" );
vlog(" \t\t-[2^n]\tSet wimpy reduction factor, recommended range of n is 1-12, default factor(%u)\n", gWimpyReductionFactor);
vlog( "\t\t-z\tToggle flush to zero mode (Default: per device)\n" );
vlog( "\t\t-#\tTest just vector size given by #, where # is an element of the set {1,2,3,4,8,16}\n" );
vlog( "\n" );
@@ -1245,15 +1251,12 @@ static int DoTest( Type outType, Type inType, SaturationMode sat, RoundingMode r
if ( !gWimpyMode && gIsEmbedded )
step = blockCount * EMBEDDED_REDUCTION_FACTOR;
if ( gWimpyMode )
step = (size_t)blockCount * (size_t)gWimpyReductionFactor;
vlog( "Testing... " );
fflush(stdout);
for( i = 0; i < (uint64_t)lastCase; i += step )
{
if (gWimpyMode) {
uint64_t blockIndex = (i / blockCount) & 0xFF;
if (blockIndex != 0 && blockIndex != 0xFF)
continue;
}
if( 0 == ( i & ((lastCase >> 3) -1))) {
vlog(".");

2
test_conformance/d3d10/harness.cpp
View File

@@ -200,7 +200,7 @@ cl_int HarnessD3D10_CreateDevice(IDXGIAdapter* pAdapter, ID3D10Device **ppDevice
pAdapter,
D3D10_DRIVER_TYPE_HARDWARE,
NULL,
D3D10_CREATE_DEVICE_DEBUG,
0,
D3D10_SDK_VERSION,
&sd,
&HarnessD3D10_pSwapChain,

7
test_conformance/device_execution/execute_block.cpp
View File

@@ -928,15 +928,16 @@ static const char* block_barrier[] =
NL, " size_t gid = get_group_id(0);"
NL, " size_t idx = gid*lsz;"
NL, ""
NL, " res[tid]=lsz;"
NL, " barrier(CLK_GLOBAL_MEM_FENCE);"
NL, " int (^kernelBlock)(int) = ^(int a)"
NL, " {"
NL, " atomic_inc(res+idx);"
NL, " atomic_dec(res+idx);"
NL, " barrier(CLK_GLOBAL_MEM_FENCE);"
NL, " return (int)abs(a - b) - (res[idx] != lsz ? 0 : 1);"
NL, " return (int)abs(a - b) - (res[idx] != 0 ? 0 : 1);"
NL, " };"
NL, ""
NL, " int d = kernelBlock(2);"
NL, " barrier(CLK_GLOBAL_MEM_FENCE);"
NL, " res[tid] = d;"
NL, "}"
NL

64
test_conformance/device_partition/Jamfile
View File

@@ -1,32 +1,32 @@
project
: requirements
<toolset>gcc:<cflags>-xc++
<toolset>msvc:<cflags>"/TP"
;
exe test_device_partition
: main.c
test_device_partition.cpp
../../test_common/harness/errorHelpers.c
../../test_common/harness/threadTesting.c
../../test_common/harness/testHarness.c
../../test_common/harness/kernelHelpers.c
../../test_common/harness/genericThread.cpp
../../test_common/harness/mt19937.c
../../test_common/harness/conversions.c
../../test_common/harness/typeWrappers.cpp
: <target-os>windows:<source>../../test_common/harness/msvc9.c
;
install dist
: test_device_partition
: <variant>debug:<location>$(DIST)/debug/tests/conformance/1.2/x86/device_partition
<variant>release:<location>$(DIST)/release/tests/conformance/1.2/x86/device_partition
;
install dist
: test_device_partition
: <variant>debug:<location>$(DIST)/debug/tests/conformance/1.2/x86_64/device_partition
<variant>release:<location>$(DIST)/release/tests/conformance/1.2/x86_64/device_partition
<address-model>64
;
project
: requirements
<toolset>gcc:<cflags>-xc++
<toolset>msvc:<cflags>"/TP"
;
exe test_device_partition
: main.c
test_device_partition.cpp
../../test_common/harness/errorHelpers.c
../../test_common/harness/threadTesting.c
../../test_common/harness/testHarness.c
../../test_common/harness/kernelHelpers.c
../../test_common/harness/genericThread.cpp
../../test_common/harness/mt19937.c
../../test_common/harness/conversions.c
../../test_common/harness/typeWrappers.cpp
: <target-os>windows:<source>../../test_common/harness/msvc9.c
;
install dist
: test_device_partition
: <variant>debug:<location>$(DIST)/debug/tests/conformance/1.2/x86/device_partition
<variant>release:<location>$(DIST)/release/tests/conformance/1.2/x86/device_partition
;
install dist
: test_device_partition
: <variant>debug:<location>$(DIST)/debug/tests/conformance/1.2/x86_64/device_partition
<variant>release:<location>$(DIST)/release/tests/conformance/1.2/x86_64/device_partition
<address-model>64
;

3
test_conformance/device_timer/main.c
View File

@@ -32,8 +32,7 @@ basefn basefn_list[] = {
const char *basefn_names[] = {
"test_timer_resolution_queries",
"test_device_and_host_timers",
"all"
"test_device_and_host_timers"
};
size_t num_fns = sizeof(basefn_names)/sizeof(basefn_names[0]);

106
test_conformance/generate_spirv_offline.py
View File

@@ -1,53 +1,53 @@
import sys
import os
import platform
import re
import string
import shutil
import traceback
if len(sys.argv)<2:
print 'Usage: "generate_spirv_offline.py <input> <32|64>"'
exit(1)
input_dir = sys.argv[1]
arch = sys.argv[2]
def generate_spirv():
print "generating spirv"
ocl_version = '12';
build_options = ''
if os.path.exists(input_dir):
for root, dirs, files in os.walk(input_dir):
for file in files:
if file.endswith('.cl'):
options_file_name = file[:-2] + "options"
ocl_version = '12'
if os.path.exists(os.path.join(root, options_file_name)):
optFile = open (os.path.join(root, options_file_name), 'rU')
for line in optFile:
if re.search("-cl-std=CL2.0", line):
ocl_version = '20'
build_options = re.sub("-cl-std=CL2.0", "", line)
print build_options
input_string = os.path.join(root, file)
output_string = os.path.join(root, file[:-2])
command_line = ".\\build_script_spirv.py " + input_string + " " + output_string + "spv" + arch + " " + arch + " spir_v " + ocl_version + " \"" + build_options + " \""
print command_line
os.system(command_line)
return 0
def main():
try:
generate_spirv()
except Exception:
traceback.print_exc(file=sys.stdout)
sys.exit(0)
if __name__ == "__main__":
main()
import sys
import os
import platform
import re
import string
import shutil
import traceback
if len(sys.argv)<2:
print 'Usage: "generate_spirv_offline.py <input> <32|64>"'
exit(1)
input_dir = sys.argv[1]
arch = sys.argv[2]
def generate_spirv():
print "generating spirv"
ocl_version = '12';
build_options = ''
if os.path.exists(input_dir):
for root, dirs, files in os.walk(input_dir):
for file in files:
if file.endswith('.cl'):
options_file_name = file[:-2] + "options"
ocl_version = '12'
if os.path.exists(os.path.join(root, options_file_name)):
optFile = open (os.path.join(root, options_file_name), 'rU')
for line in optFile:
if re.search("-cl-std=CL2.0", line):
ocl_version = '20'
build_options = re.sub("-cl-std=CL2.0", "", line)
print build_options
input_string = os.path.join(root, file)
output_string = os.path.join(root, file[:-2])
command_line = ".\\build_script_spirv.py " + input_string + " " + output_string + "spv" + arch + " " + arch + " spir_v " + ocl_version + " \"" + build_options + " \""
print command_line
os.system(command_line)
return 0
def main():
try:
generate_spirv()
except Exception:
traceback.print_exc(file=sys.stdout)
sys.exit(0)
if __name__ == "__main__":
main()

4
test_conformance/geometrics/test_geometrics_double.cpp
View File

@@ -203,7 +203,7 @@ int test_geom_cross_double(cl_device_id deviceID, cl_context context, cl_command
return -1;
/* Generate some streams. Note: deliberately do some random data in w to verify that it gets ignored */
for( i = 0; i < TEST_SIZE * vecsize; i++ )
for( i = 0; i < size * vecsize; i++ )
{
inDataA[ i ] = get_random_double( -512.f, 512.f, d );
inDataB[ i ] = get_random_double( -512.f, 512.f, d );
@@ -237,7 +237,7 @@ int test_geom_cross_double(cl_device_id deviceID, cl_context context, cl_command
}
/* Run the kernel */
threads[0] = TEST_SIZE;
threads[0] = size;
error = get_max_common_work_group_size( context, kernel, threads[0], &localThreads[0] );
test_error( error, "Unable to get work group size to use" );

16
test_conformance/gl/test_image_methods.cpp
View File

@@ -34,7 +34,8 @@ typedef struct image_kernel_data
cl_int numSamples;
};
static const char *methodTestKernelPattern =
static const char *methodTestKernelPattern =
"%s"
"typedef struct {\n"
" int width;\n"
" int height;\n"
@@ -75,6 +76,8 @@ static const char *channelOrderConstLine =
" outData->expectedChannelOrder = CLK_%s;\n";
static const char *numSamplesKernelLine =
" outData->numSamples = get_image_num_samples( input );\n";
static const char *enableMSAAKernelLine =
"#pragma OPENCL EXTENSION cl_khr_gl_msaa_sharing : enable\n";
static int verify(cl_int input, cl_int kernelOutput, const char * description)
{
@@ -185,6 +188,7 @@ int test_image_format_methods( cl_device_id device, cl_context context, cl_comma
bool doImageChannelOrder = false;
bool doImageDim = false;
bool doNumSamples = false;
bool doMSAA = false;
switch(target) {
case GL_TEXTURE_2D:
imageType = "image2d_depth_t";
@@ -206,6 +210,7 @@ int test_image_format_methods( cl_device_id device, cl_context context, cl_comma
break;
case GL_TEXTURE_2D_MULTISAMPLE:
doNumSamples = true;
doMSAA = true;
if(format.formattype == GL_DEPTH_COMPONENT) {
doImageWidth = true;
imageType = "image2d_msaa_depth_t";
@@ -214,6 +219,7 @@ int test_image_format_methods( cl_device_id device, cl_context context, cl_comma
}
break;
case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
doMSAA = true;
if(format.formattype == GL_DEPTH_COMPONENT) {
doImageWidth = true;
imageType = "image2d_msaa_array_depth_t";
@@ -244,9 +250,11 @@ int test_image_format_methods( cl_device_id device, cl_context context, cl_comma
}
}
// Create a program to run against
sprintf( programSrc, methodTestKernelPattern,
imageType,
// Create a program to run against
sprintf(programSrc,
methodTestKernelPattern,
( doMSAA ) ? enableMSAAKernelLine : "",
imageType,
( doArraySize ) ? arraySizeKernelLine : "",
( doImageWidth ) ? imageWidthKernelLine : "",
( doImageHeight ) ? imageHeightKernelLine : "",

4
test_conformance/gl/test_images_read_common.cpp
View File

@@ -107,6 +107,7 @@ static const char *kernelpattern_image_read_2darray_depth =
"}\n";
static const char *kernelpattern_image_multisample_read_2d =
"#pragma OPENCL EXTENSION cl_khr_gl_msaa_sharing : enable\n"
"__kernel void sample_test( read_only image2d_msaa_t source, sampler_t sampler, __global %s4 *results )\n"
"{\n"
" int tidX = get_global_id(0);\n"
@@ -121,6 +122,7 @@ static const char *kernelpattern_image_multisample_read_2d =
"}\n";
static const char *kernelpattern_image_multisample_read_2d_depth =
"#pragma OPENCL EXTENSION cl_khr_gl_msaa_sharing : enable\n"
"__kernel void sample_test( read_only image2d_msaa_depth_t source, sampler_t sampler, __global %s *results )\n"
"{\n"
" int tidX = get_global_id(0);\n"
@@ -135,6 +137,7 @@ static const char *kernelpattern_image_multisample_read_2d_depth =
"}\n";
static const char *kernelpattern_image_multisample_read_2darray =
"#pragma OPENCL EXTENSION cl_khr_gl_msaa_sharing : enable\n"
"__kernel void sample_test( read_only image2d_array_msaa_t source, sampler_t sampler, __global %s4 *results )\n"
"{\n"
" int tidX = get_global_id(0);\n"
@@ -151,6 +154,7 @@ static const char *kernelpattern_image_multisample_read_2darray =
"}\n";
static const char *kernelpattern_image_multisample_read_2darray_depth =
"#pragma OPENCL EXTENSION cl_khr_gl_msaa_sharing : enable\n"
"__kernel void sample_test( read_only image2d_array_msaa_depth_t source, sampler_t sampler, __global %s *results )\n"
"{\n"
" int tidX = get_global_id(0);\n"

4
test_conformance/gl/test_images_write_common.cpp
View File

@@ -333,8 +333,8 @@ int test_cl_image_write( cl_context context, cl_command_queue queue,
get_explicit_type_name( *outType ), suffix, convert);
programPtr = kernelSource;
if( create_single_kernel_helper( context, &program, &kernel, 1,
(const char **)&programPtr, "sample_test" ) )
if( create_single_kernel_helper_with_build_options( context, &program, &kernel, 1,
(const char **)&programPtr, "sample_test", "-cl-std=CL2.0" ) )
{
return -1;
}

18
test_conformance/gles/main.cpp
View File

@@ -101,16 +101,14 @@ const char *basefn_names[] = {
"images_write_cube",
"renderbuffer_read",
"renderbuffer_write",
"renderbuffer_getinfo",
"all"
"renderbuffer_getinfo"
};
const char *basefn_names32[] = {
"fence_sync",
"all"
"fence_sync"
};
ct_assert((sizeof(basefn_names) / sizeof(basefn_names[0]) - 1) == (sizeof(basefn_list) / sizeof(basefn_list[0])));
ct_assert((sizeof(basefn_names) / sizeof(basefn_names[0])) == (sizeof(basefn_list) / sizeof(basefn_list[0])));
int num_fns = sizeof(basefn_names) / sizeof(char *);
int num_fns32 = sizeof(basefn_names32) / sizeof(char *);
@@ -386,17 +384,17 @@ int main(int argc, const char *argv[])
// Intentional falling through
cleanup:
// Cleanup EGL
glEnv->terminate_egl_display();
// Always make sure that OpenCL context is released properly when the test exit
if(sCurrentContext)
{
clReleaseContext( sCurrentContext );
sCurrentContext = NULL;
}
// Cleanup EGL
glEnv->terminate_egl_display();
delete glEnv;
return error;
}
}

2
test_conformance/half/Test_roundTrip.c
View File

@@ -162,7 +162,7 @@ int Test_roundTrip( void )
// Figure out how many elements are in a work block
size_t elementSize = MAX( sizeof(cl_half), sizeof(cl_float));
size_t blockCount = (size_t)getBufferSize(gDevice) / elementSize; //elementSize is a power of two
size_t blockCount = (size_t)gBufferSize / elementSize; //elementSize is a power of two
uint64_t lastCase = 1ULL << (8*sizeof(cl_half)); // number of cl_half
size_t stride = blockCount;

4
test_conformance/half/Test_vLoadHalf.c
View File

@@ -453,7 +453,7 @@ int Test_vLoadHalf_private( bool aligned )
// Figure out how many elements are in a work block
size_t elementSize = MAX( sizeof(cl_half), sizeof(cl_float));
size_t blockCount = getBufferSize(gDevice) / elementSize; // elementSize is power of 2
size_t blockCount = gBufferSize / elementSize; // elementSize is power of 2
uint64_t lastCase = 1ULL << (8*sizeof(cl_half)); // number of things of size cl_half
// we handle 64-bit types a bit differently.
@@ -503,7 +503,7 @@ int Test_vLoadHalf_private( bool aligned )
continue;
}
*/
memset_pattern4( gOut_single, &pattern, getBufferSize(gDevice));
memset_pattern4( gOut_single, &pattern, gBufferSize);
if( (error = clEnqueueWriteBuffer(gQueue, gOutBuffer_single, CL_TRUE, 0, count * sizeof( float ), gOut_single, 0, NULL, NULL)) )
{
vlog_error( "Failure in clWriteArray\n" );

4
test_conformance/half/Test_vStoreHalf.c
View File

@@ -1044,7 +1044,7 @@ int Test_vStoreHalf_private( f2h referenceFunc, d2h doubleReferenceFunc, const c
size_t stride = blockCount;
if (gWimpyMode)
stride = 0x10000000U;
stride = (uint64_t)blockCount * (uint64_t)gWimpyReductionFactor;
// we handle 64-bit types a bit differently.
if( lastCase == 0 )
@@ -1654,7 +1654,7 @@ int Test_vStoreaHalf_private( f2h referenceFunc, d2h doubleReferenceFunc, const
size_t stride = blockCount;
if (gWimpyMode)
stride = 0x10000000U;
stride = (uint64_t)blockCount * (uint64_t)gWimpyReductionFactor;
// we handle 64-bit types a bit differently.
if( lastCase == 0 )

46
test_conformance/half/cl_utils.c
View File

@@ -61,9 +61,11 @@ size_t gWorkGroupSize = 0;
int gTestCount = 0;
int gFailCount = 0;
bool gWimpyMode = false;
int gWimpyReductionFactor = 512;
int gTestDouble = 0;
uint32_t gDeviceIndex = 0;
int gIsEmbedded = 0;
size_t gBufferSize = 0;
#if defined( __APPLE__ )
int gReportTimes = 1;
@@ -184,17 +186,19 @@ int InitCL( void )
#if defined( __APPLE__ )
// FIXME: use clProtectedArray
#endif
gBufferSize = getBufferSize(gDevice);
//Allocate buffers
gIn_half = malloc( getBufferSize(gDevice)/2 );
gIn_half = malloc( gBufferSize/2 );
gOut_half = malloc( BUFFER_SIZE/2 );
gOut_half_reference = malloc( BUFFER_SIZE/2 );
gOut_half_reference_double = malloc( BUFFER_SIZE/2 );
gIn_single = malloc( BUFFER_SIZE );
gOut_single = malloc( getBufferSize(gDevice) );
gOut_single_reference = malloc( getBufferSize(gDevice) );
gOut_single = malloc( gBufferSize );
gOut_single_reference = malloc( gBufferSize );
gIn_double = malloc( 2*BUFFER_SIZE );
// gOut_double = malloc( (2*getBufferSize(gDevice)) );
// gOut_double_reference = malloc( (2*getBufferSize(gDevice)) );
// gOut_double = malloc( (2*gBufferSize) );
// gOut_double_reference = malloc( (2*gBufferSize) );
if ( NULL == gIn_half ||
NULL == gOut_half ||
@@ -207,7 +211,7 @@ int InitCL( void )
)
return -3;
gInBuffer_half = clCreateBuffer(gContext, CL_MEM_READ_ONLY, getBufferSize(gDevice) / 2, NULL, &error);
gInBuffer_half = clCreateBuffer(gContext, CL_MEM_READ_ONLY, gBufferSize / 2, NULL, &error);
if( gInBuffer_half == NULL )
{
vlog_error( "clCreateArray failed for input (%d)\n", error );
@@ -235,7 +239,7 @@ int InitCL( void )
return -5;
}
gOutBuffer_single = clCreateBuffer(gContext, CL_MEM_WRITE_ONLY, getBufferSize(gDevice), NULL, &error );
gOutBuffer_single = clCreateBuffer(gContext, CL_MEM_WRITE_ONLY, gBufferSize, NULL, &error );
if( gOutBuffer_single == NULL )
{
vlog_error( "clCreateArray failed for output (%d)\n", error );
@@ -243,7 +247,7 @@ int InitCL( void )
}
#if 0
gOutBuffer_double = clCreateBuffer(gContext, CL_MEM_WRITE_ONLY, (size_t)(2*getBufferSize(gDevice)), NULL, &error );
gOutBuffer_double = clCreateBuffer(gContext, CL_MEM_WRITE_ONLY, (size_t)(2*gBufferSize), NULL, &error );
if( gOutBuffer_double == NULL )
{
vlog_error( "clCreateArray failed for output (%d)\n", error );
@@ -317,6 +321,15 @@ void ReleaseCL(void)
// clReleaseMemObject(gOutBuffer_double);
clReleaseCommandQueue(gQueue);
clReleaseContext(gContext);
free(gIn_half);
free(gOut_half);
free(gOut_half_reference);
free(gOut_half_reference_double);
free(gIn_single);
free(gOut_single);
free(gOut_single_reference);
free(gIn_double);
}
cl_uint numVecs(cl_uint count, int vectorSizeIdx, bool aligned) {
@@ -453,19 +466,30 @@ size_t getBufferSize(cl_device_id device_id)
if(s_initialized == 0 || s_device_id != device_id)
{
cl_ulong result;
cl_ulong result, maxGlobalSize;
cl_int err = clGetDeviceInfo (device_id,
CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE,
sizeof(result), (void *)&result,
NULL);
if(err)
{
vlog_error("clGetDeviceInfo() failed\n");
vlog_error("clGetDeviceInfo(CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE) failed\n");
s_result = 64*1024;
goto exit;
}
result = result / 2;
log_info("Const buffer size is %llx (%llu)\n", result, result);
err = clGetDeviceInfo (device_id,
CL_DEVICE_GLOBAL_MEM_SIZE,
sizeof(maxGlobalSize), (void *)&maxGlobalSize,
NULL);
if(err)
{
vlog_error("clGetDeviceInfo(CL_DEVICE_GLOBAL_MEM_SIZE) failed\n");
goto exit;
}
result = result / 2;
if(maxGlobalSize < result * 10)
result = result / 10;
s_initialized = 1;
s_device_id = device_id;
s_result = result;

2
test_conformance/half/cl_utils.h
View File

@@ -73,11 +73,13 @@ extern int gFailCount;
extern int gTestDouble;
extern int gReportTimes;
extern int gIsEmbedded;
extern size_t gBufferSize;
// gWimpyMode indicates if we run the test in wimpy mode where we limit the
// size of 32 bit ranges to a much smaller set. This is meant to be used
// as a smoke test
extern bool gWimpyMode;
extern int gWimpyReductionFactor;
uint64_t ReadTime( void );
double SubtractTime( uint64_t endTime, uint64_t startTime );

8
test_conformance/half/main.c
View File

@@ -236,7 +236,9 @@ static int ParseArgs( int argc, const char **argv )
case 'w': // Wimpy mode
gWimpyMode = true;
break;
case '[':
parseWimpyReductionFactor( arg, gWimpyReductionFactor);
break;
default:
vlog_error( " <-- unknown flag: %c (0x%2.2x)\n)", *arg, *arg );
PrintUsage();
@@ -278,6 +280,7 @@ static int ParseArgs( int argc, const char **argv )
vlog( "*** WARNING: Testing in Wimpy mode! ***\n" );
vlog( "*** Wimpy mode is not sufficient to verify correctness. ***\n" );
vlog( "*** It gives warm fuzzy feelings and then nevers calls. ***\n\n" );
vlog( "*** Wimpy Reduction Factor: %-27u ***\n\n", gWimpyReductionFactor);
}
return 0;
}
@@ -288,6 +291,7 @@ static void PrintUsage( void )
vlog( "\t\t-d\tToggle double precision testing (default: on if double supported)\n" );
vlog( "\t\t-t\tToggle reporting performance data.\n" );
vlog( "\t\t-w\tRun in wimpy mode\n" );
vlog( "\t\t-[2^n]\tSet wimpy reduction factor, recommended range of n is 1-12, default factor(%u)\n", gWimpyReductionFactor);
vlog( "\t\t-h\tHelp\n" );
vlog( "\n" );
}
@@ -307,6 +311,8 @@ static void PrintArch( void )
vlog( "ARCH:\tx86_64\n" );
#elif defined( __arm__ )
vlog( "ARCH:\tarm\n" );
#elif defined( __aarch64__ )
vlog( "\tARCH:\taarch64\n" );
#else
#error unknown arch
#endif

9
test_conformance/headers/CMakeLists.txt
View File

@@ -19,6 +19,8 @@ set(CL_H_SOURCES
test_cl.h.c
)
set_source_files_properties(${CL_H_SOURCES} PROPERTIES LANGUAGE CXX)
set(CL_H_OUT ${CONFORMANCE_PREFIX}cl_h${CONFORMANCE_SUFFIX})
add_executable(
@@ -36,6 +38,8 @@ set(CL_PLATFORM_H_SOURCES
test_cl_platform.h.c
)
set_source_files_properties(${CL_PLATFORM_H_SOURCES} PROPERTIES LANGUAGE CXX)
set(CL_PLATFORM_H_OUT ${CONFORMANCE_PREFIX}cl_platform_h${CONFORMANCE_SUFFIX})
add_executable(
@@ -53,6 +57,8 @@ set(CL_GL_H_SOURCES
test_cl_gl.h.c
)
set_source_files_properties(${CL_GL_H_SOURCES} PROPERTIES LANGUAGE CXX)
set(CL_GL_H_OUT ${CONFORMANCE_PREFIX}cl_gl_h${CONFORMANCE_SUFFIX})
add_executable(
@@ -70,6 +76,8 @@ set(OPENCL_H_SOURCES
test_opencl.h.c
)
set_source_files_properties(${OPENCL_H_SOURCES} PROPERTIES LANGUAGE CXX)
set(OPENCL_H_OUT ${CONFORMANCE_PREFIX}opencl_h${CONFORMANCE_SUFFIX})
add_executable(
@@ -83,5 +91,4 @@ TARGET_LINK_LIBRARIES(${OPENCL_H_OUT} ${CLConform_LIBRARIES})
########################################################################################
# end of file #

174
test_conformance/images/clGetInfo/main.cpp
View File

@@ -27,106 +27,123 @@
bool gDebugTrace = false, gTestSmallImages = false, gTestMaxImages = false, gTestRounding = false;
int gTypesToTest = 0;
static bool gTest3DImages = true;
cl_channel_type gChannelTypeToUse = (cl_channel_type)-1;
cl_device_type gDeviceType = CL_DEVICE_TYPE_DEFAULT;
cl_command_queue queue;
cl_context context;
static cl_device_id device;
extern int test_image_set( cl_device_id device, cl_mem_object_type image_type );
static void printUsage( const char *execName );
#define MAX_ALLOWED_STD_DEVIATION_IN_MB 8.0
void printUsage( const char *execName )
int test_1D(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
const char *p = strrchr( execName, '/' );
if( p != NULL )
execName = p + 1;
return test_image_set( device, CL_MEM_OBJECT_IMAGE1D );
}
int test_2D(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE2D );
}
int test_3D(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
if( !gTest3DImages )
{
log_info("3D image is not supported, test not run.\n");
return 0;
}
log_info( "Usage: %s [debug_trace] [1D|2D|3D|1Darray|2Darray] [small_images|max_images] [randomize]\n", execName );
log_info( "Where:\n" );
log_info( "\t1D - Only test 1D images\n" );
log_info( "\t2D - Only test 2D images\n" );
log_info( "\t3D - Only test 3D images\n" );
log_info( "\t1Darray - Only test 1D image arrays\n" );
log_info( "\t2Darray - Only test 2D image arrays\n" );
log_info( "\n" );
log_info( "\tdebug_trace - Enables additional debug info logging (default no debug info)\n" );
log_info( "\n" );
log_info( "\tsmall_images - Runs every format through a loop of widths 1-13 and heights 1-9, instead of random sizes (default test random sizes)\n" );
log_info( "\tmax_images - Runs every format through a set of size combinations with the max values, max values - 1, and max values / 128 (default test random sizes)\n" );
log_info( "\n" );
log_info( "\trandomize - Seed random number generator (default do not seed random number generator)\n" );
return test_image_set( device, CL_MEM_OBJECT_IMAGE3D );
}
int test_1Darray(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE1D_ARRAY );
}
int test_2Darray(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE2D_ARRAY );
}
basefn basefn_list[] = {
test_1D,
test_2D,
test_3D,
test_1Darray,
test_2Darray,
};
const char *basefn_names[] = {
"1D",
"2D",
"3D",
"1Darray",
"2Darray",
};
ct_assert((sizeof(basefn_names) / sizeof(basefn_names[0])) == (sizeof(basefn_list) / sizeof(basefn_list[0])));
int num_fns = sizeof(basefn_names) / sizeof(char *);
int main(int argc, const char *argv[])
{
cl_platform_id platform;
cl_device_id device;
cl_channel_type chanType;
char str[ 128 ];
bool test3DImages = true;
bool randomize = false;
int testMethods = 0;
test_start();
checkDeviceTypeOverride( &gDeviceType );
const char ** argList = (const char **)calloc( argc, sizeof( char*) );
if( NULL == argList )
{
log_error( "Failed to allocate memory for argList array.\n" );
return 1;
}
argList[0] = argv[0];
size_t argCount = 1;
// Parse arguments
for( int i = 1; i < argc; i++ )
{
strncpy( str, argv[ i ], sizeof( str ) - 1 );
if( strcmp( str, "cpu" ) == 0 || strcmp( str, "CL_DEVICE_TYPE_CPU" ) == 0 )
if( strcmp( argv[i], "cpu" ) == 0 || strcmp( argv[i], "CL_DEVICE_TYPE_CPU" ) == 0 )
gDeviceType = CL_DEVICE_TYPE_CPU;
else if( strcmp( str, "gpu" ) == 0 || strcmp( str, "CL_DEVICE_TYPE_GPU" ) == 0 )
else if( strcmp( argv[i], "gpu" ) == 0 || strcmp( argv[i], "CL_DEVICE_TYPE_GPU" ) == 0 )
gDeviceType = CL_DEVICE_TYPE_GPU;
else if( strcmp( str, "accelerator" ) == 0 || strcmp( str, "CL_DEVICE_TYPE_ACCELERATOR" ) == 0 )
else if( strcmp( argv[i], "accelerator" ) == 0 || strcmp( argv[i], "CL_DEVICE_TYPE_ACCELERATOR" ) == 0 )
gDeviceType = CL_DEVICE_TYPE_ACCELERATOR;
else if( strcmp( str, "CL_DEVICE_TYPE_DEFAULT" ) == 0 )
else if( strcmp( argv[i], "CL_DEVICE_TYPE_DEFAULT" ) == 0 )
gDeviceType = CL_DEVICE_TYPE_DEFAULT;
else if( strcmp( str, "debug_trace" ) == 0 )
else if( strcmp( argv[i], "debug_trace" ) == 0 )
gDebugTrace = true;
else if( strcmp( str, "small_images" ) == 0 )
else if( strcmp( argv[i], "small_images" ) == 0 )
gTestSmallImages = true;
else if( strcmp( str, "max_images" ) == 0 )
else if( strcmp( argv[i], "max_images" ) == 0 )
gTestMaxImages = true;
else if( strcmp( str, "randomize" ) == 0 )
else if( strcmp( argv[i], "randomize" ) == 0 )
randomize = true;
else if( strcmp( str, "1D" ) == 0 )
testMethods |= k1D;
else if( strcmp( str, "2D" ) == 0 )
testMethods |= k2D;
else if( strcmp( str, "3D" ) == 0 )
testMethods |= k3D;
else if( strcmp( str, "1Darray" ) == 0 )
testMethods |= k1DArray;
else if( strcmp( str, "2Darray" ) == 0 )
testMethods |= k2DArray;
else if( strcmp( str, "help" ) == 0 || strcmp( str, "?" ) == 0 )
else if( strcmp( argv[i], "--help" ) == 0 || strcmp( argv[i], "-h" ) == 0 )
{
printUsage( argv[ 0 ] );
return -1;
}
else if( ( chanType = get_channel_type_from_name( str ) ) != (cl_channel_type)-1 )
else if( ( chanType = get_channel_type_from_name( argv[i] ) ) != (cl_channel_type)-1 )
gChannelTypeToUse = chanType;
else
{
log_error( "ERROR: Unknown argument %d: %s. Exiting....\n", i, str );
return -1;
else
{
argList[argCount] = argv[i];
argCount++;
}
}
}
if ( testMethods == 0 )
testMethods = k1D | k2D | k3D | k1DArray | k2DArray;
// Seed the random # generators
if( randomize )
{
@@ -225,7 +242,7 @@ int main(int argc, const char *argv[])
return -1;
}
test3DImages = false;
gTest3DImages = false;
}
}
@@ -250,38 +267,47 @@ int main(int argc, const char *argv[])
if( gTestSmallImages )
log_info( "Note: Using small test images\n" );
// Run the test now
int ret = 0;
if (testMethods & k1D)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE1D );
if (testMethods & k2D)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE2D );
if (test3DImages && (testMethods & k3D))
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE3D );
if (testMethods & k1DArray)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE1D_ARRAY );
if (testMethods & k2DArray)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE2D_ARRAY );
int ret = parseAndCallCommandLineTests( argCount, argList, NULL, num_fns, basefn_list, basefn_names, true, 0, 0 );
if (gTestFailure == 0) {
if (gTestCount > 1)
log_info("PASSED %d of %d tests.\n", gTestCount, gTestCount);
log_info("PASSED %d of %d sub-tests.\n", gTestCount, gTestCount);
else
log_info("PASSED test.\n");
log_info("PASSED sub-test.\n");
} else if (gTestFailure > 0) {
if (gTestCount > 1)
log_error("FAILED %d of %d tests.\n", gTestFailure, gTestCount);
log_error("FAILED %d of %d sub-tests.\n", gTestFailure, gTestCount);
else
log_error("FAILED test.\n");
log_error("FAILED sub-test.\n");
}
// Clean up
clReleaseCommandQueue(queue);
clReleaseContext(context);
free(argList);
test_finish();
if (gTestFailure > 0)
return gTestFailure;
return ret;
}
static void printUsage( const char *execName )
{
const char *p = strrchr( execName, '/' );
if( p != NULL )
execName = p + 1;
log_info( "Usage: %s [options] [test_names]\n", execName );
log_info( "Options:\n" );
log_info( "\tdebug_trace - Enables additional debug info logging (default no debug info)\n" );
log_info( "\n" );
log_info( "\tsmall_images - Runs every format through a loop of widths 1-13 and heights 1-9, instead of random sizes (default test random sizes)\n" );
log_info( "\tmax_images - Runs every format through a set of size combinations with the max values, max values - 1, and max values / 128 (default test random sizes)\n" );
log_info( "\n" );
log_info( "\trandomize - Seed random number generator (default do not seed random number generator)\n" );
log_info( "\n" );
log_info( "Test names:\n" );
for( int i = 0; i < num_fns; i++ )
{
log_info( "\t%s\n", basefn_names[i] );
}
}

180
test_conformance/images/clReadWriteImage/main.cpp
View File

@@ -32,108 +32,120 @@ bool gEnablePitch = false;
cl_device_type gDeviceType = CL_DEVICE_TYPE_DEFAULT;
cl_command_queue queue;
cl_context context;
static cl_device_id device;
#define MAX_ALLOWED_STD_DEVIATION_IN_MB 8.0
void printUsage( const char *execName )
{
const char *p = strrchr( execName, '/' );
if( p != NULL )
execName = p + 1;
log_info( "Usage: %s [debug_trace] [small_images]\n", execName );
log_info( "Where:\n" );
log_info( "\t1D - Only test 1D images\n" );
log_info( "\t2D - Only test 2D images\n" );
log_info( "\t3D - Only test 3D images\n" );
log_info( "\t1Darray - Only test 1D image arrays\n" );
log_info( "\t2Darray - Only test 2D image arrays\n" );
log_info( "\n" );
log_info( "\tdebug_trace - Enables additional debug info logging\n" );
log_info( "\tsmall_images - Runs every format through a loop of widths 1-13 and heights 1-9, instead of random sizes\n" );
log_info( "\tmax_images - Runs every format through a set of size combinations with the max values, max values - 1, and max values / 128\n" );
log_info( "\trounding - Runs every format through a single image filled with every possible value for that image format, to verify rounding works properly\n" );
log_info( "\tuse_pitches - Enables row and slice pitches\n" );
log_info( "\tuse_ramp - Instead of random data, uses images filled with ramps (and 0xff on any padding pixels) to ease debugging\n" );
log_info( "\ttest_mipmaps - Test mipmapped images\n" );
}
static void printUsage( const char *execName );
extern int test_image_set( cl_device_id device, cl_mem_object_type image_type );
int test_1D(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE1D );
}
int test_2D(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE2D );
}
int test_3D(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE3D );
}
int test_1Darray(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE1D_ARRAY );
}
int test_2Darray(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE2D_ARRAY );
}
basefn basefn_list[] = {
test_1D,
test_2D,
test_3D,
test_1Darray,
test_2Darray,
};
const char *basefn_names[] = {
"1D",
"2D",
"3D",
"1Darray",
"2Darray",
};
ct_assert((sizeof(basefn_names) / sizeof(basefn_names[0])) == (sizeof(basefn_list) / sizeof(basefn_list[0])));
int num_fns = sizeof(basefn_names) / sizeof(char *);
int main(int argc, const char *argv[])
{
cl_platform_id platform;
cl_device_id device;
cl_channel_type chanType;
char str[ 128 ];
bool randomize = false;
int testMethods = 0;
test_start();
checkDeviceTypeOverride( &gDeviceType );
const char ** argList = (const char **)calloc( argc, sizeof( char*) );
if( NULL == argList )
{
log_error( "Failed to allocate memory for argList array.\n" );
return 1;
}
argList[0] = argv[0];
size_t argCount = 1;
// Parse arguments
for( int i = 1; i < argc; i++ )
{
strncpy( str, argv[ i ], sizeof( str ) - 1 );
if( strcmp( str, "cpu" ) == 0 || strcmp( str, "CL_DEVICE_TYPE_CPU" ) == 0 )
if( strcmp( argv[i], "cpu" ) == 0 || strcmp( argv[i], "CL_DEVICE_TYPE_CPU" ) == 0 )
gDeviceType = CL_DEVICE_TYPE_CPU;
else if( strcmp( str, "gpu" ) == 0 || strcmp( str, "CL_DEVICE_TYPE_GPU" ) == 0 )
else if( strcmp( argv[i], "gpu" ) == 0 || strcmp( argv[i], "CL_DEVICE_TYPE_GPU" ) == 0 )
gDeviceType = CL_DEVICE_TYPE_GPU;
else if( strcmp( str, "accelerator" ) == 0 || strcmp( str, "CL_DEVICE_TYPE_ACCELERATOR" ) == 0 )
else if( strcmp( argv[i], "accelerator" ) == 0 || strcmp( argv[i], "CL_DEVICE_TYPE_ACCELERATOR" ) == 0 )
gDeviceType = CL_DEVICE_TYPE_ACCELERATOR;
else if( strcmp( str, "CL_DEVICE_TYPE_DEFAULT" ) == 0 )
else if( strcmp( argv[i], "CL_DEVICE_TYPE_DEFAULT" ) == 0 )
gDeviceType = CL_DEVICE_TYPE_DEFAULT;
else if( strcmp( str, "debug_trace" ) == 0 )
else if( strcmp( argv[i], "debug_trace" ) == 0 )
gDebugTrace = true;
else if( strcmp( str, "small_images" ) == 0 )
else if( strcmp( argv[i], "small_images" ) == 0 )
gTestSmallImages = true;
else if( strcmp( str, "max_images" ) == 0 )
else if( strcmp( argv[i], "max_images" ) == 0 )
gTestMaxImages = true;
else if( strcmp( str, "use_pitches" ) == 0 )
else if( strcmp( argv[i], "use_pitches" ) == 0 )
gEnablePitch = true;
else if( strcmp( str, "use_ramps" ) == 0 )
else if( strcmp( argv[i], "use_ramps" ) == 0 )
gUseRamp = true;
else if( strcmp(str, "test_mipmaps") == 0 ) {
else if( strcmp( argv[i], "test_mipmaps") == 0 ) {
gTestMipmaps = true;
// Don't test pitches with mipmaps right now.
gEnablePitch = false;
}
else if( strcmp( str, "randomize" ) == 0 )
else if( strcmp( argv[i], "randomize" ) == 0 )
randomize = true;
else if( strcmp( str, "1D" ) == 0 )
testMethods |= k1D;
else if( strcmp( str, "2D" ) == 0 )
testMethods |= k2D;
else if( strcmp( str, "3D" ) == 0 )
testMethods |= k3D;
else if( strcmp( str, "1Darray" ) == 0 )
testMethods |= k1DArray;
else if( strcmp( str, "2Darray" ) == 0 )
testMethods |= k2DArray;
else if( strcmp( str, "help" ) == 0 || strcmp( str, "?" ) == 0 )
else if( strcmp( argv[i], "--help" ) == 0 || strcmp( argv[i], "-h" ) == 0 )
{
printUsage( argv[ 0 ] );
return -1;
}
else if( ( chanType = get_channel_type_from_name( str ) ) != (cl_channel_type)-1 )
else if( ( chanType = get_channel_type_from_name( argv[i] ) ) != (cl_channel_type)-1 )
gChannelTypeToUse = chanType;
else
{
log_error( "ERROR: Unknown argument %d: %s. Exiting....\n", i, str );
return -1;
else
{
argList[argCount] = argv[i];
argCount++;
}
}
}
if (testMethods == 0)
testMethods = k1D | k2D | k3D | k1DArray | k2DArray;
// Seed the random # generators
if( randomize )
@@ -224,18 +236,7 @@ int main(int argc, const char *argv[])
if( gTestSmallImages )
log_info( "Note: Using small test images\n" );
// Run the test now
int ret = 0;
if (testMethods & k1D)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE1D );
if (testMethods & k2D)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE2D );
if (testMethods & k3D)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE3D );
if (testMethods & k1DArray)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE1D_ARRAY );
if (testMethods & k2DArray)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE2D_ARRAY );
int ret = parseAndCallCommandLineTests( argCount, argList, NULL, num_fns, basefn_list, basefn_names, true, 0, 0 );
error = clFinish(queue);
if (error)
@@ -243,23 +244,44 @@ int main(int argc, const char *argv[])
if (gTestFailure == 0) {
if (gTestCount > 1)
log_info("PASSED %d of %d tests.\n", gTestCount, gTestCount);
log_info("PASSED %d of %d sub-tests.\n", gTestCount, gTestCount);
else
log_info("PASSED test.\n");
log_info("PASSED sub-test.\n");
} else if (gTestFailure > 0) {
if (gTestCount > 1)
log_error("FAILED %d of %d tests.\n", gTestFailure, gTestCount);
log_error("FAILED %d of %d sub-tests.\n", gTestFailure, gTestCount);
else
log_error("FAILED test.\n");
log_error("FAILED sub-test.\n");
}
// Clean up
clReleaseCommandQueue(queue);
clReleaseContext(context);
free(argList);
test_finish();
if (gTestFailure > 0)
return gTestFailure;
return ret;
}
static void printUsage( const char *execName )
{
const char *p = strrchr( execName, '/' );
if( p != NULL )
execName = p + 1;
log_info( "Usage: %s [options] [test_names]\n", execName );
log_info( "Options:\n" );
log_info( "\tdebug_trace - Enables additional debug info logging\n" );
log_info( "\tsmall_images - Runs every format through a loop of widths 1-13 and heights 1-9, instead of random sizes\n" );
log_info( "\tmax_images - Runs every format through a set of size combinations with the max values, max values - 1, and max values / 128\n" );
log_info( "\tuse_pitches - Enables row and slice pitches\n" );
log_info( "\tuse_ramp - Instead of random data, uses images filled with ramps (and 0xff on any padding pixels) to ease debugging\n" );
log_info( "\ttest_mipmaps - Test mipmapped images\n" );
log_info( "\trandomize - Uses random seed\n" );
log_info( "\n" );
log_info( "Test names:\n" );
for( int i = 0; i < num_fns; i++ )
{
log_info( "\t%s\n", basefn_names[i] );
}
}

161
test_conformance/images/kernel_image_methods/main.cpp
View File

@@ -30,41 +30,62 @@ bool gDebugTrace = false, gTestSmallImages = false, gTestMaxImages =
int gTypesToTest = 0;
cl_channel_type gChannelTypeToUse = (cl_channel_type)-1;
cl_device_type gDeviceType = CL_DEVICE_TYPE_DEFAULT;
static cl_device_id device;
extern int test_image_set( cl_device_id device, cl_mem_object_type imageType );
static void printUsage( const char *execName );
#define MAX_ALLOWED_STD_DEVIATION_IN_MB 8.0
clCommandQueueWrapper queue;
clContextWrapper context;
void printUsage( const char *execName )
int test_1D(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
const char *p = strrchr( execName, '/' );
if( p != NULL )
execName = p + 1;
log_info( "Usage: %s [debug_trace] [small_images]\n", execName );
log_info( "Where:\n" );
log_info( "\t1D - Only test 1D images\n" );
log_info( "\t2D - Only test 2D images\n" );
log_info( "\t3D - Only test 3D images\n" );
log_info( "\t1Darray - Only test 1D image arrays\n" );
log_info( "\t2Darray - Only test 2D image arrays\n" );
log_info( "\n" );
log_info( "\tdebug_trace - Enables additional debug info logging\n" );
log_info( "\tsmall_images - Runs every format through a loop of widths 1-13 and heights 1-9, instead of random sizes\n" );
log_info( "\tmax_images - Runs every format through a set of size combinations with the max values, max values - 1, and max values / 128\n" );
return test_image_set( device, CL_MEM_OBJECT_IMAGE1D );
}
int test_2D(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE2D );
}
int test_3D(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE3D );
}
int test_1Darray(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE1D_ARRAY );
}
int test_2Darray(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE2D_ARRAY );
}
basefn basefn_list[] = {
test_1D,
test_2D,
test_3D,
test_1Darray,
test_2Darray,
};
const char *basefn_names[] = {
"1D",
"2D",
"3D",
"1Darray",
"2Darray",
};
ct_assert((sizeof(basefn_names) / sizeof(basefn_names[0])) == (sizeof(basefn_list) / sizeof(basefn_list[0])));
int num_fns = sizeof(basefn_names) / sizeof(char *);
int main(int argc, const char *argv[])
{
cl_platform_id platform;
cl_device_id device;
cl_channel_type chanType;
char str[ 128 ];
int testMethods = 0;
bool randomize = false;
test_start();
@@ -78,58 +99,53 @@ int main(int argc, const char *argv[])
checkDeviceTypeOverride( &gDeviceType );
const char ** argList = (const char **)calloc( argc, sizeof( char*) );
if( NULL == argList )
{
log_error( "Failed to allocate memory for argList array.\n" );
return 1;
}
argList[0] = argv[0];
size_t argCount = 1;
// Parse arguments
for( int i = 1; i < argc; i++ )
{
strncpy( str, argv[ i ], sizeof( str ) - 1 );
if( strcmp( str, "cpu" ) == 0 || strcmp( str, "CL_DEVICE_TYPE_CPU" ) == 0 )
if( strcmp( argv[i], "cpu" ) == 0 || strcmp( argv[i], "CL_DEVICE_TYPE_CPU" ) == 0 )
gDeviceType = CL_DEVICE_TYPE_CPU;
else if( strcmp( str, "gpu" ) == 0 || strcmp( str, "CL_DEVICE_TYPE_GPU" ) == 0 )
else if( strcmp( argv[i], "gpu" ) == 0 || strcmp( argv[i], "CL_DEVICE_TYPE_GPU" ) == 0 )
gDeviceType = CL_DEVICE_TYPE_GPU;
else if( strcmp( str, "accelerator" ) == 0 || strcmp( str, "CL_DEVICE_TYPE_ACCELERATOR" ) == 0 )
else if( strcmp( argv[i], "accelerator" ) == 0 || strcmp( argv[i], "CL_DEVICE_TYPE_ACCELERATOR" ) == 0 )
gDeviceType = CL_DEVICE_TYPE_ACCELERATOR;
else if( strcmp( str, "CL_DEVICE_TYPE_DEFAULT" ) == 0 )
else if( strcmp( argv[i], "CL_DEVICE_TYPE_DEFAULT" ) == 0 )
gDeviceType = CL_DEVICE_TYPE_DEFAULT;
else if( strcmp( str, "debug_trace" ) == 0 )
else if( strcmp( argv[i], "debug_trace" ) == 0 )
gDebugTrace = true;
else if( strcmp( str, "small_images" ) == 0 )
else if( strcmp( argv[i], "small_images" ) == 0 )
gTestSmallImages = true;
else if( strcmp( str, "max_images" ) == 0 )
else if( strcmp( argv[i], "max_images" ) == 0 )
gTestMaxImages = true;
else if( strcmp( str, "randomize" ) == 0 )
else if( strcmp( argv[i], "randomize" ) == 0 )
randomize = true;
else if ( strcmp( str, "1D" ) == 0 )
testMethods |= k1D;
else if( strcmp( str, "2D" ) == 0 )
testMethods |= k2D;
else if( strcmp( str, "3D" ) == 0 )
testMethods |= k3D;
else if( strcmp( str, "1Darray" ) == 0 )
testMethods |= k1DArray;
else if( strcmp( str, "2Darray" ) == 0 )
testMethods |= k2DArray;
else if( strcmp( str, "help" ) == 0 || strcmp( str, "?" ) == 0 )
else if( strcmp( argv[i], "--help" ) == 0 || strcmp( argv[i], "-h" ) == 0 )
{
printUsage( argv[ 0 ] );
return -1;
}
else if( ( chanType = get_channel_type_from_name( str ) ) != (cl_channel_type)-1 )
else if( ( chanType = get_channel_type_from_name( argv[i] ) ) != (cl_channel_type)-1 )
gChannelTypeToUse = chanType;
else
{
log_error( "ERROR: Unknown argument %d: %s. Exiting....\n", i, str );
return -1;
else
{
argList[argCount] = argv[i];
argCount++;
}
}
}
if (testMethods == 0)
testMethods = k1D | k2D | k3D | k1DArray | k2DArray;
// Seed the random # generators
if( randomize )
@@ -223,18 +239,7 @@ int main(int argc, const char *argv[])
if( gTestSmallImages )
log_info( "Note: Using small test images\n" );
// Run the test now
int ret = 0;
if (testMethods & k1D)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE1D );
if (testMethods & k2D)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE2D );
if (testMethods & k3D)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE3D );
if (testMethods & k1DArray)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE1D_ARRAY );
if (testMethods & k2DArray)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE2D_ARRAY );
int ret = parseAndCallCommandLineTests( argCount, argList, NULL, num_fns, basefn_list, basefn_names, true, 0, 0 );
// Clean up
error = clFinish(queue);
@@ -243,20 +248,38 @@ int main(int argc, const char *argv[])
if (gTestFailure == 0) {
if (gTestCount > 1)
log_info("PASSED %d of %d tests.\n", gTestCount, gTestCount);
log_info("PASSED %d of %d sub-tests.\n", gTestCount, gTestCount);
else
log_info("PASSED test.\n");
log_info("PASSED sub-test.\n");
} else if (gTestFailure > 0) {
if (gTestCount > 1)
log_error("FAILED %d of %d tests.\n", gTestFailure, gTestCount);
log_error("FAILED %d of %d sub-tests.\n", gTestFailure, gTestCount);
else
log_error("FAILED test.\n");
log_error("FAILED sub-test.\n");
}
free(argList);
test_finish();
if (gTestFailure > 0)
return gTestFailure;
return ret;
}
static void printUsage( const char *execName )
{
const char *p = strrchr( execName, '/' );
if( p != NULL )
execName = p + 1;
log_info( "Usage: %s [options] [test_names]\n", execName );
log_info( "Options:\n" );
log_info( "\tdebug_trace - Enables additional debug info logging\n" );
log_info( "\tsmall_images - Runs every format through a loop of widths 1-13 and heights 1-9, instead of random sizes\n" );
log_info( "\tmax_images - Runs every format through a set of size combinations with the max values, max values - 1, and max values / 128\n" );
log_info( "\trandomize - Uses random seed\n" );
log_info( "\n" );
log_info( "Test names:\n" );
for( int i = 0; i < num_fns; i++ )
{
log_info( "\t%s\n", basefn_names[i] );
}
}

198
test_conformance/images/samplerlessReads/main.cpp
View File

@@ -45,51 +45,61 @@ cl_device_type gDeviceType = CL_DEVICE_TYPE_DEFAULT;
cl_command_queue queue;
cl_context context;
static cl_device_id device;
#define MAX_ALLOWED_STD_DEVIATION_IN_MB 8.0
void printUsage( const char *execName )
{
const char *p = strrchr( execName, '/' );
if ( p != NULL )
execName = p + 1;
log_info( "Usage: %s [options]\n", execName );
log_info( "Where:\n" );
log_info( "\n" );
log_info( "\tThe following flags specify the types to test. They can be combined; if none are specified, all are tested:\n" );
log_info( "\t\tint - Test integer I/O (read_imagei)\n" );
log_info( "\t\tuint - Test unsigned integer I/O (read_imageui)\n" );
log_info( "\t\tfloat - Test float I/O (read_imagef)\n" );
log_info( "\n" );
log_info( "You may also use appropriate CL_ channel type and ordering constants.\n" );
log_info( "\n" );
log_info( "\t1D - Only test 1D images\n" );
log_info( "\t2D - Only test 2D images\n" );
log_info( "\t3D - Only test 3D images\n" );
log_info( "\t1Darray - Only test 1D image arrays\n" );
log_info( "\t2Darray - Only test 2D image arrays\n" );
log_info( "\n" );
log_info( "\tThe following modify the types of images tested:\n" );
log_info( "\t\read_write - Runs the tests with read_write images which allow a kernel do both read and write to the same image \n" );
log_info( "\t\tsmall_images - Runs every format through a loop of widths 1-13 and heights 1-9, instead of random sizes\n" );
log_info( "\t\tmax_images - Runs every format through a set of size combinations with the max values, max values - 1, and max values / 128\n" );
log_info( "\n" );
log_info( "\tdebug_trace - Enables additional debug info logging\n" );
log_info( "\tuse_pitches - Enables row and slice pitches\n" );
}
static void printUsage( const char *execName );
extern int test_image_set( cl_device_id device, cl_mem_object_type imageType );
int test_1D(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE1D ) +
test_image_set( device, CL_MEM_OBJECT_IMAGE1D_BUFFER );
}
int test_2D(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE2D );
}
int test_3D(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE3D );
}
int test_1Darray(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE1D_ARRAY );
}
int test_2Darray(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
{
return test_image_set( device, CL_MEM_OBJECT_IMAGE2D_ARRAY );
}
basefn basefn_list[] = {
test_1D,
test_2D,
test_3D,
test_1Darray,
test_2Darray,
};
const char *basefn_names[] = {
"1D",
"2D",
"3D",
"1Darray",
"2Darray",
};
ct_assert((sizeof(basefn_names) / sizeof(basefn_names[0])) == (sizeof(basefn_list) / sizeof(basefn_list[0])));
int num_fns = sizeof(basefn_names) / sizeof(char *);
int main(int argc, const char *argv[])
{
cl_platform_id platform;
cl_device_id device;
cl_channel_type chanType;
cl_channel_order chanOrder;
char str[ 128 ];
int testMethods = 0;
bool randomize = false;
test_start();
@@ -104,72 +114,68 @@ int main(int argc, const char *argv[])
//Check CL_DEVICE_TYPE environment variable
checkDeviceTypeOverride( &gDeviceType );
const char ** argList = (const char **)calloc( argc, sizeof( char*) );
if( NULL == argList )
{
log_error( "Failed to allocate memory for argList array.\n" );
return 1;
}
argList[0] = argv[0];
size_t argCount = 1;
// Parse arguments
for ( int i = 1; i < argc; i++ )
{
strncpy( str, argv[ i ], sizeof( str ) - 1 );
if ( strcmp( str, "cpu" ) == 0 || strcmp( str, "CL_DEVICE_TYPE_CPU" ) == 0 )
if ( strcmp( argv[i], "cpu" ) == 0 || strcmp( argv[i], "CL_DEVICE_TYPE_CPU" ) == 0 )
gDeviceType = CL_DEVICE_TYPE_CPU;
else if ( strcmp( str, "gpu" ) == 0 || strcmp( str, "CL_DEVICE_TYPE_GPU" ) == 0 )
else if ( strcmp( argv[i], "gpu" ) == 0 || strcmp( argv[i], "CL_DEVICE_TYPE_GPU" ) == 0 )
gDeviceType = CL_DEVICE_TYPE_GPU;
else if ( strcmp( str, "accelerator" ) == 0 || strcmp( str, "CL_DEVICE_TYPE_ACCELERATOR" ) == 0 )
else if ( strcmp( argv[i], "accelerator" ) == 0 || strcmp( argv[i], "CL_DEVICE_TYPE_ACCELERATOR" ) == 0 )
gDeviceType = CL_DEVICE_TYPE_ACCELERATOR;
else if ( strcmp( str, "CL_DEVICE_TYPE_DEFAULT" ) == 0 )
else if ( strcmp( argv[i], "CL_DEVICE_TYPE_DEFAULT" ) == 0 )
gDeviceType = CL_DEVICE_TYPE_DEFAULT;
else if ( strcmp( str, "debug_trace" ) == 0 )
else if ( strcmp( argv[i], "debug_trace" ) == 0 )
gDebugTrace = true;
else if ( strcmp( str, "read_write" ) == 0 )
else if ( strcmp( argv[i], "read_write" ) == 0 )
gTestReadWrite = true;
else if ( strcmp( str, "small_images" ) == 0 )
else if ( strcmp( argv[i], "small_images" ) == 0 )
gTestSmallImages = true;
else if ( strcmp( str, "max_images" ) == 0 )
else if ( strcmp( argv[i], "max_images" ) == 0 )
gTestMaxImages = true;
else if ( strcmp( str, "use_pitches" ) == 0 )
else if ( strcmp( argv[i], "use_pitches" ) == 0 )
gEnablePitch = true;
else if ( strcmp( str, "int" ) == 0 )
else if ( strcmp( argv[i], "int" ) == 0 )
gTypesToTest |= kTestInt;
else if ( strcmp( str, "uint" ) == 0 )
else if ( strcmp( argv[i], "uint" ) == 0 )
gTypesToTest |= kTestUInt;
else if ( strcmp( str, "float" ) == 0 )
else if ( strcmp( argv[i], "float" ) == 0 )
gTypesToTest |= kTestFloat;
else if ( strcmp( str, "randomize" ) == 0 )
else if ( strcmp( argv[i], "randomize" ) == 0 )
randomize = true;
else if ( strcmp( str, "1D" ) == 0 )
testMethods |= k1D;
else if( strcmp( str, "2D" ) == 0 )
testMethods |= k2D;
else if( strcmp( str, "3D" ) == 0 )
testMethods |= k3D;
else if( strcmp( str, "1Darray" ) == 0 )
testMethods |= k1DArray;
else if( strcmp( str, "2Darray" ) == 0 )
testMethods |= k2DArray;
else if ( strcmp( str, "help" ) == 0 || strcmp( str, "?" ) == 0 )
else if ( strcmp( argv[i], "--help" ) == 0 || strcmp( argv[i], "-h" ) == 0 )
{
printUsage( argv[ 0 ] );
return -1;
}
else if ( ( chanType = get_channel_type_from_name( str ) ) != (cl_channel_type)-1 )
else if ( ( chanType = get_channel_type_from_name( argv[i] ) ) != (cl_channel_type)-1 )
gChannelTypeToUse = chanType;
else if ( ( chanOrder = get_channel_order_from_name( str ) ) != (cl_channel_order)-1 )
else if ( ( chanOrder = get_channel_order_from_name( argv[i] ) ) != (cl_channel_order)-1 )
gChannelOrderToUse = chanOrder;
else
{
log_error( "ERROR: Unknown argument %d: %s. Exiting....\n", i, str );
return -1;
argList[argCount] = argv[i];
argCount++;
}
}
if (testMethods == 0)
testMethods = k1D | k2D | k3D | k1DArray | k2DArray;
if ( gTypesToTest == 0 )
gTypesToTest = kTestAllTypes;
@@ -255,20 +261,7 @@ int main(int argc, const char *argv[])
FPU_mode_type oldMode;
DisableFTZ(&oldMode);
// Run the test now
int ret = 0;
if (testMethods & k1D) {
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE1D );
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE1D_BUFFER );
}
if (testMethods & k2D)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE2D );
if (testMethods & k3D)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE3D );
if (testMethods & k1DArray)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE1D_ARRAY );
if (testMethods & k2DArray)
ret += test_image_set( device, CL_MEM_OBJECT_IMAGE2D_ARRAY );
int ret = parseAndCallCommandLineTests( argCount, argList, NULL, num_fns, basefn_list, basefn_names, true, 0, 0 );
// Restore FP state before leaving
RestoreFPState(&oldMode);
@@ -282,22 +275,51 @@ int main(int argc, const char *argv[])
if (gTestFailure == 0) {
if (gTestCount > 1)
log_info("PASSED %d of %d tests.\n", gTestCount, gTestCount);
log_info("PASSED %d of %d sub-tests.\n", gTestCount, gTestCount);
else
log_info("PASSED test.\n");
log_info("PASSED sub-test.\n");
}
else if (gTestFailure > 0) {
if (gTestCount > 1)
log_error("FAILED %d of %d tests.\n", gTestFailure, gTestCount);
log_error("FAILED %d of %d sub-tests.\n", gTestFailure, gTestCount);
else
log_error("FAILED test.\n");
log_error("FAILED sub-test.\n");
}
// Clean up
free(argList);
test_finish();
if (gTestFailure > 0)
return gTestFailure;
return ret;
}
static void printUsage( const char *execName )
{
const char *p = strrchr( execName, '/' );
if ( p != NULL )
execName = p + 1;
log_info( "Usage: %s [options] [test_names]\n", execName );
log_info( "Options:\n" );
log_info( "\n" );
log_info( "\tThe following flags specify the types to test. They can be combined; if none are specified, all are tested:\n" );
log_info( "\t\tint - Test integer I/O (read_imagei)\n" );
log_info( "\t\tuint - Test unsigned integer I/O (read_imageui)\n" );
log_info( "\t\tfloat - Test float I/O (read_imagef)\n" );
log_info( "\n" );
log_info( "You may also use appropriate CL_ channel type and ordering constants.\n" );
log_info( "\n" );
log_info( "\tThe following modify the types of images tested:\n" );
log_info( "\t\read_write - Runs the tests with read_write images which allow a kernel do both read and write to the same image \n" );
log_info( "\t\tsmall_images - Runs every format through a loop of widths 1-13 and heights 1-9, instead of random sizes\n" );
log_info( "\t\tmax_images - Runs every format through a set of size combinations with the max values, max values - 1, and max values / 128\n" );
log_info( "\n" );
log_info( "\tdebug_trace - Enables additional debug info logging\n" );
log_info( "\tuse_pitches - Enables row and slice pitches\n" );
log_info( "\n" );
log_info( "Test names:\n" );
for( int i = 0; i < num_fns; i++ )
{
log_info( "\t%s\n", basefn_names[i] );
}
}

25
test_conformance/math_brute_force/binary.c
View File

@@ -233,6 +233,7 @@ typedef struct TestInfo
cl_kernel *k[VECTOR_SIZE_COUNT ]; // arrays of thread-specific kernels for each worker thread: k[vector_size][thread_id]
ThreadInfo *tinfo; // An array of thread specific information for each worker thread
cl_uint threadCount; // Number of worker threads
cl_uint jobCount; // Number of jobs
cl_uint step; // step between each chunk and the next.
cl_uint scale; // stride between individual test values
float ulps; // max_allowed ulps
@@ -268,6 +269,16 @@ int TestFunc_Float_Float_Float_common(const Func *f, MTdata d, int isNextafter)
test_info.scale = (cl_uint) sizeof(cl_float) * 2 * gWimpyReductionFactor;
}
test_info.step = (cl_uint) test_info.subBufferSize * test_info.scale;
if (test_info.step / test_info.subBufferSize != test_info.scale)
{
//there was overflow
test_info.jobCount = 1;
}
else
{
test_info.jobCount = (cl_uint)((1ULL << 32) / test_info.step);
}
test_info.f = f;
test_info.ulps = gIsEmbedded ? f->float_embedded_ulps : f->float_ulps;
test_info.ftz = f->ftz || gForceFTZ || 0 == (CL_FP_DENORM & gFloatCapabilities);
@@ -341,7 +352,7 @@ int TestFunc_Float_Float_Float_common(const Func *f, MTdata d, int isNextafter)
// Run the kernels
if( !gSkipCorrectnessTesting )
{
error = ThreadPool_Do( TestFloat, (cl_uint) ((1ULL<<32) / test_info.step), &test_info );
error = ThreadPool_Do( TestFloat, test_info.jobCount, &test_info );
// Accumulate the arithmetic errors
for( i = 0; i < test_info.threadCount; i++ )
@@ -991,6 +1002,16 @@ int TestFunc_Double_Double_Double_common(const Func *f, MTdata d, int isNextafte
test_info.scale = (cl_uint) sizeof(cl_double) * 2 * gWimpyReductionFactor;
}
test_info.step = (cl_uint) test_info.subBufferSize * test_info.scale;
if (test_info.step / test_info.subBufferSize != test_info.scale)
{
//there was overflow
test_info.jobCount = 1;
}
else
{
test_info.jobCount = (cl_uint)((1ULL << 32) / test_info.step);
}
test_info.f = f;
test_info.ulps = f->double_ulps;
test_info.ftz = f->ftz || gForceFTZ;
@@ -1063,7 +1084,7 @@ int TestFunc_Double_Double_Double_common(const Func *f, MTdata d, int isNextafte
if( !gSkipCorrectnessTesting )
{
error = ThreadPool_Do( TestDouble, (cl_uint) ((1ULL<<32) / test_info.step), &test_info );
error = ThreadPool_Do( TestDouble, test_info.jobCount, &test_info );
// Accumulate the arithmetic errors
for( i = 0; i < test_info.threadCount; i++ )

97
test_conformance/math_brute_force/binaryOperator.c
View File

@@ -207,6 +207,7 @@ typedef struct TestInfo
cl_kernel *k[VECTOR_SIZE_COUNT ]; // arrays of thread-specific kernels for each worker thread: k[vector_size][thread_id]
ThreadInfo *tinfo; // An array of thread specific information for each worker thread
cl_uint threadCount; // Number of worker threads
cl_uint jobCount; // Number of jobs
cl_uint step; // step between each chunk and the next.
cl_uint scale; // stride between individual test values
float ulps; // max_allowed ulps
@@ -260,6 +261,16 @@ int TestFunc_Float_Float_Float_Operator(const Func *f, MTdata d)
}
test_info.step = test_info.subBufferSize * test_info.scale;
if (test_info.step / test_info.subBufferSize != test_info.scale)
{
//there was overflow
test_info.jobCount = 1;
}
else
{
test_info.jobCount = (cl_uint)((1ULL << 32) / test_info.step);
}
test_info.f = f;
test_info.ulps = gIsEmbedded ? f->float_embedded_ulps : f->float_ulps;
test_info.ftz = f->ftz || gForceFTZ || 0 == (CL_FP_DENORM & gFloatCapabilities);
@@ -329,7 +340,7 @@ int TestFunc_Float_Float_Float_Operator(const Func *f, MTdata d)
if( !gSkipCorrectnessTesting )
{
error = ThreadPool_Do( TestFloat, (cl_uint) ((1ULL<<32) / test_info.step), &test_info );
error = ThreadPool_Do( TestFloat, test_info.jobCount, &test_info );
// Accumulate the arithmetic errors
for( i = 0; i < test_info.threadCount; i++ )
@@ -501,63 +512,51 @@ static cl_int TestFloat( cl_uint job_id, cl_uint thread_id, void *data )
int totalSpecialValueCount = specialValuesFloatCount * specialValuesFloatCount;
int indx = (totalSpecialValueCount - 1) / buffer_elements;
if( job_id <= (cl_uint)indx )
{ // test edge cases
float *fp = (float *)p;
float *fp2 = (float *)p2;
if( job_id <= (cl_uint)indx ) {
// Insert special values
uint32_t x, y;
x = (job_id * buffer_elements) % specialValuesFloatCount;
y = (job_id * buffer_elements) / specialValuesFloatCount;
x = (job_id * buffer_elements) % specialValuesFloatCount;
y = (job_id * buffer_elements) / specialValuesFloatCount;
for( ; j < buffer_elements; j++ )
{
fp[j] = specialValuesFloat[x];
fp2[j] = specialValuesFloat[y];
if( ++x >= specialValuesFloatCount )
{
for( ; j < buffer_elements; j++ ) {
p[j] = ((cl_uint *)specialValuesFloat)[x];
p2[j] = ((cl_uint *)specialValuesFloat)[y];
++x;
if (x >= specialValuesFloatCount) {
x = 0;
y++;
if( y >= specialValuesFloatCount )
if (y >= specialValuesFloatCount)
break;
}
if(gTestFastRelaxed && strcmp(name,"divide") == 0 )
{
float fpj = *(float*)&fp[j];
float fpj2 = *(float*)&fp2[j];
if(fabs(fpj) > 0x5E800000 ) //[2^-62,2^62]
{
fp[j] = NAN;
}
if( fabs(fpj2) > 0x5E800000 ) //[2^-62,2^62]
{
fp2[j] = NAN;
}
if (gTestFastRelaxed && strcmp(name,"divide") == 0) {
cl_uint pj = p[j] & 0x7fffffff;
cl_uint p2j = p2[j] & 0x7fffffff;
// Replace values outside [2^-62, 2^62] with QNaN
if (pj < 0x20800000 || pj > 0x5e800000)
p[j] = 0x7fc00000;
if (p2j < 0x20800000 || p2j > 0x5e800000)
p2[j] = 0x7fc00000;
}
}
}
}
//Init any remaining values.
// Init any remaining values.
for( ; j < buffer_elements; j++ )
{
p[j] = genrand_int32(d);
p2[j] = genrand_int32(d);
if(gTestFastRelaxed)
{
if( strcmp(name,"divide")==0){
float pj = *(float*)&p[j];
float pj2 = *(float*)&p2[j];
if(fabs(pj) > 0x5E800000 ) //[2^-62,2^62]
{
p[j] = NAN;
}
if( fabs(pj2) > 0x5E800000 ) //[2^-62,2^62]
{
p2[j] = NAN;
}
}
}
if (gTestFastRelaxed && strcmp(name,"divide") == 0) {
cl_uint pj = p[j] & 0x7fffffff;
cl_uint p2j = p2[j] & 0x7fffffff;
// Replace values outside [2^-62, 2^62] with QNaN
if (pj < 0x20800000 || pj > 0x5e800000)
p[j] = 0x7fc00000;
if (p2j < 0x20800000 || p2j > 0x5e800000)
p2[j] = 0x7fc00000;
}
}
if( (error = clEnqueueWriteBuffer( tinfo->tQueue, tinfo->inBuf, CL_FALSE, 0, buffer_size, p, 0, NULL, NULL) ))
@@ -950,6 +949,16 @@ int TestFunc_Double_Double_Double_Operator(const Func *f, MTdata d)
}
test_info.step = (cl_uint) test_info.subBufferSize * test_info.scale;
if (test_info.step / test_info.subBufferSize != test_info.scale)
{
//there was overflow
test_info.jobCount = 1;
}
else
{
test_info.jobCount = (cl_uint)((1ULL << 32) / test_info.step);
}
test_info.f = f;
test_info.ulps = f->double_ulps;
test_info.ftz = f->ftz || gForceFTZ;
@@ -1020,7 +1029,7 @@ int TestFunc_Double_Double_Double_Operator(const Func *f, MTdata d)
if( !gSkipCorrectnessTesting )
{
error = ThreadPool_Do( TestDouble, (cl_uint) ((1ULL<<32) / test_info.step), &test_info );
error = ThreadPool_Do( TestDouble, test_info.jobCount, &test_info );
// Accumulate the arithmetic errors
for( i = 0; i < test_info.threadCount; i++ )

25
test_conformance/math_brute_force/binary_i.c
View File

@@ -230,6 +230,7 @@ typedef struct TestInfo
cl_kernel *k[VECTOR_SIZE_COUNT ]; // arrays of thread-specific kernels for each worker thread: k[vector_size][thread_id]
ThreadInfo *tinfo; // An array of thread specific information for each worker thread
cl_uint threadCount; // Number of worker threads
cl_uint jobCount; // Number of jobs
cl_uint step; // step between each chunk and the next.
cl_uint scale; // stride between individual test values
float ulps; // max_allowed ulps
@@ -262,6 +263,16 @@ int TestFunc_Float_Float_Int(const Func *f, MTdata d)
test_info.scale = (cl_uint) sizeof(cl_float) * 2 * gWimpyReductionFactor;
}
test_info.step = (cl_uint) test_info.subBufferSize * test_info.scale;
if (test_info.step / test_info.subBufferSize != test_info.scale)
{
//there was overflow
test_info.jobCount = 1;
}
else
{
test_info.jobCount = (cl_uint)((1ULL << 32) / test_info.step);
}
test_info.f = f;
test_info.ulps = gIsEmbedded ? f->float_embedded_ulps : f->float_ulps;
test_info.ftz = f->ftz || gForceFTZ || 0 == (CL_FP_DENORM & gFloatCapabilities);
@@ -330,7 +341,7 @@ int TestFunc_Float_Float_Int(const Func *f, MTdata d)
}
// Run the kernels
error = ThreadPool_Do( TestFloat, (cl_uint) ((1ULL<<32) / test_info.step), &test_info );
error = ThreadPool_Do( TestFloat, test_info.jobCount, &test_info );
// Accumulate the arithmetic errors
@@ -758,6 +769,16 @@ int TestFunc_Double_Double_Int(const Func *f, MTdata d)
test_info.scale = (cl_uint) sizeof(cl_double) * 2 * gWimpyReductionFactor;
}
test_info.step = (cl_uint) test_info.subBufferSize * test_info.scale;
if (test_info.step / test_info.subBufferSize != test_info.scale)
{
//there was overflow
test_info.jobCount = 1;
}
else
{
test_info.jobCount = (cl_uint)((1ULL << 32) / test_info.step);
}
test_info.f = f;
test_info.ulps = f->double_ulps;
test_info.ftz = f->ftz || gForceFTZ;
@@ -831,7 +852,7 @@ int TestFunc_Double_Double_Int(const Func *f, MTdata d)
// Run the kernels
if( !gSkipCorrectnessTesting )
error = ThreadPool_Do( TestDouble, (cl_uint) ((1ULL<<32) / test_info.step), &test_info );
error = ThreadPool_Do( TestDouble, test_info.jobCount, &test_info );
// Accumulate the arithmetic errors

25
test_conformance/math_brute_force/macro_binary.c
View File

@@ -222,6 +222,7 @@ typedef struct TestInfo
cl_kernel *k[VECTOR_SIZE_COUNT ]; // arrays of thread-specific kernels for each worker thread: k[vector_size][thread_id]
ThreadInfo *tinfo; // An array of thread specific information for each worker thread
cl_uint threadCount; // Number of worker threads
cl_uint jobCount; // Number of jobs
cl_uint step; // step between each chunk and the next.
cl_uint scale; // stride between individual test values
int ftz; // non-zero if running in flush to zero mode
@@ -249,6 +250,16 @@ int TestMacro_Int_Float_Float(const Func *f, MTdata d)
test_info.scale = (cl_uint) sizeof(cl_float) * 2 * gWimpyReductionFactor;
}
test_info.step = (cl_uint) test_info.subBufferSize * test_info.scale;
if (test_info.step / test_info.subBufferSize != test_info.scale)
{
//there was overflow
test_info.jobCount = 1;
}
else
{
test_info.jobCount = (cl_uint)((1ULL << 32) / test_info.step);
}
test_info.f = f;
test_info.ftz = f->ftz || gForceFTZ || 0 == (CL_FP_DENORM & gFloatCapabilities);
@@ -319,7 +330,7 @@ int TestMacro_Int_Float_Float(const Func *f, MTdata d)
// Run the kernels
if( !gSkipCorrectnessTesting )
{
error = ThreadPool_Do( TestFloat, (cl_uint) ((1ULL<<32) / test_info.step), &test_info );
error = ThreadPool_Do( TestFloat, test_info.jobCount, &test_info );
if( error )
goto exit;
@@ -749,6 +760,16 @@ int TestMacro_Int_Double_Double(const Func *f, MTdata d)
}
test_info.step = (cl_uint) test_info.subBufferSize * test_info.scale;
if (test_info.step / test_info.subBufferSize != test_info.scale)
{
//there was overflow
test_info.jobCount = 1;
}
else
{
test_info.jobCount = (cl_uint)((1ULL << 32) / test_info.step);
}
test_info.f = f;
test_info.ftz = f->ftz || gForceFTZ;
@@ -820,7 +841,7 @@ int TestMacro_Int_Double_Double(const Func *f, MTdata d)
if( !gSkipCorrectnessTesting )
{
error = ThreadPool_Do( TestDouble, (cl_uint) ((1ULL<<32) / test_info.step), &test_info );
error = ThreadPool_Do( TestDouble, test_info.jobCount, &test_info );
if( error )
goto exit;

25
test_conformance/math_brute_force/macro_unary.c
View File

@@ -193,6 +193,7 @@ typedef struct TestInfo
cl_kernel *k[VECTOR_SIZE_COUNT ]; // arrays of thread-specific kernels for each worker thread: k[vector_size][thread_id]
ThreadInfo *tinfo; // An array of thread specific information for each worker thread
cl_uint threadCount; // Number of worker threads
cl_uint jobCount; // Number of jobs
cl_uint step; // step between each chunk and the next.
cl_uint scale; // stride between individual test values
int ftz; // non-zero if running in flush to zero mode
@@ -220,6 +221,16 @@ int TestMacro_Int_Float(const Func *f, MTdata d)
test_info.scale = (cl_uint) sizeof(cl_float) * 2 * gWimpyReductionFactor;
}
test_info.step = (cl_uint) test_info.subBufferSize * test_info.scale;
if (test_info.step / test_info.subBufferSize != test_info.scale)
{
//there was overflow
test_info.jobCount = 1;
}
else
{
test_info.jobCount = (cl_uint)((1ULL << 32) / test_info.step);
}
test_info.f = f;
test_info.ftz = f->ftz || gForceFTZ || 0 == (CL_FP_DENORM & gFloatCapabilities);
// cl_kernels aren't thread safe, so we make one for each vector size for every thread
@@ -279,7 +290,7 @@ int TestMacro_Int_Float(const Func *f, MTdata d)
if( !gSkipCorrectnessTesting )
{
error = ThreadPool_Do( TestFloat, (cl_uint) ((1ULL<<32) / test_info.step), &test_info );
error = ThreadPool_Do( TestFloat, test_info.jobCount, &test_info );
if( error )
goto exit;
@@ -602,6 +613,16 @@ int TestMacro_Int_Double(const Func *f, MTdata d)
}
test_info.step = (cl_uint) test_info.subBufferSize * test_info.scale;
if (test_info.step / test_info.subBufferSize != test_info.scale)
{
//there was overflow
test_info.jobCount = 1;
}
else
{
test_info.jobCount = (cl_uint)((1ULL << 32) / test_info.step);
}
test_info.f = f;
test_info.ftz = f->ftz || gForceFTZ;
@@ -664,7 +685,7 @@ int TestMacro_Int_Double(const Func *f, MTdata d)
if( !gSkipCorrectnessTesting )
{
error = ThreadPool_Do( TestDouble, (cl_uint) ((1ULL<<32) / test_info.step), &test_info );
error = ThreadPool_Do( TestDouble, test_info.jobCount, &test_info );
if( error )
goto exit;

21
test_conformance/math_brute_force/main.c
View File

@@ -499,24 +499,7 @@ static int ParseArgs( int argc, const char **argv )
break;
case '[':
// wimpy reduction factor can be set with the option -[2^n]
// Default factor is 32, and n practically can be from 1 to 10
{
const char *arg_temp = strchr(&arg[1], ']');
if( arg_temp != 0)
{
int new_factor = atoi(&arg[1]);
arg=arg_temp; // Advance until ']'
if(new_factor && !(new_factor & (new_factor - 1)))
{
vlog( " WimpyReduction factor changed from %d to %d \n",gWimpyReductionFactor, new_factor);
gWimpyReductionFactor = new_factor;
}else
{
vlog( " Error in WimpyReduction factor %d, must be power of 2 \n",gWimpyReductionFactor);
}
}
}
parseWimpyReductionFactor(arg, gWimpyReductionFactor);
break;
case 'z':
@@ -699,6 +682,8 @@ static void PrintArch( void )
vlog( "\tARCH:\tx86_64\n" );
#elif defined( __arm__ )
vlog( "\tARCH:\tarm\n" );
#elif defined( __aarch64__ )
vlog( "\tARCH:\taarch64\n" );
#else
vlog( "\tARCH:\tunknown\n" );
#endif

6
test_conformance/math_brute_force/reference_math.c
View File

@@ -1790,7 +1790,7 @@ static const double //two52 = 4.50359962737049600000e+15, /* 0x43300000, 0x00000
// *signgamp = 1;
ix = hx&0x7fffffff;
if(ix>=0x7ff00000) return x*x;
if((ix|lx)==0) return one/zero;
if((ix|lx)==0) return INFINITY;
if(ix<0x3b900000) { /* |x|<2**-70, return -log(|x|) */
if(hx<0) {
// *signgamp = -1;
@@ -1799,9 +1799,9 @@ static const double //two52 = 4.50359962737049600000e+15, /* 0x43300000, 0x00000
}
if(hx<0) {
if(ix>=0x43300000) /* |x|>=2**52, must be -integer */
return one/zero;
return INFINITY;
t = reference_sinpi(x);
if(t==zero) return one/zero; /* -integer */
if(t==zero) return INFINITY; /* -integer */
nadj = reference_log(pi/reference_fabs(t*x));
// if(t<zero) *signgamp = -1;
x = -x;

0
test_conformance/math_brute_force/run_math_brute_force_in_parallel.py Normal file → Executable file
View File

26
test_conformance/math_brute_force/unary.c
View File

@@ -200,6 +200,7 @@ typedef struct TestInfo
cl_kernel *k[VECTOR_SIZE_COUNT ]; // arrays of thread-specific kernels for each worker thread: k[vector_size][thread_id]
ThreadInfo *tinfo; // An array of thread specific information for each worker thread
cl_uint threadCount; // Number of worker threads
cl_uint jobCount; // Number of jobs
cl_uint step; // step between each chunk and the next.
cl_uint scale; // stride between individual test values
float ulps; // max_allowed ulps
@@ -234,6 +235,16 @@ int TestFunc_Float_Float(const Func *f, MTdata d)
test_info.scale = (cl_uint) sizeof(cl_float) * 2 * gWimpyReductionFactor;
}
test_info.step = (cl_uint) test_info.subBufferSize * test_info.scale;
if (test_info.step / test_info.subBufferSize != test_info.scale)
{
//there was overflow
test_info.jobCount = 1;
}
else
{
test_info.jobCount = (cl_uint)((1ULL << 32) / test_info.step);
}
test_info.f = f;
test_info.ulps = gIsEmbedded ? f->float_embedded_ulps : f->float_ulps;
test_info.ftz = f->ftz || gForceFTZ || 0 == (CL_FP_DENORM & gFloatCapabilities);
@@ -309,7 +320,7 @@ int TestFunc_Float_Float(const Func *f, MTdata d)
if( !gSkipCorrectnessTesting || skipTestingRelaxed)
{
error = ThreadPool_Do( TestFloat, (cl_uint) ((1ULL<<32) / test_info.step), &test_info );
error = ThreadPool_Do( TestFloat, test_info.jobCount, &test_info );
// Accumulate the arithmetic errors
for( i = 0; i < test_info.threadCount; i++ )
@@ -997,7 +1008,16 @@ int TestFunc_Double_Double(const Func *f, MTdata d)
test_info.subBufferSize = gWimpyBufferSize / (sizeof( cl_double) * RoundUpToNextPowerOfTwo(test_info.threadCount));
test_info.scale = (cl_uint) sizeof(cl_double) * 2 * gWimpyReductionFactor;
}
test_info.step = (cl_uint) test_info.subBufferSize * test_info.scale;
test_info.step = (cl_uint) test_info.subBufferSize * test_info.scale;
if (test_info.step / test_info.subBufferSize != test_info.scale)
{
//there was overflow
test_info.jobCount = 1;
}
else
{
test_info.jobCount = (cl_uint)((1ULL << 32) / test_info.step);
}
test_info.f = f;
test_info.ulps = f->double_ulps;
@@ -1062,7 +1082,7 @@ int TestFunc_Double_Double(const Func *f, MTdata d)
if( !gSkipCorrectnessTesting )
{
error = ThreadPool_Do( TestDouble, (cl_uint) ((1ULL<<32) / test_info.step), &test_info );
error = ThreadPool_Do( TestDouble, test_info.jobCount, &test_info );
// Accumulate the arithmetic errors
for( i = 0; i < test_info.threadCount; i++ )

25
test_conformance/non_uniform_work_group/TestNonUniformWorkGroup.cpp
View File

@@ -605,6 +605,28 @@ void TestNonUniformWorkGroup::showTestInfo () {
}
}
size_t TestNonUniformWorkGroup::adjustLocalArraySize (size_t localArraySize) {
// In case if localArraySize is too big, sometimes we can not run kernel because of lack
// of resources due to kernel itself requires some local memory to run
int err;
cl_ulong kernelLocalMemSize = 0;
err = clGetKernelWorkGroupInfo(_testKernel, _device, CL_KERNEL_LOCAL_MEM_SIZE, sizeof(kernelLocalMemSize), &kernelLocalMemSize, NULL);
test_error(err, "clGetKernelWorkGroupInfo failed");
cl_ulong deviceLocalMemSize = 0;
err = clGetDeviceInfo(_device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof(deviceLocalMemSize), &deviceLocalMemSize, NULL);
test_error(err, "clGetDeviceInfo failed");
if (kernelLocalMemSize + localArraySize > deviceLocalMemSize) {
size_t adjustedLocalArraySize = deviceLocalMemSize - kernelLocalMemSize;
log_info("localArraySize was adjusted from %lu to %lu\n", localArraySize, adjustedLocalArraySize);
localArraySize = adjustedLocalArraySize;
}
return localArraySize;
}
int TestNonUniformWorkGroup::runKernel () {
int err;
@@ -622,7 +644,8 @@ int TestNonUniformWorkGroup::runKernel () {
test_error(err, "clSetKernelArg failed");
//creating local buffer
err = clSetKernelArg(_testKernel, 1, localArraySize*sizeof(unsigned int), NULL);
localArraySize = adjustLocalArraySize(localArraySize*sizeof(unsigned int));
err = clSetKernelArg(_testKernel, 1, localArraySize, NULL);
test_error(err, "clSetKernelArg failed");
clMemWrapper testGlobalArray = clCreateBuffer(_context, CL_MEM_READ_WRITE, _numOfGlobalWorkItems*sizeof(cl_uint), NULL, &err);

1
test_conformance/non_uniform_work_group/TestNonUniformWorkGroup.h
View File

@@ -116,6 +116,7 @@ private:
void verifyData (DataContainerAttrib * reference, DataContainerAttrib * results, short regionNumber);
void calculateExpectedValues ();
void showTestInfo ();
size_t adjustLocalArraySize(size_t localArraySize);
};
// Class responsible for running subtest scenarios in test function

1
test_conformance/opencl_conformance_tests_21_full_spirv.csv
View File

@@ -111,6 +111,7 @@ Workgroups,workgroups/test_workgroups -offlineCompiler spir_v cache .
# OpenCL 2.1 tests
#####################################
Device timer,device_timer/test_device_timer
SPIRV new,spirv_new/test_spirv_new -ILPath spirv_bin
#########################################
# Extensions
1 #
111
112
113
114
115
116
117

6
test_conformance/opencl_conformance_tests_21_legacy_wimpy.csv
View File

@@ -93,6 +93,12 @@ Pipes,pipes/test_pipes
SVM,SVM/test_SVM
Workgroups,workgroups/test_workgroups
#####################################
# OpenCL 2.1 tests
#####################################
Device timer,device_timer/test_device_timer
SPIRV new,spirv_new/test_spirv_new -ILPath spirv_bin
#########################################
# Extensions
#########################################
1 #
93 SPIR,spir/test_spir
94 Mipmaps (Kernel),images/kernel_read_write/test_image_streams test_mipmaps CL_FILTER_NEAREST
95 Mipmaps (clCopyImage),images/clCopyImage/test_cl_copy_images test_mipmaps
96 Mipmaps (clReadWriteImage),images/clReadWriteImage/test_cl_read_write_images test_mipmaps
97 Subgroups,subgroups/test_subgroups
98
99
100
101
102
103
104

6
test_conformance/opencl_conformance_tests_full.csv
View File

@@ -107,6 +107,12 @@ Pipes,pipes/test_pipes
SVM,SVM/test_SVM
Workgroups,workgroups/test_workgroups
#####################################
# OpenCL 2.1 tests
#####################################
Device timer,device_timer/test_device_timer
SPIRV new,spirv_new/test_spirv_new -ILPath spirv_bin
#########################################
# Extensions
#########################################
1 #
107 Mipmaps (Kernel),images/kernel_read_write/test_image_streams test_mipmaps CL_FILTER_NEAREST
108 Mipmaps (clCopyImage),images/clCopyImage/test_cl_copy_images test_mipmaps
109 Mipmaps (clReadWriteImage),images/clReadWriteImage/test_cl_read_write_images test_mipmaps
110 Subgroups,subgroups/test_subgroups
111
112
113
114
115
116
117
118

41
test_conformance/opencl_conformance_tests_full_no_math_or_conversions.csv
View File

@@ -1,5 +1,5 @@
#
# OpenCL Conformance Test Suite (full version)
# OpenCL Conformance Test Suite (no math and no conversion)
#
# #########################################
@@ -33,6 +33,8 @@ Allocations (single maximum),allocations/test_allocations single 5 all
Allocations (total maximum),allocations/test_allocations multiple 5 all
VecAlign, vec_align/test_vecalign
VecStep, vec_step/test_vecstep
Printf,printf/test_printf
Device Partitioning,device_partition/test_device_partition
# #########################################
# Buffers and images
@@ -65,10 +67,6 @@ Headers (cl.h standalone), headers/test_cl_h
Headers (cl_platform.h standalone), headers/test_cl_platform_h
Headers (cl_gl.h standalone), headers/test_cl_gl_h
Headers (opencl.h standalone), headers/test_opencl_h
Headers (cl.h standalone C99), headers/test_cl_h_c99
Headers (cl_platform.h standalone C99), headers/test_cl_platform_h_c99
Headers (cl_gl.h standalone C99), headers/test_cl_gl_h_c99
Headers (opencl.h standalone C99), headers/test_opencl_h_c99
# #########################################
# CPU is required to pass linear and normalized image filtering
@@ -88,5 +86,36 @@ OpenCL-GL Sharing,gl/test_gl
Select,select/test_select
Contractions,contractions/contractions
Integer Ops,integer_ops/test_integer_ops
Half Ops,half/Test_half
Half Ops,half/test_half
# #########################################
# Compatibility with Previous Versions
# #########################################
Basic 1.2,compatibility/test_conformance/basic/test_basic
API 1.2,compatibility/test_conformance/api/test_api
#####################################
# OpenCL 2.0 tests
#####################################
C11 Atomics,c11_atomics/test_c11_atomics
Execution Model,device_execution/test_device_execution
Generic Address Space,generic_address_space/test_generic_address_space
Non Uniform Work Groups,non_uniform_work_group/test_non_uniform_work_group
Pipes,pipes/test_pipes
SVM,SVM/test_SVM
Workgroups,workgroups/test_workgroups
#####################################
# OpenCL 2.1 tests
#####################################
Device timer,device_timer/test_device_timer
SPIRV new,spirv_new/test_spirv_new -ILPath spirv_bin
#########################################
# Extensions
#########################################
SPIR,spir/test_spir
Mipmaps (Kernel),images/kernel_read_write/test_image_streams test_mipmaps CL_FILTER_NEAREST
Mipmaps (clCopyImage),images/clCopyImage/test_cl_copy_images test_mipmaps
Mipmaps (clReadWriteImage),images/clReadWriteImage/test_cl_read_write_images test_mipmaps
Subgroups,subgroups/test_subgroups
1 #
2 # OpenCL Conformance Test Suite (full version) # OpenCL Conformance Test Suite (no math and no conversion)
3 #
4 # #########################################
5 # Basic Information on the compute device
33 # Buffers and images Device Partitioning,device_partition/test_device_partition
34 # #########################################
35 Buffers,buffers/test_buffers # Buffers and images
36 # #########################################
37 Buffers,buffers/test_buffers
38 Images (API Info),images/clGetInfo/test_cl_get_info
39 Images (Kernel Methods),images/kernel_image_methods/test_kernel_image_methods
40 Images (Kernel),images/kernel_read_write/test_image_streams CL_FILTER_NEAREST
67 Headers (opencl.h standalone C99), headers/test_opencl_h_c99 CL_DEVICE_TYPE_CPU, Images (Kernel CL_FILTER_LINEAR),images/kernel_read_write/test_image_streams CL_FILTER_LINEAR
68 # ######################################### CL_DEVICE_TYPE_CPU, Images (Kernel CL_FILTER_LINEAR pitch),images/kernel_read_write/test_image_streams use_pitches CL_FILTER_LINEAR
69 # CPU is required to pass linear and normalized image filtering CL_DEVICE_TYPE_CPU, Images (Kernel CL_FILTER_LINEAR max size),images/kernel_read_write/test_image_streams max_images CL_FILTER_LINEAR
# #########################################
CL_DEVICE_TYPE_CPU, Images (Kernel CL_FILTER_LINEAR),images/kernel_read_write/test_image_streams CL_FILTER_LINEAR
CL_DEVICE_TYPE_CPU, Images (Kernel CL_FILTER_LINEAR pitch),images/kernel_read_write/test_image_streams use_pitches CL_FILTER_LINEAR
CL_DEVICE_TYPE_CPU, Images (Kernel CL_FILTER_LINEAR max size),images/kernel_read_write/test_image_streams max_images CL_FILTER_LINEAR
70 # #########################################
71 # OpenGL/CL interaction
72 # #########################################
86 #####################################
87 # OpenCL 2.0 tests
88 #####################################
89 C11 Atomics,c11_atomics/test_c11_atomics
90 Execution Model,device_execution/test_device_execution
91 Generic Address Space,generic_address_space/test_generic_address_space
92 Non Uniform Work Groups,non_uniform_work_group/test_non_uniform_work_group
93 Pipes,pipes/test_pipes
94 SVM,SVM/test_SVM
95 Workgroups,workgroups/test_workgroups
96 #####################################
97 # OpenCL 2.1 tests
98 #####################################
99 Device timer,device_timer/test_device_timer
100 SPIRV new,spirv_new/test_spirv_new -ILPath spirv_bin
101 #########################################
102 # Extensions
103 #########################################
104 SPIR,spir/test_spir
105 Mipmaps (Kernel),images/kernel_read_write/test_image_streams test_mipmaps CL_FILTER_NEAREST
106 Mipmaps (clCopyImage),images/clCopyImage/test_cl_copy_images test_mipmaps
107 Mipmaps (clReadWriteImage),images/clReadWriteImage/test_cl_read_write_images test_mipmaps
108 Subgroups,subgroups/test_subgroups
109
110
111
112
113
114
115
116
117
118
119
120
121

53
test_conformance/printf/test_printf.c
View File

@@ -17,6 +17,7 @@
#include <string.h>
#include <errno.h>
#include <memory>
#if ! defined( _WIN32)
#if ! defined( __ANDROID__ )
@@ -304,9 +305,6 @@ static cl_program makePrintfProgram(cl_kernel *kernel_ptr, const cl_context cont
//-----------------------------------------
static bool isLongSupported(cl_device_id device_id)
{
//profile type && device extention for long support checking
char *profileType = NULL,*devExt = NULL;
size_t tempSize = 0;
cl_int status;
bool extSupport = true;
@@ -325,7 +323,7 @@ static bool isLongSupported(cl_device_id device_id)
return false;
}
profileType = new char[tempSize];
std::unique_ptr<char[]> profileType(new char[tempSize]);
if(profileType == NULL)
{
log_error("Failed to allocate memory(profileType)");
@@ -336,11 +334,11 @@ static bool isLongSupported(cl_device_id device_id)
device_id,
CL_DEVICE_PROFILE,
sizeof(char) * tempSize,
profileType,
profileType.get(),
NULL);
if(!strcmp("EMBEDDED_PROFILE",profileType))
if(!strcmp("EMBEDDED_PROFILE",profileType.get()))
{
// Device extention
status = clGetDeviceInfo(
@@ -356,7 +354,7 @@ static bool isLongSupported(cl_device_id device_id)
return false;
}
devExt = new char[tempSize];
std::unique_ptr<char[]> devExt(new char[tempSize]);
if(devExt == NULL)
{
log_error("Failed to allocate memory(devExt)");
@@ -367,13 +365,10 @@ static bool isLongSupported(cl_device_id device_id)
device_id,
CL_DEVICE_EXTENSIONS,
sizeof(char) * tempSize,
devExt,
devExt.get(),
NULL);
extSupport = (strstr(devExt,"cles_khr_int64") != NULL);
delete devExt;
delete profileType;
extSupport = (strstr(devExt.get(),"cles_khr_int64") != NULL);
}
return extSupport;
}
@@ -410,7 +405,8 @@ static int doTest(cl_command_queue queue, cl_context context, const unsigned int
int err;
cl_program program;
cl_kernel kernel;
cl_mem d_out;
cl_mem d_out = NULL;
cl_mem d_a = NULL;
char _analysisBuffer[ANALYSIS_BUFFER_SIZE];
cl_uint out32 = 0;
cl_ulong out64 = 0;
@@ -431,7 +427,7 @@ static int doTest(cl_command_queue queue, cl_context context, const unsigned int
if(isKernelArgument(allTestCase[testId],testNum))
{
int a = 2;
cl_mem d_a = clCreateBuffer(context, CL_MEM_READ_ONLY|CL_MEM_COPY_HOST_PTR,
d_a = clCreateBuffer(context, CL_MEM_READ_ONLY|CL_MEM_COPY_HOST_PTR,
sizeof(int), &a, &err);
if(err!= CL_SUCCESS || d_a == NULL) {
log_error("clCreateBuffer failed\n");
@@ -460,10 +456,12 @@ static int doTest(cl_command_queue queue, cl_context context, const unsigned int
}
}
int fd = acquireOutputStream();
globalWorkSize[0] = 1;
cl_event ndrEvt;
err = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, globalWorkSize, NULL, 0, NULL,&ndrEvt);
if (err != CL_SUCCESS) {
releaseOutputStream(fd);
log_error("\n clEnqueueNDRangeKernel failed errcode:%d\n", err);
++s_test_fail;
goto exit;
@@ -473,6 +471,7 @@ static int doTest(cl_command_queue queue, cl_context context, const unsigned int
err = clFlush(queue);
if(err != CL_SUCCESS)
{
releaseOutputStream(fd);
log_error("clFlush failed\n");
goto exit;
}
@@ -480,6 +479,8 @@ static int doTest(cl_command_queue queue, cl_context context, const unsigned int
//is immidatly printed
err = waitForEvent(&ndrEvt);
releaseOutputStream(fd);
if(err != CL_SUCCESS)
{
log_error("waitforEvent failed\n");
@@ -521,6 +522,10 @@ exit:
log_error("clReleaseKernel failed\n");
if(clReleaseProgram(program) != CL_SUCCESS)
log_error("clReleaseProgram failed\n");
if(d_out)
clReleaseMemObject(d_out);
if(d_a)
clReleaseMemObject(d_a);
++s_test_cnt;
return err;
}
@@ -553,6 +558,8 @@ static void printArch( void )
log_info( "ARCH:\tx86_64\n" );
#elif defined( __arm__ )
log_info( "ARCH:\tarm\n" );
#elif defined( __aarch64__ );
log_info( "ARCH:\taarch64\n" );
#else
#error unknown arch
#endif
@@ -669,7 +676,6 @@ int main(int argc, const char* argv[]) {
int err;
int fd = acquireOutputStream();
// Get platform
err = clGetPlatformIDs(1, &platform_id, NULL);
@@ -695,8 +701,6 @@ int main(int argc, const char* argv[]) {
if((err = clGetDeviceInfo(device_id, CL_DEVICE_MAX_CLOCK_FREQUENCY, config_size, &device_frequency, NULL )))
device_frequency = 1;
releaseOutputStream(fd);
log_info( "\nCompute Device info:\n" );
log_info( "\tProcessing with %d devices\n", compute_devices );
log_info( "\tDevice Frequency: %d MHz\n", device_frequency );
@@ -716,8 +720,6 @@ int main(int argc, const char* argv[]) {
log_info( "Test binary built %s %s\n", __DATE__, __TIME__ );
fd = acquireOutputStream();
cl_context context = clCreateContext(NULL, 1, &device_id, notify_callback, NULL, NULL);
checkNull(context, "clCreateContext");
@@ -727,17 +729,13 @@ int main(int argc, const char* argv[]) {
// Forall types
for (int testId = 0; testId < TYPE_COUNT; ++testId) {
if (test_filter_num && (testId != test_filter_num)) {
releaseOutputStream(fd);
log_info("\n*** Skipping printf for %s ***\n",strType[testId]);
fd = acquireOutputStream();
}
else {
releaseOutputStream(fd);
log_info("\n*** Testing printf for %s ***\n",strType[testId]);
fd = acquireOutputStream();
//For all formats
for(unsigned int testNum = 0;testNum < allTestCase[testId]->_testNum;++testNum){
releaseOutputStream(fd);
if(allTestCase[testId]->_type == TYPE_VECTOR)
log_info("%d)testing printf(\"%sv%s%s\",%s)\n",testNum,allTestCase[testId]->_genParameters[testNum].vectorFormatFlag,allTestCase[testId]->_genParameters[testNum].vectorSize,
allTestCase[testId]->_genParameters[testNum].vectorFormatSpecifier,allTestCase[testId]->_genParameters[testNum].dataRepresentation);
@@ -752,7 +750,6 @@ int main(int argc, const char* argv[]) {
}
else
log_info("%d)testing printf(\"%s\",%s)\n",testNum,allTestCase[testId]->_genParameters[testNum].genericFormat,allTestCase[testId]->_genParameters[testNum].dataRepresentation);
fd = acquireOutputStream();
// Long support for varible type
if(allTestCase[testId]->_type == TYPE_VECTOR && !strcmp(allTestCase[testId]->_genParameters[testNum].dataType,"long") && !isLongSupported(device_id))
@@ -766,15 +763,11 @@ int main(int argc, const char* argv[]) {
// Perform the test
if (doTest(queue, context,testId,testNum,device_id,isLongSupport) != 0)
{
releaseOutputStream(fd);
log_error("*** FAILED ***\n\n");
fd = acquireOutputStream();
}
else
{
releaseOutputStream(fd);
log_info("Passed\n");
fd = acquireOutputStream();
}
}
}
@@ -790,8 +783,6 @@ int main(int argc, const char* argv[]) {
if(clReleaseContext(context)!= CL_SUCCESS)
log_error("clReleaseContext\n");
releaseOutputStream(fd);
if (s_test_fail == 0) {
if (s_test_cnt > 1)

18
test_conformance/printf/util_printf.c
View File

@@ -212,8 +212,6 @@ struct printDataGenParameters printFloatGenParameters[] = {
{"%+#21.15E","789456123.0"},
#if ! defined( __ANDROID__ )
//Double argument representing floating-point,in [-]xh.hhhhpAd style
{"%.6a","0.1"},
@@ -222,8 +220,6 @@ struct printDataGenParameters printFloatGenParameters[] = {
{"%10.2a","9990.235"},
#endif
//Infinity (1.0/0.0)
{"%f","1.0f/0.0f"},
@@ -275,14 +271,10 @@ const char* correctBufferFloat[] = {
"+7.894561230000000E+8",
#if ! defined( __ANDROID__ )
"0x1.99999ap-4",
"0x1.38p+13",
#endif
"inf",
"-nan",
@@ -621,11 +613,6 @@ struct printDataGenParameters printStringGenParameters[] = {
//%% specification
{"%s","\"%%\""},
//null string
{"%s","(void*)0"}
};
//---------------------------------------------------------
@@ -641,9 +628,6 @@ const char * correctBufferString[] = {
"f",
"%%",
"(null)"
};
//---------------------------------------------------------
@@ -887,7 +871,7 @@ size_t verifyOutputBuffer(char *analysisBuffer,testCase* pTestCase,size_t testId
if(!strcmp(pTestCase->_correctBuffer[testId],"inf"))
return strcmp(analysisBuffer,"inf")&&strcmp(analysisBuffer,"infinity")&&strcmp(analysisBuffer,"1.#INF00")&&strcmp(analysisBuffer,"Inf");
if(!strcmp(pTestCase->_correctBuffer[testId],"nan") || !strcmp(pTestCase->_correctBuffer[testId],"-nan")) {
return strcmp(analysisBuffer,"nan")&&strcmp(analysisBuffer,"-nan")&&strcmp(analysisBuffer,"1.#IND00")&&strcmp(analysisBuffer,"-1.#IND00")&&strcmp(analysisBuffer,"NaN")&&strcmp(analysisBuffer,"nan(ind)")&&strcmp(analysisBuffer,"nan(snan)");
return strcmp(analysisBuffer,"nan")&&strcmp(analysisBuffer,"-nan")&&strcmp(analysisBuffer,"1.#IND00")&&strcmp(analysisBuffer,"-1.#IND00")&&strcmp(analysisBuffer,"NaN")&&strcmp(analysisBuffer,"nan(ind)")&&strcmp(analysisBuffer,"nan(snan)")&&strcmp(analysisBuffer,"-nan(ind)");
}
return strcmp(analysisBuffer,pTestCase->_correctBuffer[testId]);
}

0
test_conformance/run_conformance.py Normal file → Executable file
View File

10
test_conformance/select/test_select.c
View File

@@ -72,6 +72,7 @@ static int doTest(cl_command_queue queue, cl_context context,
// range. Otherwise, we test a subset of the range
// [-min_short, min_short]
static bool s_wimpy_mode = false;
static int s_wimpy_reduction_factor = 256;
// Tests are broken into the major test which is based on the
// src and cmp type and their corresponding vector types and
@@ -304,7 +305,7 @@ static int doTest(cl_command_queue queue, cl_context context, Type stype, Type c
cl_ulong blocks = type_size[stype] * 0x100000000ULL / BUFFER_SIZE;
size_t block_elements = BUFFER_SIZE / type_size[stype];
size_t step = s_wimpy_mode ? 256 : 1;
size_t step = s_wimpy_mode ? s_wimpy_reduction_factor : 1;
cl_ulong cmp_stride = block_elements * step;
// It is more efficient to create the tests all at once since we
@@ -471,6 +472,7 @@ static void printUsage( void )
log_info("test_select: [-cghw] [test_name|start_test_num] \n");
log_info(" default is to run the full test on the default device\n");
log_info(" -w run in wimpy mode (smoke test)\n");
log_info(" -[2^n] Set wimpy reduction factor, recommended range of n is 1-12, default factor(%u)\n", s_wimpy_reduction_factor);
log_info(" test_name will run only one test of that name\n");
log_info(" start_test_num will start running from that num\n");
}
@@ -491,6 +493,8 @@ static void printArch( void )
log_info( "ARCH:\tx86_64\n" );
#elif defined( __arm__ )
log_info( "ARCH:\tarm\n" );
#elif defined( __aarch64__ )
log_info( "ARCH:\taarch64\n" );
#else
#error unknown arch
#endif
@@ -582,6 +586,9 @@ int main(int argc, const char* argv[]) {
case 'w': // Wimpy mode
s_wimpy_mode = true;
break;
case '[':
parseWimpyReductionFactor(arg, s_wimpy_reduction_factor);
break;
default:
log_error( " <-- unknown flag: %c (0x%2.2x)\n)", *arg, *arg );
printUsage();
@@ -659,6 +666,7 @@ int main(int argc, const char* argv[]) {
log_info("*** WARNING: Testing in Wimpy mode! ***\n");
log_info("*** Wimpy mode is not sufficient to verify correctness. ***\n");
log_info("*** It gives warm fuzzy feelings and then nevers calls. ***\n\n");
log_info("*** Wimpy Reduction Factor: %-27u ***\n\n", s_wimpy_reduction_factor);
}
cl_context context = clCreateContext(NULL, 1, &device_id, notify_callback, NULL, NULL);

BIN
test_conformance/spir/basic.zip
View File

Binary file not shown.

BIN
test_conformance/spir/half.zip
View File

Binary file not shown.

BIN
test_conformance/spir/images_kernel_read_write.zip
View File

Binary file not shown.

1
test_conformance/spir/main.cpp
View File

@@ -840,7 +840,6 @@ bool test_basic (cl_device_id device, cl_uint size_t_width, const char *folder)
"test_sizeof.sizeof_uintptr_t",
"test_sizeof.sizeof_image2d_t",
"test_sizeof.sizeof_image3d_t",
"test_sizeof.sizeof_sampler_t",
"test_sizeof.sizeof_double",
"test_sizeof.sizeof_double2",
"test_sizeof.sizeof_double4",

BIN
test_conformance/spir/profiling.zip
View File

Binary file not shown.

36
test_conformance/spir/typeinfo.h
View File

@@ -93,6 +93,42 @@ TYPE_HNDL("image3d_int", false, 0, 1, 0x0,
TYPE_HNDL("image3d_uint", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage3d<CL_UNSIGNED_INT32>)
TYPE_HNDL("image_kernel_data", false, 0, 1, 0x0, 0xffffffff, KernelStructTypeArgGenerator<image_kernel_data>) //image_kernel_data defines as 5 X int
TYPE_HNDL("image_kernel_data*", true, 0, 1, 0x0, 0xffffffff, KernelStructTypeArgGenerator<image_kernel_data>) //image_kernel_data defines as 5 X int
TYPE_HNDL("read_only_image1d_array_float", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1dArray<CL_FLOAT>)
TYPE_HNDL("read_only_image1d_array_int", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1dArray<CL_SIGNED_INT32>)
TYPE_HNDL("read_only_image1d_array_uint", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1dArray<CL_UNSIGNED_INT32>)
TYPE_HNDL("read_only_image1d_buffer_float", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1dBuffer<CL_FLOAT>)
TYPE_HNDL("read_only_image1d_buffer_int", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1dBuffer<CL_SIGNED_INT32>)
TYPE_HNDL("read_only_image1d_buffer_uint", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1dBuffer<CL_UNSIGNED_INT32>)
TYPE_HNDL("read_only_image1d_float", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1d<CL_FLOAT>)
TYPE_HNDL("read_only_image1d_int", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1d<CL_SIGNED_INT32>)
TYPE_HNDL("read_only_image1d_uint", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1d<CL_UNSIGNED_INT32>)
TYPE_HNDL("read_only_image2d_array_float", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage2dArray<CL_FLOAT>)
TYPE_HNDL("read_only_image2d_array_int", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage2dArray<CL_SIGNED_INT32>)
TYPE_HNDL("read_only_image2d_array_uint", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage2dArray<CL_UNSIGNED_INT32>)
TYPE_HNDL("read_only_image2d_float", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage2d<CL_FLOAT>)
TYPE_HNDL("read_only_image2d_int", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage2d<CL_SIGNED_INT32>)
TYPE_HNDL("read_only_image2d_uint", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage2d<CL_UNSIGNED_INT32>)
TYPE_HNDL("read_only_image3d_float", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage3d<CL_FLOAT>)
TYPE_HNDL("read_only_image3d_int", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage3d<CL_SIGNED_INT32>)
TYPE_HNDL("read_only_image3d_uint", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage3d<CL_UNSIGNED_INT32>)
TYPE_HNDL("write_only_image1d_array_float", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1dArray<CL_FLOAT>)
TYPE_HNDL("write_only_image1d_array_int", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1dArray<CL_SIGNED_INT32>)
TYPE_HNDL("write_only_image1d_array_uint", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1dArray<CL_UNSIGNED_INT32>)
TYPE_HNDL("write_only_image1d_buffer_float", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1dBuffer<CL_FLOAT>)
TYPE_HNDL("write_only_image1d_buffer_int", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1dBuffer<CL_SIGNED_INT32>)
TYPE_HNDL("write_only_image1d_buffer_uint", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1dBuffer<CL_UNSIGNED_INT32>)
TYPE_HNDL("write_only_image1d_float", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1d<CL_FLOAT>)
TYPE_HNDL("write_only_image1d_int", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1d<CL_SIGNED_INT32>)
TYPE_HNDL("write_only_image1d_uint", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage1d<CL_UNSIGNED_INT32>)
TYPE_HNDL("write_only_image2d_array_float", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage2dArray<CL_FLOAT>)
TYPE_HNDL("write_only_image2d_array_int", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage2dArray<CL_SIGNED_INT32>)
TYPE_HNDL("write_only_image2d_array_uint", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage2dArray<CL_UNSIGNED_INT32>)
TYPE_HNDL("write_only_image2d_float", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage2d<CL_FLOAT>)
TYPE_HNDL("write_only_image2d_int", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage2d<CL_SIGNED_INT32>)
TYPE_HNDL("write_only_image2d_uint", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage2d<CL_UNSIGNED_INT32>)
TYPE_HNDL("write_only_image3d_float", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage3d<CL_FLOAT>)
TYPE_HNDL("write_only_image3d_int", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage3d<CL_SIGNED_INT32>)
TYPE_HNDL("write_only_image3d_uint", false, 0, 1, 0x0, 0x7f, KernelArgGeneratorImage3d<CL_UNSIGNED_INT32>)
TYPE_HNDL("int", false, 0, 1, 0x0, 0x7fffffff, KernelArgGeneratorT<cl_int>)
TYPE_HNDL("int*", true, 0, 16, 0x0, 0x7fffffff, KernelArgGeneratorT<cl_int>)
TYPE_HNDL("int16", false, 0, 16, 0x0, 0x7fffffff, KernelArgGeneratorT<cl_int>)

37
test_conformance/spirv_new/CMakeLists.txt Normal file
View File

@@ -0,0 +1,37 @@
######################################################################################################
#Copyright (c) 2016 The Khronos Group Inc. All Rights Reserved.
#
#This code is protected by copyright laws and contains material proprietary to the Khronos Group, Inc.
#This is UNPUBLISHED PROPRIETARY SOURCE CODE that may not be disclosed in whole or in part to
#third parties, and may not be reproduced, republished, distributed, transmitted, displayed,
#broadcast or otherwise exploited in any manner without the express prior written permission
#of Khronos Group. The receipt or possession of this code does not convey any rights to reproduce,
#disclose, or distribute its contents, or to manufacture, use, or sell anything that it may describe,
#in whole or in part other than under the terms of the Khronos Adopters Agreement
#or Khronos Conformance Test Source License Agreement as executed between Khronos and the recipient.
######################################################################################################
set(MODULE_NAME SPIRV_NEW)
set(CMAKE_CXX_STANDARD 11)
file(GLOB SPIRV_NEW_SOURCES "*.cpp")
set(TEST_HARNESS_SOURCES
../../test_common/harness/errorHelpers.c
../../test_common/harness/threadTesting.c
../../test_common/harness/testHarness.c
../../test_common/harness/kernelHelpers.c
../../test_common/harness/typeWrappers.cpp
../../test_common/harness/mt19937.c
../../test_common/harness/conversions.c
../../test_common/harness/msvc9.c
../../test_common/harness/rounding_mode.c
../../test_common/harness/os_helpers.cpp
../../test_common/harness/parseParameters.cpp
../../test_conformance/math_brute_force/reference_math.c
../../test_conformance/math_brute_force/Utility.c
)
set(${MODULE_NAME}_SOURCES ${SPIRV_NEW_SOURCES} ${TEST_HARNESS_SOURCES})
include(../CMakeCommon.txt)

13
test_conformance/spirv_new/README.txt Normal file
View File

@@ -0,0 +1,13 @@
test_conformance/spirv_new README
==================================
The text versions of the spirv files are present in `conformance-tests/test_conformance/spriv_new/spirv_txt`.
These text files have been used to generate the binaries in `spirv_bin` using the assembler from `spirv-tools`.
The absolute path to `spirv_bin` needs to be passed after `-ILPath` token for the test to find the SPIRV binaries.
An example invocation looks like the following:
```
./test_conformance/spirv_new/test_conformance_spirv_new -ILPath /home/user/workspace/conformance-tests/test_conformance/spirv_new/spirv_bin/ [other options]
```

173
test_conformance/spirv_new/main.cpp Normal file
View File

@@ -0,0 +1,173 @@
/******************************************************************
Copyright (c) 2016 The Khronos Group Inc. All Rights Reserved.
This code is protected by copyright laws and contains material proprietary to the Khronos Group, Inc.
This is UNPUBLISHED PROPRIETARY SOURCE CODE that may not be disclosed in whole or in part to
third parties, and may not be reproduced, republished, distributed, transmitted, displayed,
broadcast or otherwise exploited in any manner without the express prior written permission
of Khronos Group. The receipt or possession of this code does not convey any rights to reproduce,
disclose, or distribute its contents, or to manufacture, use, or sell anything that it may describe,
in whole or in part other than under the terms of the Khronos Adopters Agreement
or Khronos Conformance Test Source License Agreement as executed between Khronos and the recipient.
******************************************************************/
#include <stdio.h>
#include <string.h>
#include "procs.h"
#if !defined(_WIN32)
#include <unistd.h>
#endif
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#if defined(_WIN32)
const std::string slash = "\\";
#else
const std::string slash = "/";
#endif
const std::string spvExt = ".spv";
const std::string addrWidth = (sizeof(void *) == 4) ? "32" : "64";
std::vector<unsigned char> readBinary(const char *file_name)
{
using namespace std;
ifstream file(file_name, ios::in | ios::binary | ios::ate);
std::vector<char> tmpBuffer(0);
if (file.is_open()) {
size_t size = file.tellg();
tmpBuffer.resize(size);
file.seekg(0, ios::beg);
file.read(&tmpBuffer[0], size);
file.close();
} else {
log_error("File %s not found\n", file_name);
}
std::vector<unsigned char> result(tmpBuffer.begin(), tmpBuffer.end());
return result;
}
std::vector<unsigned char> readSPIRV(const char *file_name)
{
std::string full_name_str = gSpirVPath + slash + file_name + spvExt + addrWidth;
return readBinary(full_name_str.c_str());
}
const char **spirvTestsRegistry::getTestNames()
{
return &testNames[0];
}
basefn *spirvTestsRegistry::getTests()
{
return &tests[0];
}
size_t spirvTestsRegistry::getNumTests()
{
return tests.size();
}
void spirvTestsRegistry::addTestClass(baseTestClass *test, const char *testName)
{
testNames.push_back(testName);
testClasses.push_back(test);
tests.push_back(test->getFunction());
}
spirvTestsRegistry& spirvTestsRegistry::getInstance()
{
static spirvTestsRegistry instance;
return instance;
}
static int offline_get_program_with_il(clProgramWrapper &prog,
const cl_device_id deviceID,
const cl_context context,
const char *prog_name)
{
cl_int err = 0;
std::string outputTypeStr = "binary";
std::string defaultScript = std::string("..") + slash + std::string("spv_to_binary.py");
std::string gOfflineCompilerOutput = gSpirVPath + slash + std::string(prog_name);
std::string gOfflineCompilerInput = gOfflineCompilerOutput + spvExt;
std::string scriptArgs =
gOfflineCompilerInput + " " +
gOfflineCompilerOutput + " " +
addrWidth + " " +
outputTypeStr + " " +
"-cl-std=CL2.0";
std::string scriptToRunString = defaultScript + scriptArgs;
// execute script
log_info("Executing command: %s\n", scriptToRunString.c_str());
fflush(stdout);
int returnCode = system(scriptToRunString.c_str());
if (returnCode != 0) {
log_error("Command finished with error: 0x%x\n", returnCode);
return CL_COMPILE_PROGRAM_FAILURE;
}
// read output file
std::vector<unsigned char> buffer_vec = readBinary(gOfflineCompilerOutput.c_str());
size_t file_bytes = buffer_vec.size();
if (file_bytes == 0) {
log_error("OfflinerCompiler: Failed to open binary file: %s", gOfflineCompilerOutput.c_str());
return -1;
}
const unsigned char *buffer = &buffer_vec[0];
cl_int status = 0;
prog = clCreateProgramWithBinary(context, 1, &deviceID, &file_bytes, &buffer, &status, &err);
SPIRV_CHECK_ERROR((err || status), "Failed to create program with clCreateProgramWithBinary");
return err;
}
int get_program_with_il(clProgramWrapper &prog,
const cl_device_id deviceID,
const cl_context context,
const char *prog_name)
{
cl_int err = 0;
if (gOfflineCompiler && gOfflineCompilerOutputType == kBinary) {
return offline_get_program_with_il(prog, deviceID, context, prog_name);
}
std::vector<unsigned char> buffer_vec = readSPIRV(prog_name);
int file_bytes = buffer_vec.size();
if (file_bytes == 0) {
log_error("File %s not found\n", prog_name);
return -1;
}
unsigned char *buffer = &buffer_vec[0];
prog = clCreateProgramWithIL(context, buffer, file_bytes, &err);
SPIRV_CHECK_ERROR(err, "Failed to create program with clCreateProgramWithIL");
err = clBuildProgram(prog, 1, &deviceID, NULL, NULL, NULL);
SPIRV_CHECK_ERROR(err, "Failed to build program");
return err;
}
int main(int argc, const char *argv[])
{
gReSeed = 1;
return runTestHarness(argc, argv,
spirvTestsRegistry::getInstance().getNumTests(),
spirvTestsRegistry::getInstance().getTests(),
spirvTestsRegistry::getInstance().getTestNames(),
false, false, 0);
}

101
test_conformance/spirv_new/procs.h Normal file
View File

@@ -0,0 +1,101 @@
/******************************************************************
Copyright (c) 2016 The Khronos Group Inc. All Rights Reserved.
This code is protected by copyright laws and contains material proprietary to the Khronos Group, Inc.
This is UNPUBLISHED PROPRIETARY SOURCE CODE that may not be disclosed in whole or in part to
third parties, and may not be reproduced, republished, distributed, transmitted, displayed,
broadcast or otherwise exploited in any manner without the express prior written permission
of Khronos Group. The receipt or possession of this code does not convey any rights to reproduce,
disclose, or distribute its contents, or to manufacture, use, or sell anything that it may describe,
in whole or in part other than under the terms of the Khronos Adopters Agreement
or Khronos Conformance Test Source License Agreement as executed between Khronos and the recipient.
******************************************************************/
#pragma once
#include "../../test_common/harness/errorHelpers.h"
#include "../../test_common/harness/kernelHelpers.h"
#include "../../test_common/harness/typeWrappers.h"
#include "../../test_common/harness/conversions.h"
#include "../../test_common/harness/mt19937.h"
#include "../../test_common/harness/compat.h"
#include "../../test_common/harness/testHarness.h"
#include "../../test_common/harness/parseParameters.h"
#include <vector>
#define SPIRV_CHECK_ERROR(err, fmt, ...) do { \
if (err == CL_SUCCESS) break; \
log_error("%s(%d): Error %d\n" fmt "\n", \
__FILE__, __LINE__, err, ##__VA_ARGS__); \
return -1; \
} while(0)
class baseTestClass
{
public:
baseTestClass() {}
virtual basefn getFunction() = 0;
};
class spirvTestsRegistry {
private:
std::vector<const char *> testNames;
std::vector<baseTestClass *> testClasses;
std::vector<basefn> tests;
public:
static spirvTestsRegistry& getInstance();
const char **getTestNames();
basefn *getTests();
size_t getNumTests();
void addTestClass(baseTestClass *test, const char *testName);
spirvTestsRegistry() {}
};
template<typename T>
T* createAndRegister(const char *name)
{
T *testClass = new T();
spirvTestsRegistry::getInstance().addTestClass((baseTestClass *)testClass, name);
return testClass;
}
#define TEST_SPIRV_FUNC(name) \
extern int test_##name(cl_device_id deviceID, \
cl_context context, \
cl_command_queue queue, \
int num_elements); \
class test_##name##_class : public baseTestClass \
{ \
private: \
basefn fn; \
\
public: \
test_##name##_class() : fn(test_##name) \
{ \
} \
basefn getFunction() \
{ \
return fn; \
} \
}; \
test_##name##_class *var_##name = \
createAndRegister<test_##name##_class>(#name); \
int test_##name(cl_device_id deviceID, \
cl_context context, \
cl_command_queue queue, \
int num_elements)
std::vector<unsigned char> readSPIRV(const char *file_name);
int get_program_with_il(clProgramWrapper &prog,
const cl_device_id deviceID,
const cl_context context,
const char *prog_name);

BIN
test_conformance/spirv_new/spirv_bin/atomic_dec_global.spv32 Normal file
View File

Binary file not shown.

BIN
test_conformance/spirv_new/spirv_bin/atomic_dec_global.spv64 Normal file
View File

Binary file not shown.

BIN
test_conformance/spirv_new/spirv_bin/atomic_inc_global.spv32 Normal file
View File

Binary file not shown.

BIN
test_conformance/spirv_new/spirv_bin/atomic_inc_global.spv64 Normal file
View File

Binary file not shown.

Some files were not shown because too many files have changed in this diff Show More