mirror of
https://github.com/KhronosGroup/OpenCL-CTS.git
synced 2026-03-19 14:09:03 +00:00
d8733efc0f
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>
1681 lines
64 KiB
C
1681 lines
64 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 <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <math.h>
|
|
#include <string.h>
|
|
|
|
#if !defined(_WIN32)
|
|
#include <stdbool.h>
|
|
#endif
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include "procs.h"
|
|
#include "../../test_common/harness/conversions.h"
|
|
|
|
extern MTdata d;
|
|
|
|
// The tests we are running
|
|
const char *tests[] = {
|
|
"+",
|
|
"-",
|
|
"*",
|
|
"/",
|
|
"%",
|
|
"&",
|
|
"|",
|
|
"^",
|
|
">>",
|
|
"<<",
|
|
">>",
|
|
"<<",
|
|
"~",
|
|
"?:",
|
|
"&&",
|
|
"||",
|
|
"<",
|
|
">",
|
|
"<=",
|
|
">=",
|
|
"==",
|
|
"!=",
|
|
"!",
|
|
};
|
|
|
|
// The names of the tests
|
|
const char *test_names[] = {
|
|
"+", // 0
|
|
"-", // 1
|
|
"*", // 2
|
|
"/", // 3
|
|
"%", // 4
|
|
"&", // 5
|
|
"|", // 6
|
|
"^", // 7
|
|
">> by vector", // 8
|
|
"<< by vector", // 9
|
|
">> by scalar", // 10
|
|
"<< by scalar", // 11
|
|
"~", // 12
|
|
"?:", // 13
|
|
"&&", // 14
|
|
"||", // 15
|
|
"<", // 16
|
|
">", // 17
|
|
"<=", // 18
|
|
">=", // 19
|
|
"==", // 20
|
|
"!=", // 21
|
|
"!", // 22
|
|
};
|
|
|
|
const size_t vector_aligns[] = {0, 1, 2, 4, 4,
|
|
8, 8, 8, 8,
|
|
16, 16, 16, 16,
|
|
16, 16, 16, 16};
|
|
|
|
// =======================================
|
|
// long
|
|
// =======================================
|
|
int
|
|
verify_long(int test, size_t vector_size, cl_long *inptrA, cl_long *inptrB, cl_long *outptr, size_t n)
|
|
{
|
|
cl_long r, shift_mask = (sizeof(cl_long)*8)-1;
|
|
size_t i, j;
|
|
int count=0;
|
|
|
|
for (j=0; j<n; j += vector_size )
|
|
{
|
|
for( i = j; i < j + vector_size; i++ )
|
|
{
|
|
switch (test) {
|
|
case 0:
|
|
r = inptrA[i] + inptrB[i];
|
|
break;
|
|
case 1:
|
|
r = inptrA[i] - inptrB[i];
|
|
break;
|
|
case 2:
|
|
r = inptrA[i] * inptrB[i];
|
|
break;
|
|
case 3:
|
|
if (inptrB[i] == 0 || (inptrB[i] == -1 && inptrA[i] == CL_LONG_MIN))
|
|
continue;
|
|
else
|
|
r = inptrA[i] / inptrB[i];
|
|
break;
|
|
case 4:
|
|
if (inptrB[i] == 0 || (inptrB[i] == -1 && inptrA[i] == CL_LONG_MIN))
|
|
continue;
|
|
else
|
|
r = inptrA[i] % inptrB[i];
|
|
break;
|
|
case 5:
|
|
r = inptrA[i] & inptrB[i];
|
|
break;
|
|
case 6:
|
|
r = inptrA[i] | inptrB[i];
|
|
break;
|
|
case 7:
|
|
r = inptrA[i] ^ inptrB[i];
|
|
break;
|
|
case 8:
|
|
r = inptrA[i] >> (inptrB[i] & shift_mask);
|
|
break;
|
|
case 9:
|
|
r = inptrA[i] << (inptrB[i] & shift_mask);
|
|
break;
|
|
case 10:
|
|
r = inptrA[i] >> (inptrB[j] & shift_mask);
|
|
break;
|
|
case 11:
|
|
r = inptrA[i] << (inptrB[j] & shift_mask);
|
|
break;
|
|
case 12:
|
|
r = ~inptrA[i];
|
|
break;
|
|
case 13:
|
|
r = (inptrA[j] < inptrB[j]) ? inptrA[i] : inptrB[i];
|
|
break;
|
|
case 14:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] && inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 15:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] || inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 16:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] < inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 17:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] > inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 18:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] <= inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 19:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] >= inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 20:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] == inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 21:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] != inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 22:
|
|
// Scalars are set to 1/0
|
|
r = !inptrA[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
default:
|
|
log_error("Invalid test: %d\n", test);
|
|
return -1;
|
|
break;
|
|
}
|
|
if (r != outptr[i]) {
|
|
// Shift is tricky
|
|
if (test == 8 || test == 9) {
|
|
log_error("cl_long Verification failed at element %ld of %ld : 0x%llx %s 0x%llx = 0x%llx, got 0x%llx\n", i, n, inptrA[i], tests[test], inptrB[i], r, outptr[i]);
|
|
log_error("\t1) Vector shift failure at element %ld: original is 0x%llx %s %d (0x%llx)\n", i, inptrA[i], tests[test], (int)inptrB[i], inptrB[i]);
|
|
log_error("\t2) Take the %d LSBs of the shift to get the final shift amount %lld (0x%llx).\n", (int)log2(sizeof(cl_long)*8), inptrB[i]&shift_mask, inptrB[i]&shift_mask);
|
|
}
|
|
else if (test == 10 || test == 11) {
|
|
|
|
log_error("cl_long Verification failed at element %ld of %ld (%ld): 0x%llx %s 0x%llx = 0x%llx, got 0x%llx\n", i, n, j, inptrA[i], tests[test], inptrB[j], r, outptr[i]);
|
|
log_error("\t1) Scalar shift failure at element %ld: original is 0x%llx %s %d (0x%llx)\n", i, inptrA[i], tests[test], (int)inptrB[j], inptrB[j]);
|
|
log_error("\t2) Take the %d LSBs of the shift to get the final shift amount %lld (0x%llx).\n", (int)log2(sizeof(cl_long)*8), inptrB[j]&shift_mask, inptrB[j]&shift_mask);
|
|
} else if (test == 13) {
|
|
log_error("cl_int Verification failed at element %ld (%ld): (0x%llx < 0x%llx) ? 0x%llx : 0x%llx = 0x%llx, got 0x%llx\n", i, j, inptrA[j], inptrB[j],
|
|
inptrA[i], inptrB[i], r, outptr[i]);
|
|
} else {
|
|
log_error("cl_long Verification failed at element %ld of %ld: 0x%llx %s 0x%llx = 0x%llx, got 0x%llx\n", i, n, inptrA[i], tests[test], inptrB[i], r, outptr[i]);
|
|
}
|
|
count++;
|
|
if (count >= MAX_ERRORS_TO_PRINT) {
|
|
log_error("Further errors ignored.\n");
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (count) return -1; else return 0;
|
|
}
|
|
|
|
void
|
|
init_long_data(uint64_t indx, int num_elements, cl_long *input_ptr[], MTdata d)
|
|
{
|
|
cl_ulong *p = (cl_ulong *)input_ptr[0];
|
|
int j;
|
|
|
|
if (indx == 0) {
|
|
// Do the tricky values the first time around
|
|
fill_test_values( input_ptr[ 0 ], input_ptr[ 1 ], (size_t)num_elements, d );
|
|
} else {
|
|
// Then just test lots of random ones.
|
|
for (j=0; j<num_elements; j++) {
|
|
cl_uint a = (cl_uint)genrand_int32(d);
|
|
cl_uint b = (cl_uint)genrand_int32(d);
|
|
p[j] = ((cl_ulong)a <<32 | b);
|
|
}
|
|
p = (cl_ulong *)input_ptr[1];
|
|
for (j=0; j<num_elements; j++) {
|
|
cl_uint a = (cl_uint)genrand_int32(d);
|
|
cl_uint b = (cl_uint)genrand_int32(d);
|
|
p[j] = ((cl_ulong)a <<32 | b);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// =======================================
|
|
// ulong
|
|
// =======================================
|
|
int
|
|
verify_ulong(int test, size_t vector_size, cl_ulong *inptrA, cl_ulong *inptrB, cl_ulong *outptr, size_t n)
|
|
{
|
|
cl_ulong r, shift_mask = (sizeof(cl_ulong)*8)-1;
|
|
size_t i, j;
|
|
int count=0;
|
|
|
|
for (j=0; j<n; j += vector_size )
|
|
{
|
|
for( i = j; i < j + vector_size; i++ )
|
|
{
|
|
switch (test) {
|
|
case 0:
|
|
r = inptrA[i] + inptrB[i];
|
|
break;
|
|
case 1:
|
|
r = inptrA[i] - inptrB[i];
|
|
break;
|
|
case 2:
|
|
r = inptrA[i] * inptrB[i];
|
|
break;
|
|
case 3:
|
|
if (inptrB[i] == 0)
|
|
continue;
|
|
else
|
|
r = inptrA[i] / inptrB[i];
|
|
break;
|
|
case 4:
|
|
if (inptrB[i] == 0)
|
|
continue;
|
|
else
|
|
r = inptrA[i] % inptrB[i];
|
|
break;
|
|
case 5:
|
|
r = inptrA[i] & inptrB[i];
|
|
break;
|
|
case 6:
|
|
r = inptrA[i] | inptrB[i];
|
|
break;
|
|
case 7:
|
|
r = inptrA[i] ^ inptrB[i];
|
|
break;
|
|
case 8:
|
|
r = inptrA[i] >> (inptrB[i] & shift_mask);
|
|
break;
|
|
case 9:
|
|
r = inptrA[i] << (inptrB[i] & shift_mask);
|
|
break;
|
|
case 10:
|
|
r = inptrA[i] >> (inptrB[j] & shift_mask);
|
|
break;
|
|
case 11:
|
|
r = inptrA[i] << (inptrB[j] & shift_mask);
|
|
break;
|
|
case 12:
|
|
r = ~inptrA[i];
|
|
break;
|
|
case 13:
|
|
r = (inptrA[j] < inptrB[j]) ? inptrA[i] : inptrB[i];
|
|
break;
|
|
case 14:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] && inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 15:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] || inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 16:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] < inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 17:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] > inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 18:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] <= inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 19:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] >= inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 20:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] == inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 21:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] != inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 22:
|
|
// Scalars are set to 1/0
|
|
r = !inptrA[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
default:
|
|
log_error("Invalid test: %d\n", test);
|
|
return -1;
|
|
break;
|
|
}
|
|
if (r != outptr[i]) {
|
|
// Shift is tricky
|
|
if (test == 8 || test == 9) {
|
|
log_error("cl_ulong Verification failed at element %ld of %ld: 0x%llx %s 0x%llx = 0x%llx, got 0x%llx\n", i, n, inptrA[i], tests[test], inptrB[i], r, outptr[i]);
|
|
log_error("\t1) Shift failure at element %ld: original is 0x%llx %s %d (0x%llx)\n", i, inptrA[i], tests[test], (int)inptrB[i], inptrB[i]);
|
|
log_error("\t2) Take the %d LSBs of the shift to get the final shift amount %llu (0x%llx).\n", (int)log2(sizeof(cl_ulong)*8), inptrB[i]&shift_mask, inptrB[i]&shift_mask);
|
|
}
|
|
else if (test == 10 || test == 11) {
|
|
log_error("cl_ulong Verification failed at element %ld of %ld (%ld): 0x%llx %s 0x%llx = 0x%llx, got 0x%llx\n", i, n, j, inptrA[i], tests[test], inptrB[j], r, outptr[i]);
|
|
log_error("\t1) Scalar shift failure at element %ld: original is 0x%llx %s %d (0x%llx)\n", i, inptrA[i], tests[test], (int)inptrB[j], inptrB[j]);
|
|
log_error("\t2) Take the %d LSBs of the shift to get the final shift amount %lld (0x%llx).\n", (int)log2(sizeof(cl_long)*8), inptrB[j]&shift_mask, inptrB[j]&shift_mask);
|
|
} else if (test == 13) {
|
|
log_error("cl_int Verification failed at element %ld of %ld (%ld): (0x%llx < 0x%llx) ? 0x%llx : 0x%llx = 0x%llx, got 0x%llx\n", i, n, j, inptrA[j], inptrB[j],
|
|
inptrA[i], inptrB[i], r, outptr[i]);
|
|
} else {
|
|
log_error("cl_ulong Verification failed at element %ld of %ld: 0x%llx %s 0x%llx = 0x%llx, got 0x%llx\n", i, n, inptrA[i], tests[test], inptrB[i], r, outptr[i]);
|
|
}
|
|
count++;
|
|
if (count >= MAX_ERRORS_TO_PRINT) {
|
|
log_error("Further errors ignored.\n");
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (count) return -1; else return 0;
|
|
}
|
|
|
|
void
|
|
init_ulong_data(uint64_t indx, int num_elements, cl_ulong *input_ptr[], MTdata d)
|
|
{
|
|
cl_ulong *p = (cl_ulong *)input_ptr[0];
|
|
int j;
|
|
|
|
if (indx == 0)
|
|
{
|
|
// Do the tricky values the first time around
|
|
fill_test_values( (cl_long*)input_ptr[ 0 ], (cl_long*)input_ptr[ 1 ], (size_t)num_elements, d );
|
|
}
|
|
else
|
|
{
|
|
// Then just test lots of random ones.
|
|
for (j=0; j<num_elements; j++)
|
|
{
|
|
cl_ulong a = genrand_int32(d);
|
|
cl_ulong b = genrand_int32(d);
|
|
// Fill in the top, bottom, and middle, remembering that random only sets 31 bits.
|
|
p[j] = (a <<32) | b;
|
|
}
|
|
p = (cl_ulong *)input_ptr[1];
|
|
for (j=0; j<num_elements; j++)
|
|
{
|
|
cl_ulong a = genrand_int32(d);
|
|
cl_ulong b = genrand_int32(d);
|
|
// Fill in the top, bottom, and middle, remembering that random only sets 31 bits.
|
|
p[j] = (a <<32) | b;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// =======================================
|
|
// int
|
|
// =======================================
|
|
int
|
|
verify_int(int test, size_t vector_size, cl_int *inptrA, cl_int *inptrB, cl_int *outptr, size_t n)
|
|
{
|
|
cl_int r, shift_mask = (sizeof(cl_int)*8)-1;
|
|
size_t i, j;
|
|
int count=0;
|
|
|
|
for (j=0; j<n; j += vector_size )
|
|
{
|
|
for( i = j; i < j + vector_size; i++ )
|
|
{
|
|
switch (test) {
|
|
case 0:
|
|
r = inptrA[i] + inptrB[i];
|
|
break;
|
|
case 1:
|
|
r = inptrA[i] - inptrB[i];
|
|
break;
|
|
case 2:
|
|
r = inptrA[i] * inptrB[i];
|
|
break;
|
|
case 3:
|
|
if (inptrB[i] == 0 || (inptrB[i] == -1 && inptrA[i] == CL_INT_MIN))
|
|
continue;
|
|
else
|
|
r = inptrA[i] / inptrB[i];
|
|
break;
|
|
case 4:
|
|
if (inptrB[i] == 0 || (inptrB[i] == -1 && inptrA[i] == CL_INT_MIN))
|
|
continue;
|
|
else
|
|
r = inptrA[i] % inptrB[i];
|
|
break;
|
|
case 5:
|
|
r = inptrA[i] & inptrB[i];
|
|
break;
|
|
case 6:
|
|
r = inptrA[i] | inptrB[i];
|
|
break;
|
|
case 7:
|
|
r = inptrA[i] ^ inptrB[i];
|
|
break;
|
|
case 8:
|
|
r = inptrA[i] >> (inptrB[i] & shift_mask);
|
|
break;
|
|
case 9:
|
|
r = inptrA[i] << (inptrB[i] & shift_mask);
|
|
break;
|
|
case 10:
|
|
r = inptrA[i] >> (inptrB[j] & shift_mask);
|
|
break;
|
|
case 11:
|
|
r = inptrA[i] << (inptrB[j] & shift_mask);
|
|
break;
|
|
case 12:
|
|
r = ~inptrA[i];
|
|
break;
|
|
case 13:
|
|
r = (inptrA[j] < inptrB[j]) ? inptrA[i] : inptrB[i];
|
|
break;
|
|
case 14:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] && inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 15:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] || inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 16:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] < inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 17:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] > inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 18:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] <= inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 19:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] >= inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 20:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] == inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 21:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] != inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 22:
|
|
// Scalars are set to 1/0
|
|
r = !inptrA[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
default:
|
|
log_error("Invalid test: %d\n", test);
|
|
return -1;
|
|
break;
|
|
}
|
|
if (r != outptr[i]) {
|
|
// Shift is tricky
|
|
if (test == 8 || test == 9) {
|
|
log_error("cl_int Verification failed at element %ld: 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, inptrA[i], tests[test], inptrB[i], r, outptr[i]);
|
|
log_error("\t1) Shift failure at element %ld: original is 0x%x %s %d (0x%x)\n", i, inptrA[i], tests[test], (int)inptrB[i], inptrB[i]);
|
|
log_error("\t2) Take the %d LSBs of the shift to get the final shift amount %d (0x%x).\n", (int)log2(sizeof(cl_int)*8), inptrB[i]&shift_mask, inptrB[i]&shift_mask);
|
|
}
|
|
else if (test == 10 || test == 11) {
|
|
log_error("cl_int Verification failed at element %ld (%ld): 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, j, inptrA[i], tests[test], inptrB[j], r, outptr[i]);
|
|
log_error("\t1) Scalar shift failure at element %ld: original is 0x%x %s %d (0x%x)\n", i, inptrA[i], tests[test], (int)inptrB[j], inptrB[j]);
|
|
log_error("\t2) Take the %d LSBs of the shift to get the final shift amount %d (0x%x).\n", (int)log2(sizeof(cl_int)*8), inptrB[j]&shift_mask, inptrB[j]&shift_mask);
|
|
} else if (test == 13) {
|
|
log_error("cl_int Verification failed at element %ld (%ld): (0x%x < 0x%x) ? 0x%x : 0x%x = 0x%x, got 0x%x\n", i, j, inptrA[j], inptrB[j],
|
|
inptrA[i], inptrB[i], r, outptr[i]);
|
|
} else {
|
|
log_error("cl_int Verification failed at element %ld: 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, inptrA[i], tests[test], inptrB[i], r, outptr[i]);
|
|
}
|
|
count++;
|
|
if (count >= MAX_ERRORS_TO_PRINT) {
|
|
log_error("Further errors ignored.\n");
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (count) return -1; else return 0;
|
|
}
|
|
|
|
void
|
|
init_int_data(uint64_t indx, int num_elements, cl_int *input_ptr[], MTdata d)
|
|
{
|
|
static const cl_int specialCaseList[] = { 0, -1, 1, CL_INT_MIN, CL_INT_MIN + 1, CL_INT_MAX };
|
|
int j;
|
|
|
|
// Set the inputs to a random number
|
|
for (j=0; j<num_elements; j++)
|
|
{
|
|
((cl_int *)input_ptr[0])[j] = (cl_int)genrand_int32(d);
|
|
((cl_int *)input_ptr[1])[j] = (cl_int)genrand_int32(d);
|
|
}
|
|
|
|
// Init the first few values to test special cases
|
|
{
|
|
size_t x, y, index = 0;
|
|
for( x = 0; x < sizeof( specialCaseList ) / sizeof( specialCaseList[0] ); x++ )
|
|
for( y = 0; y < sizeof( specialCaseList ) / sizeof( specialCaseList[0] ); y++ )
|
|
{
|
|
((cl_int *)input_ptr[0])[index] = specialCaseList[x];
|
|
((cl_int *)input_ptr[1])[index++] = specialCaseList[y];
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// =======================================
|
|
// uint
|
|
// =======================================
|
|
int
|
|
verify_uint(int test, size_t vector_size, cl_uint *inptrA, cl_uint *inptrB, cl_uint *outptr, size_t n)
|
|
{
|
|
cl_uint r, shift_mask = (sizeof(cl_uint)*8)-1;
|
|
size_t i, j;
|
|
int count=0;
|
|
|
|
for (j=0; j<n; j += vector_size )
|
|
{
|
|
for( i = j; i < j + vector_size; i++ )
|
|
{
|
|
switch (test) {
|
|
case 0:
|
|
r = inptrA[i] + inptrB[i];
|
|
break;
|
|
case 1:
|
|
r = inptrA[i] - inptrB[i];
|
|
break;
|
|
case 2:
|
|
r = inptrA[i] * inptrB[i];
|
|
break;
|
|
case 3:
|
|
if (inptrB[i] == 0)
|
|
continue;
|
|
else
|
|
r = inptrA[i] / inptrB[i];
|
|
break;
|
|
case 4:
|
|
if (inptrB[i] == 0)
|
|
continue;
|
|
else
|
|
r = inptrA[i] % inptrB[i];
|
|
break;
|
|
case 5:
|
|
r = inptrA[i] & inptrB[i];
|
|
break;
|
|
case 6:
|
|
r = inptrA[i] | inptrB[i];
|
|
break;
|
|
case 7:
|
|
r = inptrA[i] ^ inptrB[i];
|
|
break;
|
|
case 8:
|
|
r = inptrA[i] >> (inptrB[i] & shift_mask);
|
|
break;
|
|
case 9:
|
|
r = inptrA[i] << (inptrB[i] & shift_mask);
|
|
break;
|
|
case 10:
|
|
r = inptrA[i] >> (inptrB[j] & shift_mask);
|
|
break;
|
|
case 11:
|
|
r = inptrA[i] << (inptrB[j] & shift_mask);
|
|
break;
|
|
case 12:
|
|
r = ~inptrA[i];
|
|
break;
|
|
case 13:
|
|
r = (inptrA[j] < inptrB[j]) ? inptrA[i] : inptrB[i];
|
|
break;
|
|
case 14:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] && inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 15:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] || inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 16:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] < inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 17:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] > inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 18:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] <= inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 19:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] >= inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 20:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] == inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 21:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] != inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 22:
|
|
// Scalars are set to 1/0
|
|
r = !inptrA[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
default:
|
|
log_error("Invalid test: %d\n", test);
|
|
return -1;
|
|
break;
|
|
}
|
|
if (r != outptr[i]) {
|
|
// Shift is tricky
|
|
if (test == 8 || test == 9) {
|
|
log_error("cl_uint Verification failed at element %ld: 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, inptrA[i], tests[test], inptrB[i], r, outptr[i]);
|
|
log_error("\t1) Shift failure at element %ld: original is 0x%x %s %d (0x%x)\n", i, inptrA[i], tests[test], (int)inptrB[i], inptrB[i]);
|
|
log_error("\t2) Take the %d LSBs of the shift to get the final shift amount %d (0x%x).\n", (int)log2(sizeof(cl_uint)*8), inptrB[i]&shift_mask, inptrB[i]&shift_mask);
|
|
}
|
|
else if (test == 10 || test == 11) {
|
|
log_error("cl_uint Verification failed at element %ld (%ld): 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, j, inptrA[i], tests[test], inptrB[j], r, outptr[i]);
|
|
log_error("\t1) Scalar shift failure at element %ld: original is 0x%x %s %d (0x%x)\n", i, inptrA[i], tests[test], (int)inptrB[j], inptrB[j]);
|
|
log_error("\t2) Take the %d LSBs of the shift to get the final shift amount %d (0x%x).\n", (int)log2(sizeof(cl_uint)*8), inptrB[j]&shift_mask, inptrB[j]&shift_mask);
|
|
} else if (test == 13) {
|
|
log_error("cl_int Verification failed at element %ld (%ld): (0x%x < 0x%x) ? 0x%x : 0x%x = 0x%x, got 0x%x\n", i, j, inptrA[j], inptrB[j],
|
|
inptrA[i], inptrB[i], r, outptr[i]);
|
|
} else {
|
|
log_error("cl_uint Verification failed at element %ld: 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, inptrA[i], tests[test], inptrB[i], r, outptr[i]);
|
|
}
|
|
count++;
|
|
if (count >= MAX_ERRORS_TO_PRINT) {
|
|
log_error("Further errors ignored.\n");
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (count) return -1; else return 0;
|
|
}
|
|
|
|
void
|
|
init_uint_data(uint64_t indx, int num_elements, cl_uint *input_ptr[], MTdata d)
|
|
{
|
|
static cl_uint specialCaseList[] = { 0, (cl_uint) CL_INT_MAX, (cl_uint) CL_INT_MAX + 1, CL_UINT_MAX-1, CL_UINT_MAX };
|
|
int j;
|
|
|
|
// Set the first input to an incrementing number
|
|
// Set the second input to a random number
|
|
for (j=0; j<num_elements; j++)
|
|
{
|
|
((cl_uint *)input_ptr[0])[j] = genrand_int32(d);
|
|
((cl_uint *)input_ptr[1])[j] = genrand_int32(d);
|
|
}
|
|
|
|
// Init the first few values to test special cases
|
|
{
|
|
size_t x, y, index = 0;
|
|
for( x = 0; x < sizeof( specialCaseList ) / sizeof( specialCaseList[0] ); x++ )
|
|
for( y = 0; y < sizeof( specialCaseList ) / sizeof( specialCaseList[0] ); y++ )
|
|
{
|
|
((cl_uint *)input_ptr[0])[index] = specialCaseList[x];
|
|
((cl_uint *)input_ptr[1])[index++] = specialCaseList[y];
|
|
}
|
|
}
|
|
}
|
|
|
|
// =======================================
|
|
// short
|
|
// =======================================
|
|
int
|
|
verify_short(int test, size_t vector_size, cl_short *inptrA, cl_short *inptrB, cl_short *outptr, size_t n)
|
|
{
|
|
cl_short r;
|
|
cl_int shift_mask = vector_size == 1 ? (cl_int)(sizeof(cl_int)*8)-1
|
|
: (cl_int)(sizeof(cl_short)*8)-1;
|
|
size_t i, j;
|
|
int count=0;
|
|
|
|
for (j=0; j<n; j += vector_size )
|
|
{
|
|
for( i = j; i < j + vector_size; i++ )
|
|
{
|
|
switch (test) {
|
|
case 0:
|
|
r = inptrA[i] + inptrB[i];
|
|
break;
|
|
case 1:
|
|
r = inptrA[i] - inptrB[i];
|
|
break;
|
|
case 2:
|
|
r = inptrA[i] * inptrB[i];
|
|
break;
|
|
case 3:
|
|
if (inptrB[i] == 0 || (inptrB[i] == -1 && inptrA[i] == CL_SHRT_MIN))
|
|
continue;
|
|
else
|
|
r = inptrA[i] / inptrB[i];
|
|
break;
|
|
case 4:
|
|
if (inptrB[i] == 0 || (inptrB[i] == -1 && inptrA[i] == CL_SHRT_MIN))
|
|
continue;
|
|
else
|
|
r = inptrA[i] % inptrB[i];
|
|
break;
|
|
case 5:
|
|
r = inptrA[i] & inptrB[i];
|
|
break;
|
|
case 6:
|
|
r = inptrA[i] | inptrB[i];
|
|
break;
|
|
case 7:
|
|
r = inptrA[i] ^ inptrB[i];
|
|
break;
|
|
case 8:
|
|
r = inptrA[i] >> (inptrB[i] & shift_mask);
|
|
break;
|
|
case 9:
|
|
r = inptrA[i] << (inptrB[i] & shift_mask);
|
|
break;
|
|
case 10:
|
|
r = inptrA[i] >> (inptrB[j] & shift_mask);
|
|
break;
|
|
case 11:
|
|
r = inptrA[i] << (inptrB[j] & shift_mask);
|
|
break;
|
|
case 12:
|
|
r = ~inptrA[i];
|
|
break;
|
|
case 13:
|
|
r = (inptrA[j] < inptrB[j]) ? inptrA[i] : inptrB[i];
|
|
break;
|
|
case 14:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] && inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 15:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] || inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 16:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] < inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 17:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] > inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 18:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] <= inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 19:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] >= inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 20:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] == inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 21:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] != inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 22:
|
|
// Scalars are set to 1/0
|
|
r = !inptrA[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
default:
|
|
log_error("Invalid test: %d\n", test);
|
|
return -1;
|
|
break;
|
|
}
|
|
if (r != outptr[i]) {
|
|
// Shift is tricky
|
|
if (test == 8 || test == 9) {
|
|
log_error("cl_short Verification failed at element %ld: 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, inptrA[i], tests[test], inptrB[i], r, outptr[i]);
|
|
log_error("\t1) Shift failure at element %ld: original is 0x%x %s %d (0x%x)\n", i, inptrA[i], tests[test], (int)inptrB[i], inptrB[i]);
|
|
log_error("\t2) Take the %d LSBs of the shift to get the final shift amount %d (0x%x).\n", (int)log2(sizeof(cl_short)*8), inptrB[i]&shift_mask, inptrB[i]&shift_mask);
|
|
}
|
|
else if (test == 10 || test == 11) {
|
|
log_error("cl_short Verification failed at element %ld (%ld): 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, j, inptrA[i], tests[test], inptrB[j], r, outptr[i]);
|
|
log_error("\t1) Scalar shift failure at element %ld: original is 0x%x %s %d (0x%x)\n", i, inptrA[i], tests[test], (int)inptrB[j], inptrB[j]);
|
|
log_error("\t2) Take the %d LSBs of the shift to get the final shift amount %d (0x%x).\n", (int)log2(sizeof(cl_short)*8), inptrB[j]&shift_mask, inptrB[j]&shift_mask);
|
|
} else if (test == 13) {
|
|
log_error("cl_int Verification failed at element %ld (%ld): (0x%x < 0x%x) ? 0x%x : 0x%x = 0x%x, got 0x%x\n", i, j, inptrA[j], inptrB[j],
|
|
inptrA[i], inptrB[i], r, outptr[i]);
|
|
} else {
|
|
log_error("cl_short Verification failed at element %ld: 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, inptrA[i], tests[test], inptrB[i], r, outptr[i]);
|
|
}
|
|
count++;
|
|
if (count >= MAX_ERRORS_TO_PRINT) {
|
|
log_error("Further errors ignored.\n");
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (count) return -1; else return 0;
|
|
}
|
|
|
|
void
|
|
init_short_data(uint64_t indx, int num_elements, cl_short *input_ptr[], MTdata d)
|
|
{
|
|
static const cl_short specialCaseList[] = { 0, -1, 1, CL_SHRT_MIN, CL_SHRT_MIN + 1, CL_SHRT_MAX };
|
|
int j;
|
|
|
|
// Set the inputs to a random number
|
|
for (j=0; j<num_elements; j++)
|
|
{
|
|
cl_uint bits = genrand_int32(d);
|
|
((cl_short *)input_ptr[0])[j] = (cl_short) bits;
|
|
((cl_short *)input_ptr[1])[j] = (cl_short) (bits >> 16);
|
|
}
|
|
|
|
// Init the first few values to test special cases
|
|
{
|
|
size_t x, y, index = 0;
|
|
for( x = 0; x < sizeof( specialCaseList ) / sizeof( specialCaseList[0] ); x++ )
|
|
for( y = 0; y < sizeof( specialCaseList ) / sizeof( specialCaseList[0] ); y++ )
|
|
{
|
|
((cl_short *)input_ptr[0])[index] = specialCaseList[x];
|
|
((cl_short *)input_ptr[1])[index++] = specialCaseList[y];
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// =======================================
|
|
// ushort
|
|
// =======================================
|
|
int
|
|
verify_ushort(int test, size_t vector_size, cl_ushort *inptrA, cl_ushort *inptrB, cl_ushort *outptr, size_t n)
|
|
{
|
|
cl_ushort r;
|
|
cl_uint shift_mask = vector_size == 1 ? (cl_uint)(sizeof(cl_uint)*8)-1
|
|
: (cl_uint)(sizeof(cl_ushort)*8)-1;
|
|
size_t i, j;
|
|
int count=0;
|
|
|
|
for (j=0; j<n; j += vector_size )
|
|
{
|
|
for( i = j; i < j + vector_size; i++ )
|
|
{
|
|
switch (test) {
|
|
case 0:
|
|
r = inptrA[i] + inptrB[i];
|
|
break;
|
|
case 1:
|
|
r = inptrA[i] - inptrB[i];
|
|
break;
|
|
case 2:
|
|
r = inptrA[i] * inptrB[i];
|
|
break;
|
|
case 3:
|
|
if (inptrB[i] == 0)
|
|
continue;
|
|
else
|
|
r = inptrA[i] / inptrB[i];
|
|
break;
|
|
case 4:
|
|
if (inptrB[i] == 0)
|
|
continue;
|
|
else
|
|
r = inptrA[i] % inptrB[i];
|
|
break;
|
|
case 5:
|
|
r = inptrA[i] & inptrB[i];
|
|
break;
|
|
case 6:
|
|
r = inptrA[i] | inptrB[i];
|
|
break;
|
|
case 7:
|
|
r = inptrA[i] ^ inptrB[i];
|
|
break;
|
|
case 8:
|
|
r = inptrA[i] >> (inptrB[i] & shift_mask);
|
|
break;
|
|
case 9:
|
|
r = inptrA[i] << (inptrB[i] & shift_mask);
|
|
break;
|
|
case 10:
|
|
r = inptrA[i] >> (inptrB[j] & shift_mask);
|
|
break;
|
|
case 11:
|
|
r = inptrA[i] << (inptrB[j] & shift_mask);
|
|
break;
|
|
case 12:
|
|
r = ~inptrA[i];
|
|
break;
|
|
case 13:
|
|
r = (inptrA[j] < inptrB[j]) ? inptrA[i] : inptrB[i];
|
|
break;
|
|
case 14:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] && inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 15:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] || inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 16:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] < inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 17:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] > inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 18:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] <= inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 19:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] >= inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 20:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] == inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 21:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] != inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 22:
|
|
// Scalars are set to 1/0
|
|
r = !inptrA[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
default:
|
|
log_error("Invalid test: %d\n", test);
|
|
return -1;
|
|
break;
|
|
}
|
|
if (r != outptr[i]) {
|
|
// Shift is tricky
|
|
if (test == 8 || test == 9) {
|
|
log_error("cl_ushort Verification failed at element %ld: 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, inptrA[i], tests[test], inptrB[i], r, outptr[i]);
|
|
log_error("\t1) Shift failure at element %ld: original is 0x%x %s %d (0x%x)\n", i, inptrA[i], tests[test], (int)inptrB[i], inptrB[i]);
|
|
log_error("\t2) Take the %d LSBs of the shift to get the final shift amount %d (0x%x).\n", (int)log2(sizeof(cl_ushort)*8), inptrB[i]&shift_mask, inptrB[i]&shift_mask);
|
|
}
|
|
else if (test == 10 || test == 11) {
|
|
log_error("cl_ushort Verification failed at element %ld (%ld): 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, j, inptrA[i], tests[test], inptrB[j], r, outptr[i]);
|
|
log_error("\t1) Scalar shift failure at element %ld: original is 0x%x %s %d (0x%x)\n", i, inptrA[i], tests[test], (int)inptrB[j], inptrB[j]);
|
|
log_error("\t2) Take the %d LSBs of the shift to get the final shift amount %d (0x%x).\n", (int)log2(sizeof(cl_ushort)*8), inptrB[j]&shift_mask, inptrB[j]&shift_mask);
|
|
} else if (test == 13) {
|
|
log_error("cl_int Verification failed at element %ld (%ld): (0x%x < 0x%x) ? 0x%x : 0x%x = 0x%x, got 0x%x\n", i, j, inptrA[j], inptrB[j],
|
|
inptrA[i], inptrB[i], r, outptr[i]);
|
|
} else {
|
|
log_error("cl_ushort Verification failed at element %ld: 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, inptrA[i], tests[test], inptrB[i], r, outptr[i]);
|
|
}
|
|
count++;
|
|
if (count >= MAX_ERRORS_TO_PRINT) {
|
|
log_error("Further errors ignored.\n");
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (count) return -1; else return 0;
|
|
}
|
|
|
|
void
|
|
init_ushort_data(uint64_t indx, int num_elements, cl_ushort *input_ptr[], MTdata d)
|
|
{
|
|
static const cl_ushort specialCaseList[] = { 0, -1, 1, CL_SHRT_MAX, CL_SHRT_MAX + 1, CL_USHRT_MAX };
|
|
int j;
|
|
|
|
// Set the inputs to a random number
|
|
for (j=0; j<num_elements; j++)
|
|
{
|
|
cl_uint bits = genrand_int32(d);
|
|
((cl_ushort *)input_ptr[0])[j] = (cl_ushort) bits;
|
|
((cl_ushort *)input_ptr[1])[j] = (cl_ushort) (bits >> 16);
|
|
}
|
|
|
|
// Init the first few values to test special cases
|
|
{
|
|
size_t x, y, index = 0;
|
|
for( x = 0; x < sizeof( specialCaseList ) / sizeof( specialCaseList[0] ); x++ )
|
|
for( y = 0; y < sizeof( specialCaseList ) / sizeof( specialCaseList[0] ); y++ )
|
|
{
|
|
((cl_ushort *)input_ptr[0])[index] = specialCaseList[x];
|
|
((cl_ushort *)input_ptr[1])[index++] = specialCaseList[y];
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// =======================================
|
|
// char
|
|
// =======================================
|
|
int
|
|
verify_char(int test, size_t vector_size, cl_char *inptrA, cl_char *inptrB, cl_char *outptr, size_t n)
|
|
{
|
|
cl_char r;
|
|
cl_int shift_mask = vector_size == 1 ? (cl_int)(sizeof(cl_int)*8)-1
|
|
: (cl_int)(sizeof(cl_char)*8)-1;
|
|
size_t i, j;
|
|
int count=0;
|
|
|
|
for (j=0; j<n; j += vector_size )
|
|
{
|
|
for( i = j; i < j + vector_size; i++ )
|
|
{
|
|
|
|
switch (test) {
|
|
case 0:
|
|
r = inptrA[i] + inptrB[i];
|
|
break;
|
|
case 1:
|
|
r = inptrA[i] - inptrB[i];
|
|
break;
|
|
case 2:
|
|
r = inptrA[i] * inptrB[i];
|
|
break;
|
|
case 3:
|
|
if (inptrB[i] == 0 || (inptrB[i] == -1 && inptrA[i] == CL_CHAR_MIN))
|
|
continue;
|
|
else
|
|
r = inptrA[i] / inptrB[i];
|
|
break;
|
|
case 4:
|
|
if (inptrB[i] == 0 || (inptrB[i] == -1 && inptrA[i] == CL_CHAR_MIN))
|
|
continue;
|
|
else
|
|
r = inptrA[i] % inptrB[i];
|
|
break;
|
|
case 5:
|
|
r = inptrA[i] & inptrB[i];
|
|
break;
|
|
case 6:
|
|
r = inptrA[i] | inptrB[i];
|
|
break;
|
|
case 7:
|
|
r = inptrA[i] ^ inptrB[i];
|
|
break;
|
|
case 8:
|
|
r = inptrA[i] >> (inptrB[i] & shift_mask);
|
|
break;
|
|
case 9:
|
|
r = inptrA[i] << (inptrB[i] & shift_mask);
|
|
break;
|
|
case 10:
|
|
r = inptrA[i] >> (inptrB[j] & shift_mask);
|
|
break;
|
|
case 11:
|
|
r = inptrA[i] << (inptrB[j] & shift_mask);
|
|
break;
|
|
case 12:
|
|
r = ~inptrA[i];
|
|
break;
|
|
case 13:
|
|
r = (inptrA[j] < inptrB[j]) ? inptrA[i] : inptrB[i];
|
|
break;
|
|
case 14:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] && inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 15:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] || inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 16:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] < inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 17:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] > inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 18:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] <= inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 19:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] >= inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 20:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] == inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 21:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] != inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 22:
|
|
// Scalars are set to 1/0
|
|
r = !inptrA[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
default:
|
|
log_error("Invalid test: %d\n", test);
|
|
return -1;
|
|
break;
|
|
}
|
|
if (r != outptr[i]) {
|
|
// Shift is tricky
|
|
if (test == 8 || test == 9) {
|
|
log_error("cl_char Verification failed at element %ld: 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, inptrA[i], tests[test], inptrB[i], r, outptr[i]);
|
|
log_error("\t1) Shift failure at element %ld: original is 0x%x %s %d (0x%x)\n", i, inptrA[i], tests[test], (int)inptrB[i], inptrB[i]);
|
|
log_error("\t2) Take the %d LSBs of the shift to get the final shift amount %d (0x%x).\n", (int)log2(sizeof(cl_char)*8), inptrB[i]&shift_mask, inptrB[i]&shift_mask);
|
|
}
|
|
else if (test == 10 || test == 11) {
|
|
log_error("cl_char Verification failed at element %ld (%ld): 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, j, inptrA[i], tests[test], inptrB[j], r, outptr[i]);
|
|
log_error("\t1) Scalar shift failure at element %ld: original is 0x%x %s %d (0x%x)\n", i, inptrA[i], tests[test], (int)inptrB[j], inptrB[j]);
|
|
log_error("\t2) Take the %d LSBs of the shift to get the final shift amount %d (0x%x).\n", (int)log2(sizeof(cl_long)*8), inptrB[j]&shift_mask, inptrB[j]&shift_mask);
|
|
} else if (test == 13) {
|
|
log_error("cl_int Verification failed at element %ld (%ld): (0x%x < 0x%x) ? 0x%x : 0x%x = 0x%x, got 0x%x\n", i, j, inptrA[j], inptrB[j],
|
|
inptrA[i], inptrB[i], r, outptr[i]);
|
|
} else {
|
|
log_error("cl_char Verification failed at element %ld: 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, inptrA[i], tests[test], inptrB[i], r, outptr[i]);
|
|
}
|
|
count++;
|
|
if (count >= MAX_ERRORS_TO_PRINT) {
|
|
log_error("Further errors ignored.\n");
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (count) return -1; else return 0;
|
|
}
|
|
|
|
void
|
|
init_char_data(uint64_t indx, int num_elements, cl_char *input_ptr[], MTdata d)
|
|
{
|
|
static const cl_char specialCaseList[] = { 0, -1, 1, CL_CHAR_MIN, CL_CHAR_MIN + 1, CL_CHAR_MAX };
|
|
int j;
|
|
|
|
// FIXME comment below might not be appropriate for
|
|
// vector data. Yes, checking every scalar char against every
|
|
// scalar char is only 2^16 ~ 64000 tests, but once we get to vec3,
|
|
// vec4, vec8...
|
|
|
|
// in the meantime, this means I can use [] to access vec3 instead of
|
|
// vload3 / vstore3 :D
|
|
|
|
// FIXME: we really should just check every char against every char here
|
|
// Set the inputs to a random number
|
|
for (j=0; j<num_elements; j++)
|
|
{
|
|
cl_uint bits = genrand_int32(d);
|
|
((cl_char *)input_ptr[0])[j] = (cl_char) bits;
|
|
((cl_char *)input_ptr[1])[j] = (cl_char) (bits >> 16);
|
|
}
|
|
|
|
// Init the first few values to test special cases
|
|
{
|
|
size_t x, y, index = 0;
|
|
for( x = 0; x < sizeof( specialCaseList ) / sizeof( specialCaseList[0] ); x++ )
|
|
for( y = 0; y < sizeof( specialCaseList ) / sizeof( specialCaseList[0] ); y++ )
|
|
{
|
|
((cl_char *)input_ptr[0])[index] = specialCaseList[x];
|
|
((cl_char *)input_ptr[1])[index++] = specialCaseList[y];
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// =======================================
|
|
// uchar
|
|
// =======================================
|
|
int
|
|
verify_uchar(int test, size_t vector_size, cl_uchar *inptrA, cl_uchar *inptrB, cl_uchar *outptr, size_t n)
|
|
{
|
|
cl_uchar r;
|
|
cl_uint shift_mask = vector_size == 1 ? (cl_uint)(sizeof(cl_uint)*8)-1
|
|
: (cl_uint)(sizeof(cl_uchar)*8)-1;;
|
|
size_t i, j;
|
|
int count=0;
|
|
|
|
for (j=0; j<n; j += vector_size )
|
|
{
|
|
for( i = j; i < j + vector_size; i++ )
|
|
{
|
|
switch (test) {
|
|
case 0:
|
|
r = inptrA[i] + inptrB[i];
|
|
break;
|
|
case 1:
|
|
r = inptrA[i] - inptrB[i];
|
|
break;
|
|
case 2:
|
|
r = inptrA[i] * inptrB[i];
|
|
break;
|
|
case 3:
|
|
if (inptrB[i] == 0)
|
|
continue;
|
|
else
|
|
r = inptrA[i] / inptrB[i];
|
|
break;
|
|
case 4:
|
|
if (inptrB[i] == 0)
|
|
continue;
|
|
else
|
|
r = inptrA[i] % inptrB[i];
|
|
break;
|
|
case 5:
|
|
r = inptrA[i] & inptrB[i];
|
|
break;
|
|
case 6:
|
|
r = inptrA[i] | inptrB[i];
|
|
break;
|
|
case 7:
|
|
r = inptrA[i] ^ inptrB[i];
|
|
break;
|
|
case 8:
|
|
r = inptrA[i] >> (inptrB[i] & shift_mask);
|
|
break;
|
|
case 9:
|
|
r = inptrA[i] << (inptrB[i] & shift_mask);
|
|
break;
|
|
case 10:
|
|
r = inptrA[i] >> (inptrB[j] & shift_mask);
|
|
break;
|
|
case 11:
|
|
r = inptrA[i] << (inptrB[j] & shift_mask);
|
|
break;
|
|
case 12:
|
|
r = ~inptrA[i];
|
|
break;
|
|
case 13:
|
|
r = (inptrA[j] < inptrB[j]) ? inptrA[i] : inptrB[i];
|
|
break;
|
|
case 14:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] && inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 15:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] || inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 16:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] < inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 17:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] > inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 18:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] <= inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 19:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] >= inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 20:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] == inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 21:
|
|
// Scalars are set to 1/0
|
|
r = inptrA[i] != inptrB[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
case 22:
|
|
// Scalars are set to 1/0
|
|
r = !inptrA[i];
|
|
// Vectors are set to -1/0
|
|
if (vector_size != 1 && r) {
|
|
r = -1;
|
|
}
|
|
break;
|
|
default:
|
|
log_error("Invalid test: %d\n", test);
|
|
return -1;
|
|
break;
|
|
}
|
|
if (r != outptr[i]) {
|
|
// Shift is tricky
|
|
if (test == 8 || test == 9) {
|
|
log_error("cl_uchar Verification failed at element %ld: 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, inptrA[i], tests[test], inptrB[i], r, outptr[i]);
|
|
log_error("\t1) Shift failure at element %ld: original is 0x%x %s %d (0x%x)\n", i, inptrA[i], tests[test], (int)inptrB[i], inptrB[i]);
|
|
log_error("\t2) Take the %d LSBs of the shift to get the final shift amount %d (0x%x).\n", (int)log2(sizeof(cl_uchar)*8), inptrB[i]&shift_mask, inptrB[i]&shift_mask);
|
|
}
|
|
else if (test == 10 || test == 11) {
|
|
log_error("cl_uchar Verification failed at element %ld (%ld): 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, j, inptrA[i], tests[test], inptrB[j], r, outptr[i]);
|
|
log_error("\t1) Scalar shift failure at element %ld: original is 0x%x %s %d (0x%x)\n", i, inptrA[i], tests[test], (int)inptrB[j], inptrB[j]);
|
|
log_error("\t2) Take the %d LSBs of the shift to get the final shift amount %d (0x%x).\n", (int)log2(sizeof(cl_uchar)*8), inptrB[j]&shift_mask, inptrB[j]&shift_mask);
|
|
} else if (test == 13) {
|
|
log_error("cl_int Verification failed at element %ld (%ld): (0x%x < 0x%x) ? 0x%x : 0x%x = 0x%x, got 0x%x\n", i, j, inptrA[j], inptrB[j],
|
|
inptrA[i], inptrB[i], r, outptr[i]);
|
|
} else {
|
|
log_error("cl_uchar Verification failed at element %ld: 0x%x %s 0x%x = 0x%x, got 0x%x\n", i, inptrA[i], tests[test], inptrB[i], r, outptr[i]);
|
|
}
|
|
count++;
|
|
if (count >= MAX_ERRORS_TO_PRINT) {
|
|
log_error("Further errors ignored.\n");
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (count) return -1; else return 0;
|
|
}
|
|
|
|
void
|
|
init_uchar_data(uint64_t indx, int num_elements, cl_uchar *input_ptr[], MTdata d)
|
|
{
|
|
static const cl_uchar specialCaseList[] = { 0, -1, 1, CL_CHAR_MAX, CL_CHAR_MAX + 1, CL_UCHAR_MAX };
|
|
int j;
|
|
|
|
// FIXME: we really should just check every char against every char here
|
|
|
|
// Set the inputs to a random number
|
|
for (j=0; j<num_elements; j++)
|
|
{
|
|
cl_uint bits = genrand_int32(d);
|
|
((cl_uchar *)input_ptr[0])[j] = (cl_uchar) bits;
|
|
((cl_uchar *)input_ptr[1])[j] = (cl_uchar) (bits >> 16);
|
|
}
|
|
|
|
// Init the first few values to test special cases
|
|
{
|
|
size_t x, y, index = 0;
|
|
for( x = 0; x < sizeof( specialCaseList ) / sizeof( specialCaseList[0] ); x++ )
|
|
for( y = 0; y < sizeof( specialCaseList ) / sizeof( specialCaseList[0] ); y++ )
|
|
{
|
|
((cl_uchar *)input_ptr[0])[index] = specialCaseList[x];
|
|
((cl_uchar *)input_ptr[1])[index++] = specialCaseList[y];
|
|
}
|
|
}
|
|
}
|
|
|