mirror of
https://github.com/KhronosGroup/OpenCL-CTS.git
synced 2026-03-19 22:19:02 +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>
741 lines
21 KiB
C
741 lines
21 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>
|
|
|
|
#if !defined(_WIN32)
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#endif
|
|
|
|
#include <math.h>
|
|
#include "test_select.h"
|
|
|
|
|
|
//-----------------------------------------
|
|
// Definitions and initializations
|
|
//-----------------------------------------
|
|
|
|
|
|
const char *type_name[kTypeCount] = {
|
|
"uchar", "char",
|
|
"ushort", "short",
|
|
"uint", "int",
|
|
"float", "ulong", "long", "double" };
|
|
|
|
const size_t type_size[kTypeCount] = {
|
|
sizeof(cl_uchar), sizeof(cl_char),
|
|
sizeof(cl_ushort), sizeof(cl_short),
|
|
sizeof(cl_uint), sizeof(cl_int),
|
|
sizeof(cl_float), sizeof(cl_ulong), sizeof(cl_long), sizeof( cl_double ) };
|
|
|
|
const Type ctype[kTypeCount][2] = {
|
|
{ kuchar, kchar }, // uchar
|
|
{ kuchar, kchar }, // char
|
|
{ kushort, kshort}, // ushort
|
|
{ kushort, kshort}, // short
|
|
{ kuint, kint }, // uint
|
|
{ kuint, kint }, // int
|
|
{ kuint, kint }, // float
|
|
{ kulong, klong }, // ulong
|
|
{ kulong, klong }, // long
|
|
{ kulong, klong } // double
|
|
};
|
|
|
|
|
|
//-----------------------------------------
|
|
// Reference functions
|
|
//-----------------------------------------
|
|
|
|
void refselect_1i8(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_char *d, *x, *y, *m;
|
|
d = (cl_char*) dest;
|
|
x = (cl_char*) src1;
|
|
y = (cl_char*) src2;
|
|
m = (cl_char*) cmp;
|
|
for (i=0; i < count; ++i) {
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
}
|
|
|
|
void refselect_1u8(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_uchar *d, *x, *y;
|
|
cl_char *m;
|
|
d = (cl_uchar*) dest;
|
|
x = (cl_uchar*) src1;
|
|
y = (cl_uchar*) src2;
|
|
m = (cl_char*) cmp;
|
|
for (i=0; i < count; ++i) {
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
}
|
|
|
|
void refselect_1i16(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_short *d, *x, *y, *m;
|
|
d = (cl_short*) dest;
|
|
x = (cl_short*) src1;
|
|
y = (cl_short*) src2;
|
|
m = (cl_short*) cmp;
|
|
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_1u16(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_ushort *d, *x, *y;
|
|
cl_short *m;
|
|
d = (cl_ushort*) dest;
|
|
x = (cl_ushort*) src1;
|
|
y = (cl_ushort*) src2;
|
|
m = (cl_short*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_1i32(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_int *d, *x, *y, *m;
|
|
d = (cl_int*)dest;
|
|
x = (cl_int*)src1;
|
|
y = (cl_int*)src2;
|
|
m = (cl_int*)cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_1u32(void *dest, void *src1, void *src2, void *cmp, size_t count){
|
|
size_t i;
|
|
cl_uint *d, *x, *y;
|
|
cl_int *m;
|
|
d = (cl_uint*)dest;
|
|
x = (cl_uint*)src1;
|
|
y = (cl_uint*)src2;
|
|
m = (cl_int*)cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_1i64(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_long *d, *x, *y, *m;
|
|
d = (cl_long*) dest;
|
|
x = (cl_long*) src1;
|
|
y = (cl_long*) src2;
|
|
m = (cl_long*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_1u64(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_ulong *d, *x, *y;
|
|
cl_long *m;
|
|
d = (cl_ulong*) dest;
|
|
x = (cl_ulong*) src1;
|
|
y = (cl_ulong*) src2;
|
|
m = (cl_long*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_1i8u(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_char *d, *x, *y;
|
|
cl_uchar *m;
|
|
d = (cl_char*) dest;
|
|
x = (cl_char*) src1;
|
|
y = (cl_char*) src2;
|
|
m = (cl_uchar*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_1u8u(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_uchar *d, *x, *y, *m;
|
|
d = (cl_uchar*) dest;
|
|
x = (cl_uchar*) src1;
|
|
y = (cl_uchar*) src2;
|
|
m = (cl_uchar*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_1i16u(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_short *d, *x, *y;
|
|
cl_ushort *m;
|
|
d = (cl_short*) dest;
|
|
x = (cl_short*) src1;
|
|
y = (cl_short*) src2;
|
|
m = (cl_ushort*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_1u16u(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_ushort *d, *x, *y, *m;
|
|
d = (cl_ushort*) dest;
|
|
x = (cl_ushort*) src1;
|
|
y = (cl_ushort*) src2;
|
|
m = (cl_ushort*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_1i32u(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_int *d, *x, *y;
|
|
cl_uint *m;
|
|
d = (cl_int*) dest;
|
|
x = (cl_int*) src1;
|
|
y = (cl_int*) src2;
|
|
m = (cl_uint*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_1u32u(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_uint *d, *x, *y, *m;
|
|
d = (cl_uint*) dest;
|
|
x = (cl_uint*) src1;
|
|
y = (cl_uint*) src2;
|
|
m = (cl_uint*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_1i64u(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_long *d, *x, *y;
|
|
cl_ulong *m;
|
|
d = (cl_long*) dest;
|
|
x = (cl_long*) src1;
|
|
y = (cl_long*) src2;
|
|
m = (cl_ulong*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_1u64u(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_ulong *d, *x, *y, *m;
|
|
d = (cl_ulong*) dest;
|
|
x = (cl_ulong*) src1;
|
|
y = (cl_ulong*) src2;
|
|
m = (cl_ulong*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_ffi(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_int *d, *x, *y;
|
|
cl_int *m;
|
|
d = (cl_int*) dest;
|
|
x = (cl_int*) src1;
|
|
y = (cl_int*) src2;
|
|
m = (cl_int*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_ffu(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_uint *d, *x, *y;
|
|
cl_uint *m;
|
|
d = (cl_uint*) dest;
|
|
x = (cl_uint*) src1;
|
|
y = (cl_uint*) src2;
|
|
m = (cl_uint*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_ddi(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_long *d, *x, *y;
|
|
cl_long *m;
|
|
d = (cl_long*) dest;
|
|
x = (cl_long*) src1;
|
|
y = (cl_long*) src2;
|
|
m = (cl_long*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void refselect_ddu(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_long *d, *x, *y;
|
|
cl_ulong *m;
|
|
d = (cl_long*) dest;
|
|
x = (cl_long*) src1;
|
|
y = (cl_long*) src2;
|
|
m = (cl_ulong*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = m[i] ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_1i8(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_char *d, *x, *y, *m;
|
|
d = (cl_char*) dest;
|
|
x = (cl_char*) src1;
|
|
y = (cl_char*) src2;
|
|
m = (cl_char*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x80) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_1u8(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_uchar *d, *x, *y;
|
|
cl_char *m;
|
|
d = (cl_uchar*) dest;
|
|
x = (cl_uchar*) src1;
|
|
y = (cl_uchar*) src2;
|
|
m = (cl_char*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x80) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_1i16(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_short *d, *x, *y, *m;
|
|
d = (cl_short*) dest;
|
|
x = (cl_short*) src1;
|
|
y = (cl_short*) src2;
|
|
m = (cl_short*) cmp;
|
|
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x8000) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_1u16(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_ushort *d, *x, *y;
|
|
cl_short *m;
|
|
d = (cl_ushort*) dest;
|
|
x = (cl_ushort*)src1;
|
|
y = (cl_ushort*)src2;
|
|
m = (cl_short*)cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x8000) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_1i32(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_int *d, *x, *y, *m;
|
|
d = (cl_int*) dest;
|
|
x = (cl_int*) src1;
|
|
y = (cl_int*) src2;
|
|
m = (cl_int*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x80000000) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_1u32(void *dest, void *src1, void *src2, void *cmp, size_t count){
|
|
size_t i;
|
|
cl_uint *d, *x, *y;
|
|
cl_int *m;
|
|
d = (cl_uint*) dest;
|
|
x = (cl_uint*) src1;
|
|
y = (cl_uint*) src2;
|
|
m = (cl_int*) cmp;
|
|
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x80000000) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_1i64(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_long *d, *x, *y, *m;
|
|
d = (cl_long*) dest;
|
|
x = (cl_long*) src1;
|
|
y = (cl_long*) src2;
|
|
m = (cl_long*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x8000000000000000LL) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_1u64(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_ulong *d, *x, *y;
|
|
cl_long *m;
|
|
d = (cl_ulong*) dest;
|
|
x = (cl_ulong*) src1;
|
|
y = (cl_ulong*) src2;
|
|
m = (cl_long*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x8000000000000000LL) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_1i8u(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_char *d, *x, *y;
|
|
cl_uchar *m;
|
|
d = (cl_char*) dest;
|
|
x = (cl_char*) src1;
|
|
y = (cl_char*) src2;
|
|
m = (cl_uchar*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x80U) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_1u8u(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_uchar *d, *x, *y, *m;
|
|
d = (cl_uchar*) dest;
|
|
x = (cl_uchar*) src1;
|
|
y = (cl_uchar*) src2;
|
|
m = (cl_uchar*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x80U) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_1i16u(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_short *d, *x, *y;
|
|
cl_ushort *m;
|
|
d = (cl_short*) dest;
|
|
x = (cl_short*) src1;
|
|
y = (cl_short*) src2;
|
|
m = (cl_ushort*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x8000U) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_1u16u(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_ushort *d, *x, *y, *m;
|
|
d = (cl_ushort*) dest;
|
|
x = (cl_ushort*) src1;
|
|
y = (cl_ushort*) src2;
|
|
m = (cl_ushort*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x8000U) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_1i32u(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_int *d, *x, *y;
|
|
cl_uint *m;
|
|
d = (cl_int*) dest;
|
|
x = (cl_int*) src1;
|
|
y = (cl_int*) src2;
|
|
m = (cl_uint*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x80000000U) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_1u32u(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_uint *d, *x, *y, *m;
|
|
d = (cl_uint*) dest;
|
|
x = (cl_uint*) src1;
|
|
y = (cl_uint*) src2;
|
|
m = (cl_uint*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x80000000U) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_1i64u(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_long *d, *x, *y;
|
|
cl_ulong *m;
|
|
d = (cl_long*) dest;
|
|
x = (cl_long*) src1;
|
|
y = (cl_long*) src2;
|
|
m = (cl_ulong*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x8000000000000000ULL) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_1u64u(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_ulong *d, *x, *y, *m;
|
|
d = (cl_ulong*) dest;
|
|
x = (cl_ulong*) src1;
|
|
y = (cl_ulong*) src2;
|
|
m = (cl_ulong*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x8000000000000000ULL) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_ffi(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_uint *d, *x, *y;
|
|
cl_int *m;
|
|
d = (cl_uint*) dest;
|
|
x = (cl_uint*) src1;
|
|
y = (cl_uint*) src2;
|
|
m = (cl_int*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x80000000) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_ffu(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_uint *d, *x, *y;
|
|
cl_uint *m;
|
|
d = (cl_uint*) dest;
|
|
x = (cl_uint*) src1;
|
|
y = (cl_uint*) src2;
|
|
m = (cl_uint*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x80000000U) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_ddi(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_ulong *d, *x, *y;
|
|
cl_long *m;
|
|
d = (cl_ulong*) dest;
|
|
x = (cl_ulong*) src1;
|
|
y = (cl_ulong*) src2;
|
|
m = (cl_long*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x8000000000000000LL) ? y[i] : x[i];
|
|
}
|
|
|
|
void vrefselect_ddu(void *dest, void *src1, void *src2, void *cmp, size_t count) {
|
|
size_t i;
|
|
cl_ulong *d, *x, *y;
|
|
cl_ulong *m;
|
|
d = (cl_ulong*) dest;
|
|
x = (cl_ulong*) src1;
|
|
y = (cl_ulong*) src2;
|
|
m = (cl_ulong*) cmp;
|
|
for (i=0; i < count; ++i)
|
|
d[i] = (m[i] & 0x8000000000000000ULL) ? y[i] : x[i];
|
|
}
|
|
|
|
// Define refSelects
|
|
Select refSelects[kTypeCount][2] = {
|
|
{ refselect_1u8u, refselect_1u8 }, // cl_uchar
|
|
{ refselect_1i8u, refselect_1i8 }, // char
|
|
{ refselect_1u16u, refselect_1u16 }, // ushort
|
|
{ refselect_1i16u, refselect_1i16 }, // short
|
|
{ refselect_1u32u, refselect_1u32 }, // uint
|
|
{ refselect_1i32u, refselect_1i32 }, // int
|
|
{ refselect_ffu, refselect_ffi }, // float
|
|
{ refselect_1u64u, refselect_1u64 }, // ulong
|
|
{ refselect_1i64u, refselect_1i64 }, // long
|
|
{ refselect_ddu, refselect_ddi } // double
|
|
};
|
|
|
|
// Define vrefSelects (vector refSelects)
|
|
Select vrefSelects[kTypeCount][2] = {
|
|
{ vrefselect_1u8u, vrefselect_1u8 }, // cl_uchar
|
|
{ vrefselect_1i8u, vrefselect_1i8 }, // char
|
|
{ vrefselect_1u16u, vrefselect_1u16 }, // ushort
|
|
{ vrefselect_1i16u, vrefselect_1i16 }, // short
|
|
{ vrefselect_1u32u, vrefselect_1u32 }, // uint
|
|
{ vrefselect_1i32u, vrefselect_1i32 }, // int
|
|
{ vrefselect_ffu, vrefselect_ffi }, // float
|
|
{ vrefselect_1u64u, vrefselect_1u64 }, // ulong
|
|
{ vrefselect_1i64u, vrefselect_1i64 }, // long
|
|
{ vrefselect_ddu, vrefselect_ddi } // double
|
|
};
|
|
|
|
|
|
//-----------------------------------------
|
|
// Check functions
|
|
//-----------------------------------------
|
|
size_t check_uchar(void *test, void *correct, size_t count, size_t vector_size) {
|
|
const cl_uchar *t = (const cl_uchar *) test;
|
|
const cl_uchar *c = (const cl_uchar *) correct;
|
|
size_t i;
|
|
|
|
for(i = 0; i < count; i++)
|
|
if (t[i] != c[i]) {
|
|
log_error("\n(check_uchar) Error for vector size %ld found at 0x%8.8lx (of 0x%8.8lx): "
|
|
"*0x%2.2x vs 0x%2.2x\n", vector_size, i, count, c[i], t[i]);
|
|
return i + 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
size_t check_char(void *test, void *correct, size_t count, size_t vector_size) {
|
|
const cl_char *t = (const cl_char *) test;
|
|
const cl_char *c = (const cl_char *) correct;
|
|
size_t i;
|
|
|
|
|
|
for( i = 0; i < count; i++ )
|
|
if( t[i] != c[i] ) {
|
|
log_error("\n(check_char) Error for vector size %ld found at 0x%8.8lx (of 0x%8.8lx): "
|
|
"*0x%2.2x vs 0x%2.2x\n", vector_size, i, count, c[i], t[i] );
|
|
return i + 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
size_t check_ushort(void *test, void *correct, size_t count, size_t vector_size) {
|
|
const cl_ushort *t = (const cl_ushort *) test;
|
|
const cl_ushort *c = (const cl_ushort *) correct;
|
|
size_t i;
|
|
|
|
|
|
for( i = 0; i < count; i++ )
|
|
if(t[i] != c[i]) {
|
|
log_error("\n(check_ushort) Error for vector size %ld found at 0x%8.8lx (of 0x%8.8lx): "
|
|
"*0x%4.4x vs 0x%4.4x\n", vector_size, i, count, c[i], t[i] );
|
|
return i + 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
size_t check_short(void *test, void *correct, size_t count, size_t vector_size) {
|
|
const cl_short *t = (const cl_short *) test;
|
|
const cl_short *c = (const cl_short *) correct;
|
|
size_t i;
|
|
|
|
|
|
for (i = 0; i < count; i++)
|
|
if(t[i] != c[i]) {
|
|
log_error("\n(check_short) Error for vector size %ld found at 0x%8.8lx (of 0x%8.8lx): "
|
|
"*0x%8.8x vs 0x%8.8x\n", vector_size, i, count, c[i], t[i] );
|
|
return i + 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
size_t check_uint(void *test, void *correct, size_t count, size_t vector_size) {
|
|
const cl_uint *t = (const cl_uint *) test;
|
|
const cl_uint *c = (const cl_uint *) correct;
|
|
size_t i;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++)
|
|
if(t[i] != c[i]) {
|
|
log_error("\n(check_uint) Error for vector size %ld found at 0x%8.8lx (of 0x%8.8lx): "
|
|
"*0x%8.8x vs 0x%8.8x\n", vector_size, i, count, c[i], t[i] );
|
|
return i + 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
size_t check_int(void *test, void *correct, size_t count, size_t vector_size) {
|
|
const cl_int *t = (const cl_int *) test;
|
|
const cl_int *c = (const cl_int *) correct;
|
|
size_t i;
|
|
|
|
|
|
for(i = 0; i < count; i++)
|
|
if( t[i] != c[i] ) {
|
|
|
|
log_error("\n(check_int) Error for vector size %ld found at 0x%8.8lx (of 0x%8.8lx): "
|
|
"*0x%8.8x vs 0x%8.8x\n", vector_size, i, count, c[i], t[i]);
|
|
log_error("\n(check_int) Error for vector size %ld found at 0x%8.8lx (of 0x%8.8lx): "
|
|
"*0x%8.8x vs 0x%8.8x\n", vector_size, i+1, count,c[i+1], t[i+1]);
|
|
log_error("\n(check_int) Error for vector size %ld found at 0x%8.8lx (of 0x%8.8lx): "
|
|
"*0x%8.8x vs 0x%8.8x\n", vector_size, i+2, count,c[i+2], t[i+2]);
|
|
log_error("\n(check_int) Error for vector size %ld found at 0x%8.8lx (of 0x%8.8lx): "
|
|
"*0x%8.8x vs 0x%8.8x\n", vector_size, i+3, count,c[i+3], t[i+3]);
|
|
if(i) {
|
|
log_error("\n(check_int) Error for vector size %ld found just after 0x%8.8lx: "
|
|
"*0x%8.8x vs 0x%8.8x\n", vector_size, i-1, c[i-1], t[i-1]);
|
|
}
|
|
return i + 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
size_t check_ulong(void *test, void *correct, size_t count, size_t vector_size) {
|
|
const cl_ulong *t = (const cl_ulong *) test;
|
|
const cl_ulong *c = (const cl_ulong *) correct;
|
|
size_t i;
|
|
|
|
|
|
for( i = 0; i < count; i++ )
|
|
if( t[i] != c[i] ) {
|
|
log_error("\n(check_ulong) Error for vector size %ld found at 0x%8.8lx (of 0x%8.8lx): "
|
|
"*0x%16.16llx vs 0x%16.16llx\n", vector_size, i, count, c[i], t[i] );
|
|
return i + 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
size_t check_long(void *test, void *correct, size_t count, size_t vector_size) {
|
|
const cl_long *t = (const cl_long *) test;
|
|
const cl_long *c = (const cl_long *) correct;
|
|
size_t i;
|
|
|
|
|
|
for(i = 0; i < count; i++ )
|
|
if(t[i] != c[i]) {
|
|
log_error("\n(check_long) Error for vector size %ld found at 0x%8.8lx (of 0x%8.8lx): "
|
|
"*0x%16.16llx vs 0x%16.16llx\n", vector_size, i, count, c[i], t[i] );
|
|
return i + 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
size_t check_float( void *test, void *correct, size_t count, size_t vector_size ) {
|
|
const cl_uint *t = (const cl_uint *) test;
|
|
const cl_uint *c = (const cl_uint *) correct;
|
|
size_t i;
|
|
|
|
|
|
for( i = 0; i < count; i++ )
|
|
/* Allow nans to be binary different */
|
|
if ((t[i] != c[i]) && !(isnan(((float *)correct)[i]) && isnan(((float *)test)[i]))) {
|
|
log_error("\n(check_float) Error for vector size %ld found at 0x%8.8lx (of 0x%8.8lx): "
|
|
"*0x%8.8x vs 0x%8.8x\n", vector_size, i, count, c[i], t[i] );
|
|
return i + 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
size_t check_double( void *test, void *correct, size_t count, size_t vector_size ) {
|
|
const cl_ulong *t = (const cl_ulong *) test;
|
|
const cl_ulong *c = (const cl_ulong *) correct;
|
|
size_t i;
|
|
|
|
|
|
|
|
for( i = 0; i < count; i++ )
|
|
/* Allow nans to be binary different */
|
|
if ((t[i] != c[i]) && !(isnan(((double *)correct)[i]) && isnan(((double *)test)[i]))) {
|
|
log_error("\n(check_double) Error for vector size %ld found at 0x%8.8lx (of 0x%8.8lx): "
|
|
"*0x%16.16llx vs 0x%16.16llx\n", vector_size, i, count, c[i], t[i] );
|
|
return i + 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
CheckResults checkResults[kTypeCount] = {
|
|
check_uchar, check_char, check_ushort, check_short, check_uint,
|
|
check_int, check_float, check_ulong, check_long, check_double };
|