341 lines
11 KiB
C++
341 lines
11 KiB
C++
//
|
|
// Copyright (c) 2017 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 "harness/os_helpers.h"
|
|
|
|
const char *define_kernel_code[] = {
|
|
" #define VALUE\n"
|
|
"__kernel void define_test(__global int *src, __global int *dstA, __global int *dstB)\n"
|
|
"{\n"
|
|
" int tid = get_global_id(0);\n"
|
|
"#ifdef VALUE\n"
|
|
" dstA[tid] = src[tid] * 2;\n"
|
|
"#else\n"
|
|
" dstA[tid] = src[tid] * 4;\n"
|
|
"#endif\n"
|
|
"\n"
|
|
"#undef VALUE\n"
|
|
"#ifdef VALUE\n"
|
|
" dstB[tid] = src[tid] * 2;\n"
|
|
"#else\n"
|
|
" dstB[tid] = src[tid] * 4;\n"
|
|
"#endif\n"
|
|
"\n"
|
|
"}\n"};
|
|
|
|
|
|
|
|
|
|
int test_preprocessor_define_udef(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) {
|
|
|
|
cl_int error;
|
|
clKernelWrapper kernel;
|
|
clProgramWrapper program;
|
|
clMemWrapper buffer[3];
|
|
cl_int *srcData, *resultData;
|
|
int i;
|
|
MTdata d;
|
|
|
|
error = create_single_kernel_helper(context, &program, &kernel, 1, define_kernel_code, "define_test");
|
|
if (error)
|
|
return -1;
|
|
|
|
buffer[0] = clCreateBuffer(context, CL_MEM_READ_WRITE, num_elements*sizeof(cl_int), NULL, &error);
|
|
test_error( error, "clCreateBuffer failed");
|
|
buffer[1] = clCreateBuffer(context, CL_MEM_READ_WRITE, num_elements*sizeof(cl_int), NULL, &error);
|
|
test_error( error, "clCreateBuffer failed");
|
|
buffer[2] = clCreateBuffer(context, CL_MEM_READ_WRITE, num_elements*sizeof(cl_int), NULL, &error);
|
|
test_error( error, "clCreateBuffer failed");
|
|
|
|
srcData = (cl_int*)malloc(sizeof(cl_int)*num_elements);
|
|
if (srcData == NULL) {
|
|
log_error("Failed to allocate storage for source data (%d cl_ints).\n", num_elements);
|
|
return -1;
|
|
}
|
|
|
|
d = init_genrand( gRandomSeed );
|
|
for (i=0; i<num_elements; i++)
|
|
srcData[i] = (int)get_random_float(-1024, 1024,d);
|
|
free_mtdata(d); d = NULL;
|
|
|
|
resultData = (cl_int*)malloc(sizeof(cl_int)*num_elements);
|
|
if (resultData == NULL) {
|
|
free(srcData);
|
|
log_error("Failed to allocate storage for result data (%d cl_ints).\n", num_elements);
|
|
return -1;
|
|
}
|
|
|
|
error = clSetKernelArg(kernel, 0, sizeof(buffer[0]), &buffer[0]);
|
|
test_error(error, "clSetKernelArg failed");
|
|
error = clSetKernelArg(kernel, 1, sizeof(buffer[1]), &buffer[1]);
|
|
test_error(error, "clSetKernelArg failed");
|
|
error = clSetKernelArg(kernel, 2, sizeof(buffer[2]), &buffer[2]);
|
|
test_error(error, "clSetKernelArg failed");
|
|
|
|
|
|
error = clEnqueueWriteBuffer(queue, buffer[0], CL_TRUE, 0, num_elements*sizeof(cl_int), srcData, 0, NULL, NULL);
|
|
test_error(error, "clEnqueueWriteBuffer failed");
|
|
|
|
size_t threads[3] = {num_elements, 0, 0};
|
|
error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads, NULL, 0, NULL, NULL);
|
|
test_error(error, "clEnqueueNDRangeKernel failed");
|
|
|
|
error = clEnqueueReadBuffer(queue, buffer[1], CL_TRUE, 0, num_elements*sizeof(cl_int), resultData, 0, NULL, NULL);
|
|
test_error(error, "clEnqueueReadBuffer failed");
|
|
|
|
for (i=0; i<num_elements; i++)
|
|
if (resultData[i] != srcData[i]*2) {
|
|
free(srcData);
|
|
free(resultData);
|
|
return -1;
|
|
}
|
|
|
|
error = clEnqueueReadBuffer(queue, buffer[2], CL_TRUE, 0, num_elements*sizeof(cl_int), resultData, 0, NULL, NULL);
|
|
test_error(error, "clEnqueueReadBuffer failed");
|
|
|
|
for (i=0; i<num_elements; i++)
|
|
if (resultData[i] != srcData[i]*4) {
|
|
free(srcData);
|
|
free(resultData);
|
|
return -1;
|
|
}
|
|
|
|
free(srcData);
|
|
free(resultData);
|
|
return 0;
|
|
}
|
|
|
|
|
|
const char *include_kernel_code =
|
|
"#include \"%s\"\n"
|
|
"__kernel void include_test(__global int *src, __global int *dstA)\n"
|
|
"{\n"
|
|
" int tid = get_global_id(0);\n"
|
|
"#ifdef HEADER_FOUND\n"
|
|
" dstA[tid] = HEADER_FOUND;\n"
|
|
"#else\n"
|
|
" dstA[tid] = 0;\n"
|
|
"#endif\n"
|
|
"\n"
|
|
"}\n";
|
|
|
|
|
|
int test_preprocessor_include(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) {
|
|
|
|
cl_int error;
|
|
clKernelWrapper kernel;
|
|
clProgramWrapper program;
|
|
clMemWrapper buffer[2];
|
|
cl_int *resultData;
|
|
int i;
|
|
|
|
char include_dir[4096] = {0};
|
|
char include_kernel[4096] = {0};
|
|
|
|
char const * sep = get_dir_sep();
|
|
char const * path = get_exe_dir();
|
|
|
|
/* Build with the include directory defined */
|
|
sprintf(include_dir,"%s%sincludeTestDirectory%stestIncludeFile.h", path, sep, sep);
|
|
sprintf(include_kernel, include_kernel_code, include_dir);
|
|
free( (void *) sep );
|
|
free( (void *) path );
|
|
|
|
const char* test_kernel[] = { include_kernel, 0 };
|
|
error = create_single_kernel_helper(context, &program, &kernel, 1, test_kernel, "include_test");
|
|
if (error)
|
|
return -1;
|
|
|
|
buffer[0] = clCreateBuffer(context, CL_MEM_READ_WRITE, num_elements*sizeof(cl_int), NULL, &error);
|
|
test_error( error, "clCreateBuffer failed");
|
|
buffer[1] = clCreateBuffer(context, CL_MEM_READ_WRITE, num_elements*sizeof(cl_int), NULL, &error);
|
|
test_error( error, "clCreateBuffer failed");
|
|
|
|
resultData = (cl_int*)malloc(sizeof(cl_int)*num_elements);
|
|
if (resultData == NULL) {
|
|
log_error("Failed to allocate storage for result data (%d cl_ints).\n", num_elements);
|
|
return -1;
|
|
}
|
|
|
|
error = clSetKernelArg(kernel, 0, sizeof(buffer[0]), &buffer[0]);
|
|
test_error(error, "clSetKernelArg failed");
|
|
error = clSetKernelArg(kernel, 1, sizeof(buffer[1]), &buffer[1]);
|
|
test_error(error, "clSetKernelArg failed");
|
|
|
|
size_t threads[3] = {num_elements, 0, 0};
|
|
error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads, NULL, 0, NULL, NULL);
|
|
test_error(error, "clEnqueueNDRangeKernel failed");
|
|
|
|
error = clEnqueueReadBuffer(queue, buffer[1], CL_TRUE, 0, num_elements*sizeof(cl_int), resultData, 0, NULL, NULL);
|
|
test_error(error, "clEnqueueReadBuffer failed");
|
|
|
|
for (i=0; i<num_elements; i++)
|
|
if (resultData[i] != 12) {
|
|
free(resultData);
|
|
return -1;
|
|
}
|
|
|
|
free(resultData);
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *line_error_kernel_code[] = {
|
|
"__kernel void line_error_test(__global int *dstA)\n"
|
|
"{\n"
|
|
" int tid = get_global_id(0);\n"
|
|
"#line 124 \"fictitious/file/name.c\" \n"
|
|
"#error some error\n"
|
|
" dstA[tid] = tid;\n"
|
|
"\n"
|
|
"}\n"};
|
|
|
|
|
|
int test_preprocessor_line_error(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) {
|
|
|
|
cl_int error, error2;
|
|
clKernelWrapper kernel;
|
|
clProgramWrapper program;
|
|
clMemWrapper buffer[2];
|
|
|
|
char buildLog[ 1024 * 128 ];
|
|
|
|
log_info("test_preprocessor_line_error may report spurious ERRORS in the conformance log.\n");
|
|
|
|
/* Create the program object from source */
|
|
program = clCreateProgramWithSource( context, 1, line_error_kernel_code, NULL, &error );
|
|
test_error(error, "clCreateProgramWithSource failed");
|
|
|
|
/* Compile the program */
|
|
error2 = clBuildProgram( program, 0, NULL, NULL, NULL, NULL );
|
|
if (error2) {
|
|
log_info("Build error detected at clBuildProgram.");
|
|
} else {
|
|
log_info("Error not reported by clBuildProgram.\n");
|
|
}
|
|
|
|
cl_build_status status;
|
|
error = clGetProgramBuildInfo(program, deviceID, CL_PROGRAM_BUILD_STATUS, sizeof(status), &status, NULL);
|
|
test_error(error, "clGetProgramBuildInfo failed for CL_PROGRAM_BUILD_STATUS");
|
|
if (status != CL_BUILD_ERROR) {
|
|
log_error("Build status did not return CL_BUILD_ERROR for a program with #error defined.\n");
|
|
return -1;
|
|
} else if (status == CL_BUILD_ERROR || error2) {
|
|
error2 = clGetProgramBuildInfo( program, deviceID, CL_PROGRAM_BUILD_LOG, sizeof( buildLog ), buildLog, NULL );
|
|
test_error( error2, "Unable to get program build log" );
|
|
|
|
log_info("Build failed as expected with #error in source:\n");
|
|
log_info( "Build log is: ------------\n" );
|
|
log_info( "%s\n", buildLog );
|
|
log_info( "Original source is: ------------\n" );
|
|
log_info( "%s", line_error_kernel_code[0] );
|
|
log_info( "\n----------\n" );
|
|
|
|
if (strstr(buildLog, "fictitious/file/name.c")) {
|
|
log_info("Found file name from #line param in log output.\n");
|
|
} else {
|
|
log_info("WARNING: Did not find file name from #line param in log output.\n");
|
|
}
|
|
|
|
if (strstr(buildLog, "124")) {
|
|
log_info("Found line number from #line param in log output.\n");
|
|
} else {
|
|
log_info("WARNING: Did not find line number from #line param in log output.\n");
|
|
}
|
|
|
|
log_info("test_preprocessor_line_error PASSED.\n");
|
|
return 0;
|
|
}
|
|
|
|
/* And create a kernel from it */
|
|
kernel = clCreateKernel( program, "line_error_test", &error );
|
|
test_error(error, "clCreateKernel failed");
|
|
|
|
buffer[0] = clCreateBuffer(context, CL_MEM_READ_WRITE, num_elements*sizeof(cl_int), NULL, &error);
|
|
test_error( error, "clCreateBuffer failed");
|
|
|
|
error = clSetKernelArg(kernel, 0, sizeof(buffer[0]), &buffer[0]);
|
|
test_error(error, "clSetKernelArg failed");
|
|
|
|
size_t threads[3] = {num_elements, 0, 0};
|
|
error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads, NULL, 0, NULL, NULL);
|
|
test_error(error, "clEnqueueNDRangeKernel failed");
|
|
|
|
log_error("Program built and ran with #error defined.");
|
|
return -1;
|
|
}
|
|
|
|
|
|
|
|
const char *pragma_kernel_code[] = {
|
|
"__kernel void pragma_test(__global int *dstA)\n"
|
|
"{\n"
|
|
"#pragma A fool thinks himself to be wise, but a wise man knows himself to be a fool.\n"
|
|
" int tid = get_global_id(0);\n"
|
|
"#pragma\n"
|
|
" dstA[tid] = tid;\n"
|
|
"#pragma mark Though I am not naturally honest, I am so sometimes by chance.\n"
|
|
"\n"
|
|
"}\n"};
|
|
|
|
|
|
int test_preprocessor_pragma(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) {
|
|
|
|
cl_int error;
|
|
clKernelWrapper kernel;
|
|
clProgramWrapper program;
|
|
clMemWrapper buffer[2];
|
|
cl_int *resultData;
|
|
int i;
|
|
|
|
error = create_single_kernel_helper(context, &program, &kernel, 1, pragma_kernel_code, "pragma_test");
|
|
if (error)
|
|
return -1;
|
|
|
|
buffer[0] = clCreateBuffer(context, CL_MEM_READ_WRITE, num_elements*sizeof(cl_int), NULL, &error);
|
|
test_error( error, "clCreateBuffer failed");
|
|
|
|
error = clSetKernelArg(kernel, 0, sizeof(buffer[0]), &buffer[0]);
|
|
test_error(error, "clSetKernelArg failed");
|
|
|
|
size_t threads[3] = {num_elements, 0, 0};
|
|
error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, threads, NULL, 0, NULL, NULL);
|
|
test_error(error, "clEnqueueNDRangeKernel failed");
|
|
|
|
resultData = (cl_int*)malloc(sizeof(cl_int)*num_elements);
|
|
if (resultData == NULL) {
|
|
log_error("Failed to allocate storage for result data (%d cl_ints).\n", num_elements);
|
|
return -1;
|
|
}
|
|
|
|
error = clEnqueueReadBuffer(queue, buffer[0], CL_TRUE, 0, num_elements*sizeof(cl_int), resultData, 0, NULL, NULL);
|
|
test_error(error, "clEnqueueReadBuffer failed");
|
|
|
|
for (i=0; i<num_elements; i++)
|
|
if (resultData[i] != i) {
|
|
free(resultData);
|
|
return -1;
|
|
}
|
|
|
|
free(resultData);
|
|
return 0;
|
|
}
|
|
|
|
|
|
|