Danylo Lytovchenko
719 Zeilen
26 KiB
C
719 Zeilen
26 KiB
C
//
|
|
// Copyright (c) 2020 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 "CL/cl.h"
|
|
|
|
int test_char() {
|
|
/* char */
|
|
/* Constructor */
|
|
cl_char a = 0;
|
|
cl_char2 a2 = {{0, 1}};
|
|
cl_char4 a4 = {{0, 1, 2, 3}};
|
|
cl_char8 a8 = {{0, 1, 2, 3, 4, 5, 6, 7}};
|
|
cl_char16 a16 = {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}};
|
|
|
|
/* assignment */
|
|
cl_char b = a;
|
|
cl_char2 b2 = a2;
|
|
cl_char4 b4 = a4;
|
|
cl_char8 b8 = a8;
|
|
cl_char16 b16 = a16;
|
|
|
|
printf("\nVerifying assignment:\n");
|
|
printf("b: %d\n", b);
|
|
printf("b2: %d %d \n", b2.s[0], b2.s[1]);
|
|
printf("b4: %d %d %d %d\n", b4.s[0], b4.s[1], b4.s[2], b4.s[3]);
|
|
printf("b8: %d %d %d %d %d %d %d %d\n", b8.s[0], b8.s[1], b8.s[2], b8.s[3], b8.s[4], b8.s[5],
|
|
b8.s[6], b8.s[7]);
|
|
printf("b16: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n", b16.s[0], b16.s[1], b16.s[2],
|
|
b16.s[3], b16.s[4], b16.s[5], b16.s[6], b16.s[7], b16.s[8], b16.s[9], b16.s[10], b16.s[11],
|
|
b16.s[12], b16.s[13], b16.s[14], b16.s[15]);
|
|
|
|
/* vector access */
|
|
printf("\nVerifying vector access:\n");
|
|
#if defined(__CL_CHAR2__)
|
|
__cl_char2 v2 = b2.v2;
|
|
printf("__cl_char2: %d %d \n", ((cl_char*)&v2)[0], ((cl_char*)&v2)[1]);
|
|
#else
|
|
printf("__cl_char2 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_CHAR4__)
|
|
__cl_char4 v4 = b4.v4;
|
|
printf("__cl_char4: %d %d %d %d \n", ((cl_char*)&v4)[0], ((cl_char*)&v4)[1], ((cl_char*)&v4)[2],
|
|
((cl_char*)&v4)[3]);
|
|
#else
|
|
printf("__cl_char4 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_CHAR8__)
|
|
__cl_char8 v8 = b8.v8;
|
|
printf("__cl_char8: %d %d %d %d %d %d %d %d \n", ((cl_char*)&v8)[0], ((cl_char*)&v8)[1],
|
|
((cl_char*)&v8)[2], ((cl_char*)&v8)[3], ((cl_char*)&v8)[4], ((cl_char*)&v8)[5],
|
|
((cl_char*)&v8)[6], ((cl_char*)&v8)[7]);
|
|
#else
|
|
printf("__cl_char8 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_CHAR16__)
|
|
__cl_char16 v16 = b16.v16;
|
|
printf("__cl_char16: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d \n", ((cl_char*)&v16)[0],
|
|
((cl_char*)&v16)[1], ((cl_char*)&v16)[2], ((cl_char*)&v16)[3], ((cl_char*)&v16)[4],
|
|
((cl_char*)&v16)[5], ((cl_char*)&v16)[6], ((cl_char*)&v16)[7], ((cl_char*)&v16)[8],
|
|
((cl_char*)&v16)[9], ((cl_char*)&v16)[10], ((cl_char*)&v16)[11], ((cl_char*)&v16)[12],
|
|
((cl_char*)&v16)[13], ((cl_char*)&v16)[14], ((cl_char*)&v16)[15]);
|
|
#else
|
|
printf("__cl_char16 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
printf("\n");
|
|
return 0;
|
|
}
|
|
|
|
int test_uchar() {
|
|
/* uchar */
|
|
/* Constructor */
|
|
cl_uchar a = 0;
|
|
cl_uchar2 a2 = {{0, 1}};
|
|
cl_uchar4 a4 = {{0, 1, 2, 3}};
|
|
cl_uchar8 a8 = {{0, 1, 2, 3, 4, 5, 6, 7}};
|
|
cl_uchar16 a16 = {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}};
|
|
|
|
/* assignment */
|
|
cl_uchar b = a;
|
|
cl_uchar2 b2 = a2;
|
|
cl_uchar4 b4 = a4;
|
|
cl_uchar8 b8 = a8;
|
|
cl_uchar16 b16 = a16;
|
|
|
|
printf("\nVerifying assignment:\n");
|
|
printf("b: %d\n", b);
|
|
printf("b2: %d %d \n", b2.s[0], b2.s[1]);
|
|
printf("b4: %d %d %d %d\n", b4.s[0], b4.s[1], b4.s[2], b4.s[3]);
|
|
printf("b8: %d %d %d %d %d %d %d %d\n", b8.s[0], b8.s[1], b8.s[2], b8.s[3], b8.s[4], b8.s[5],
|
|
b8.s[6], b8.s[7]);
|
|
printf("b16: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n", b16.s[0], b16.s[1], b16.s[2],
|
|
b16.s[3], b16.s[4], b16.s[5], b16.s[6], b16.s[7], b16.s[8], b16.s[9], b16.s[10], b16.s[11],
|
|
b16.s[12], b16.s[13], b16.s[14], b16.s[15]);
|
|
|
|
/* vector access */
|
|
printf("\nVerifying vector access:\n");
|
|
#if defined(__CL_UCHAR2__)
|
|
__cl_uchar2 v2 = b2.v2;
|
|
printf("__cl_uchar2: %d %d \n", ((uchar*)&v2)[0], ((cl_uchar*)&v2)[1]);
|
|
#else
|
|
printf("__cl_uchar2 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_UCHAR4__)
|
|
__cl_uchar4 v4 = b4.v4;
|
|
printf("__cl_uchar4: %d %d %d %d \n", ((uchar*)&v4)[0], ((cl_uchar*)&v4)[1], ((cl_uchar*)&v4)[2],
|
|
((cl_uchar*)&v4)[3]);
|
|
#else
|
|
printf("__cl_uchar4 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_UCHAR8__)
|
|
__cl_uchar8 v8 = b8.v8;
|
|
printf("__cl_uchar8: %d %d %d %d %d %d %d %d \n", ((cl_uchar*)&v8)[0], ((cl_uchar*)&v8)[1],
|
|
((cl_uchar*)&v8)[2], ((cl_uchar*)&v8)[3], ((cl_uchar*)&v8)[4], ((cl_uchar*)&v8)[5],
|
|
((cl_uchar*)&v8)[6], ((cl_uchar*)&v8)[7]);
|
|
#else
|
|
printf("__cl_uchar8 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_UCHAR16__)
|
|
__cl_uchar16 v16 = b16.v16;
|
|
printf("__cl_uchar16: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d \n", ((cl_uchar*)&v16)[0],
|
|
((cl_uchar*)&v16)[1], ((cl_uchar*)&v16)[2], ((cl_uchar*)&v16)[3], ((cl_uchar*)&v16)[4],
|
|
((cl_uchar*)&v16)[5], ((cl_uchar*)&v16)[6], ((cl_uchar*)&v16)[7], ((cl_uchar*)&v16)[8],
|
|
((cl_uchar*)&v16)[9], ((cl_uchar*)&v16)[10], ((cl_uchar*)&v16)[11], ((cl_uchar*)&v16)[12],
|
|
((cl_uchar*)&v16)[13], ((cl_uchar*)&v16)[14], ((cl_uchar*)&v16)[15]);
|
|
#else
|
|
printf("__cl_uchar16 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
printf("\n");
|
|
return 0;
|
|
}
|
|
|
|
int test_short() {
|
|
/* short */
|
|
/* Constructor */
|
|
cl_short a = 0;
|
|
cl_short2 a2 = {{0, 1}};
|
|
cl_short4 a4 = {{0, 1, 2, 3}};
|
|
cl_short8 a8 = {{0, 1, 2, 3, 4, 5, 6, 7}};
|
|
cl_short16 a16 = {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}};
|
|
|
|
/* assignment */
|
|
cl_short b = a;
|
|
cl_short2 b2 = a2;
|
|
cl_short4 b4 = a4;
|
|
cl_short8 b8 = a8;
|
|
cl_short16 b16 = a16;
|
|
|
|
printf("\nVerifying assignment:\n");
|
|
printf("b: %d\n", b);
|
|
printf("b2: %d %d \n", b2.s[0], b2.s[1]);
|
|
printf("b4: %d %d %d %d\n", b4.s[0], b4.s[1], b4.s[2], b4.s[3]);
|
|
printf("b8: %d %d %d %d %d %d %d %d\n", b8.s[0], b8.s[1], b8.s[2], b8.s[3], b8.s[4], b8.s[5],
|
|
b8.s[6], b8.s[7]);
|
|
printf("b16: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n", b16.s[0], b16.s[1], b16.s[2],
|
|
b16.s[3], b16.s[4], b16.s[5], b16.s[6], b16.s[7], b16.s[8], b16.s[9], b16.s[10], b16.s[11],
|
|
b16.s[12], b16.s[13], b16.s[14], b16.s[15]);
|
|
|
|
/* vector access */
|
|
printf("\nVerifying vector access:\n");
|
|
#if defined(__CL_SHORT2__)
|
|
__cl_short2 v2 = b2.v2;
|
|
printf("__cl_short2: %d %d \n", ((cl_short*)&v2)[0], ((cl_short*)&v2)[1]);
|
|
#else
|
|
printf("__cl_short2 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_SHORT4__)
|
|
__cl_short4 v4 = b4.v4;
|
|
printf("__cl_short4: %d %d %d %d \n", ((cl_short*)&v4)[0], ((cl_short*)&v4)[1],
|
|
((cl_short*)&v4)[2], ((cl_short*)&v4)[3]);
|
|
#else
|
|
printf("__cl_short4 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_SHORT8__)
|
|
__cl_short8 v8 = b8.v8;
|
|
printf("__cl_short8: %d %d %d %d %d %d %d %d \n", ((cl_short*)&v8)[0], ((cl_short*)&v8)[1],
|
|
((cl_short*)&v8)[2], ((cl_short*)&v8)[3], ((cl_short*)&v8)[4], ((cl_short*)&v8)[5],
|
|
((cl_short*)&v8)[6], ((cl_short*)&v8)[7]);
|
|
#else
|
|
printf("__cl_short8 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_SHORT16__)
|
|
__cl_short16 v16 = b16.v16;
|
|
printf("__cl_short16: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d \n", ((cl_short*)&v16)[0],
|
|
((cl_short*)&v16)[1], ((cl_short*)&v16)[2], ((cl_short*)&v16)[3], ((cl_short*)&v16)[4],
|
|
((cl_short*)&v16)[5], ((cl_short*)&v16)[6], ((cl_short*)&v16)[7], ((cl_short*)&v16)[8],
|
|
((cl_short*)&v16)[9], ((cl_short*)&v16)[10], ((cl_short*)&v16)[11], ((cl_short*)&v16)[12],
|
|
((cl_short*)&v16)[13], ((cl_short*)&v16)[14], ((cl_short*)&v16)[15]);
|
|
#else
|
|
printf("__cl_short16 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
printf("\n");
|
|
return 0;
|
|
}
|
|
|
|
int test_ushort() {
|
|
/* ushort */
|
|
/* Constructor */
|
|
cl_ushort a = 0;
|
|
cl_ushort2 a2 = {{0, 1}};
|
|
cl_ushort4 a4 = {{0, 1, 2, 3}};
|
|
cl_ushort8 a8 = {{0, 1, 2, 3, 4, 5, 6, 7}};
|
|
cl_ushort16 a16 = {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}};
|
|
|
|
/* assignment */
|
|
cl_ushort b = a;
|
|
cl_ushort2 b2 = a2;
|
|
cl_ushort4 b4 = a4;
|
|
cl_ushort8 b8 = a8;
|
|
cl_ushort16 b16 = a16;
|
|
|
|
printf("\nVerifying assignment:\n");
|
|
printf("b: %d\n", b);
|
|
printf("b2: %d %d \n", b2.s[0], b2.s[1]);
|
|
printf("b4: %d %d %d %d\n", b4.s[0], b4.s[1], b4.s[2], b4.s[3]);
|
|
printf("b8: %d %d %d %d %d %d %d %d\n", b8.s[0], b8.s[1], b8.s[2], b8.s[3], b8.s[4], b8.s[5],
|
|
b8.s[6], b8.s[7]);
|
|
printf("b16: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n", b16.s[0], b16.s[1], b16.s[2],
|
|
b16.s[3], b16.s[4], b16.s[5], b16.s[6], b16.s[7], b16.s[8], b16.s[9], b16.s[10], b16.s[11],
|
|
b16.s[12], b16.s[13], b16.s[14], b16.s[15]);
|
|
|
|
/* vector access */
|
|
printf("\nVerifying vector access:\n");
|
|
#if defined(__CL_USHORT2__)
|
|
__cl_ushort2 v2 = b2.v2;
|
|
printf("__cl_ushort2: %d %d \n", ((unsigned short*)&v2)[0], ((unsigned short*)&v2)[1]);
|
|
#else
|
|
printf("__cl_ushort2 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_USHORT4__)
|
|
__cl_ushort4 v4 = b4.v4;
|
|
printf("__cl_ushort4: %d %d %d %d \n", ((unsigned short*)&v4)[0], ((unsigned short*)&v4)[1],
|
|
((unsigned short*)&v4)[2], ((unsigned short*)&v4)[3]);
|
|
#else
|
|
printf("__cl_ushort4 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_USHORT8__)
|
|
__cl_ushort8 v8 = b8.v8;
|
|
printf("__cl_ushort8: %d %d %d %d %d %d %d %d \n", ((unsigned short*)&v8)[0],
|
|
((unsigned short*)&v8)[1], ((unsigned short*)&v8)[2], ((unsigned short*)&v8)[3],
|
|
((unsigned short*)&v8)[4], ((unsigned short*)&v8)[5], ((unsigned short*)&v8)[6],
|
|
((unsigned short*)&v8)[7]);
|
|
#else
|
|
printf("__cl_ushort8 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_USHORT16__)
|
|
__cl_ushort16 v16 = b16.v16;
|
|
printf("__cl_ushort16: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d \n",
|
|
((unsigned short*)&v16)[0], ((unsigned short*)&v16)[1], ((unsigned short*)&v16)[2],
|
|
((unsigned short*)&v16)[3], ((unsigned short*)&v16)[4], ((unsigned short*)&v16)[5],
|
|
((unsigned short*)&v16)[6], ((unsigned short*)&v16)[7], ((unsigned short*)&v16)[8],
|
|
((unsigned short*)&v16)[9], ((unsigned short*)&v16)[10], ((unsigned short*)&v16)[11],
|
|
((unsigned short*)&v16)[12], ((unsigned short*)&v16)[13], ((unsigned short*)&v16)[14],
|
|
((unsigned short*)&v16)[15]);
|
|
#else
|
|
printf("__cl_ushort16 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
printf("\n");
|
|
return 0;
|
|
}
|
|
|
|
int test_int() {
|
|
/* int */
|
|
/* Constructor */
|
|
cl_int a = 0;
|
|
cl_int2 a2 = {{0, 1}};
|
|
cl_int4 a4 = {{0, 1, 2, 3}};
|
|
cl_int8 a8 = {{0, 1, 2, 3, 4, 5, 6, 7}};
|
|
cl_int16 a16 = {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}};
|
|
|
|
/* assignment */
|
|
cl_int b = a;
|
|
cl_int2 b2 = a2;
|
|
cl_int4 b4 = a4;
|
|
cl_int8 b8 = a8;
|
|
cl_int16 b16 = a16;
|
|
|
|
printf("\nVerifying assignment:\n");
|
|
printf("b: %d\n", b);
|
|
printf("b2: %d %d \n", b2.s[0], b2.s[1]);
|
|
printf("b4: %d %d %d %d\n", b4.s[0], b4.s[1], b4.s[2], b4.s[3]);
|
|
printf("b8: %d %d %d %d %d %d %d %d\n", b8.s[0], b8.s[1], b8.s[2], b8.s[3], b8.s[4], b8.s[5],
|
|
b8.s[6], b8.s[7]);
|
|
printf("b16: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n", b16.s[0], b16.s[1], b16.s[2],
|
|
b16.s[3], b16.s[4], b16.s[5], b16.s[6], b16.s[7], b16.s[8], b16.s[9], b16.s[10], b16.s[11],
|
|
b16.s[12], b16.s[13], b16.s[14], b16.s[15]);
|
|
|
|
/* vector access */
|
|
printf("\nVerifying vector access:\n");
|
|
#if defined(__CL_INT2__)
|
|
__cl_int2 v2 = b2.v2;
|
|
printf("__cl_int2: %d %d \n", ((cl_int*)&v2)[0], ((cl_int*)&v2)[1]);
|
|
#else
|
|
printf("__cl_int2 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_INT4__)
|
|
__cl_int4 v4 = b4.v4;
|
|
printf("__cl_int4: %d %d %d %d \n", ((cl_int*)&v4)[0], ((cl_int*)&v4)[1], ((cl_int*)&v4)[2],
|
|
((cl_int*)&v4)[3]);
|
|
#else
|
|
printf("__cl_int4 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_INT8__)
|
|
__cl_int8 v8 = b8.v8;
|
|
printf("__cl_int8: %d %d %d %d %d %d %d %d \n", ((cl_int*)&v8)[0], ((cl_int*)&v8)[1],
|
|
((cl_int*)&v8)[2], ((cl_int*)&v8)[3], ((cl_int*)&v8)[4], ((cl_int*)&v8)[5],
|
|
((cl_int*)&v8)[6], ((cl_int*)&v8)[7]);
|
|
#else
|
|
printf("__cl_int8 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_INT16__)
|
|
__cl_int16 v16 = b16.v16;
|
|
printf("__cl_int16: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d \n", ((cl_int*)&v16)[0],
|
|
((cl_int*)&v16)[1], ((cl_int*)&v16)[2], ((cl_int*)&v16)[3], ((cl_int*)&v16)[4],
|
|
((cl_int*)&v16)[5], ((cl_int*)&v16)[6], ((cl_int*)&v16)[7], ((cl_int*)&v16)[8],
|
|
((cl_int*)&v16)[9], ((cl_int*)&v16)[10], ((cl_int*)&v16)[11], ((cl_int*)&v16)[12],
|
|
((cl_int*)&v16)[13], ((cl_int*)&v16)[14], ((cl_int*)&v16)[15]);
|
|
#else
|
|
printf("__cl_int16 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
printf("\n");
|
|
return 0;
|
|
}
|
|
|
|
int test_uint() {
|
|
/* uint */
|
|
/* Constructor */
|
|
cl_uint a = 0;
|
|
cl_uint2 a2 = {{0, 1}};
|
|
cl_uint4 a4 = {{0, 1, 2, 3}};
|
|
cl_uint8 a8 = {{0, 1, 2, 3, 4, 5, 6, 7}};
|
|
cl_uint16 a16 = {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}};
|
|
|
|
/* assignment */
|
|
cl_uint b = a;
|
|
cl_uint2 b2 = a2;
|
|
cl_uint4 b4 = a4;
|
|
cl_uint8 b8 = a8;
|
|
cl_uint16 b16 = a16;
|
|
|
|
printf("\nVerifying assignment:\n");
|
|
printf("b: %d\n", b);
|
|
printf("b2: %d %d \n", b2.s[0], b2.s[1]);
|
|
printf("b4: %d %d %d %d\n", b4.s[0], b4.s[1], b4.s[2], b4.s[3]);
|
|
printf("b8: %d %d %d %d %d %d %d %d\n", b8.s[0], b8.s[1], b8.s[2], b8.s[3], b8.s[4], b8.s[5],
|
|
b8.s[6], b8.s[7]);
|
|
printf("b16: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n", b16.s[0], b16.s[1], b16.s[2],
|
|
b16.s[3], b16.s[4], b16.s[5], b16.s[6], b16.s[7], b16.s[8], b16.s[9], b16.s[10], b16.s[11],
|
|
b16.s[12], b16.s[13], b16.s[14], b16.s[15]);
|
|
|
|
/* vector access */
|
|
printf("\nVerifying vector access:\n");
|
|
#if defined(__CL_UINT2__)
|
|
__cl_uint2 v2 = b2.v2;
|
|
printf("__cl_uint2: %d %d \n", ((cl_uint*)&v2)[0], ((cl_uint*)&v2)[1]);
|
|
#else
|
|
printf("__cl_uint2 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_UINT4__)
|
|
__cl_uint4 v4 = b4.v4;
|
|
printf("__cl_uint4: %d %d %d %d \n", ((cl_uint*)&v4)[0], ((cl_uint*)&v4)[1], ((cl_uint*)&v4)[2],
|
|
((cl_uint*)&v4)[3]);
|
|
#else
|
|
printf("__cl_uint4 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_UINT8__)
|
|
__cl_uint8 v8 = b8.v8;
|
|
printf("__cl_uint8: %d %d %d %d %d %d %d %d \n", ((cl_uint*)&v8)[0], ((cl_uint*)&v8)[1],
|
|
((cl_uint*)&v8)[2], ((cl_uint*)&v8)[3], ((cl_uint*)&v8)[4], ((cl_uint*)&v8)[5],
|
|
((cl_uint*)&v8)[6], ((cl_uint*)&v8)[7]);
|
|
#else
|
|
printf("__cl_uint8 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_UINT16__)
|
|
__cl_uint16 v16 = b16.v16;
|
|
printf("__cl_uint16: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d \n", ((cl_uint*)&v16)[0],
|
|
((cl_uint*)&v16)[1], ((cl_uint*)&v16)[2], ((cl_uint*)&v16)[3], ((cl_uint*)&v16)[4],
|
|
((cl_uint*)&v16)[5], ((cl_uint*)&v16)[6], ((cl_uint*)&v16)[7], ((cl_uint*)&v16)[8],
|
|
((cl_uint*)&v16)[9], ((cl_uint*)&v16)[10], ((cl_uint*)&v16)[11], ((cl_uint*)&v16)[12],
|
|
((cl_uint*)&v16)[13], ((cl_uint*)&v16)[14], ((cl_uint*)&v16)[15]);
|
|
#else
|
|
printf("__cl_uint16 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
printf("\n");
|
|
return 0;
|
|
}
|
|
|
|
int test_long() {
|
|
/* long */
|
|
/* Constructor */
|
|
cl_long a = 0;
|
|
cl_long2 a2 = {{0, 1}};
|
|
cl_long4 a4 = {{0, 1, 2, 3}};
|
|
cl_long8 a8 = {{0, 1, 2, 3, 4, 5, 6, 7}};
|
|
cl_long16 a16 = {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}};
|
|
|
|
/* assignment */
|
|
cl_long b = a;
|
|
cl_long2 b2 = a2;
|
|
cl_long4 b4 = a4;
|
|
cl_long8 b8 = a8;
|
|
cl_long16 b16 = a16;
|
|
|
|
printf("\nVerifying assignment:\n");
|
|
printf("b: %lld\n", b);
|
|
printf("b2: %lld %lld \n", b2.s[0], b2.s[1]);
|
|
printf("b4: %lld %lld %lld %lld\n", b4.s[0], b4.s[1], b4.s[2], b4.s[3]);
|
|
printf("b8: %lld %lld %lld %lld %lld %lld %lld %lld\n", b8.s[0], b8.s[1], b8.s[2], b8.s[3],
|
|
b8.s[4], b8.s[5], b8.s[6], b8.s[7]);
|
|
printf("b16: %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld\n",
|
|
b16.s[0], b16.s[1], b16.s[2], b16.s[3], b16.s[4], b16.s[5], b16.s[6], b16.s[7], b16.s[8],
|
|
b16.s[9], b16.s[10], b16.s[11], b16.s[12], b16.s[13], b16.s[14], b16.s[15]);
|
|
|
|
/* vector access */
|
|
printf("\nVerifying vector access:\n");
|
|
#if defined(__CL_LONG2__)
|
|
__cl_long2 v2 = b2.v2;
|
|
printf("__cl_long2: %lld %lld \n", ((cl_long*)&v2)[0], ((cl_long*)&v2)[1]);
|
|
#else
|
|
printf("__cl_long2 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_LONG4__)
|
|
__cl_long4 v4 = b4.v4;
|
|
printf("__cl_long4: %lld %lld %lld %lld \n", ((cl_long*)&v4)[0], ((cl_long*)&v4)[1],
|
|
((cl_long*)&v4)[2], ((cl_long*)&v4)[3]);
|
|
#else
|
|
printf("__cl_long4 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_LONG8__)
|
|
__cl_long8 v8 = b8.v8;
|
|
printf("__cl_long8: %lld %lld %lld %lld %lld %lld %lld %lld \n", ((cl_long*)&v8)[0],
|
|
((cl_long*)&v8)[1], ((cl_long*)&v8)[2], ((cl_long*)&v8)[3], ((cl_long*)&v8)[4],
|
|
((cl_long*)&v8)[5], ((cl_long*)&v8)[6], ((cl_long*)&v8)[7]);
|
|
#else
|
|
printf("__cl_long8 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_LONG16__)
|
|
__cl_long16 v16 = b16.v16;
|
|
printf(
|
|
"__cl_long16: %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld "
|
|
"%lld \n",
|
|
((cl_long*)&v16)[0], ((cl_long*)&v16)[1], ((cl_long*)&v16)[2], ((cl_long*)&v16)[3],
|
|
((cl_long*)&v16)[4], ((cl_long*)&v16)[5], ((cl_long*)&v16)[6], ((cl_long*)&v16)[7],
|
|
((cl_long*)&v16)[8], ((cl_long*)&v16)[9], ((cl_long*)&v16)[10], ((cl_long*)&v16)[11],
|
|
((cl_long*)&v16)[12], ((cl_long*)&v16)[13], ((cl_long*)&v16)[14], ((cl_long*)&v16)[15]);
|
|
#else
|
|
printf("__cl_long16 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
printf("\n");
|
|
return 0;
|
|
}
|
|
|
|
int test_ulong() {
|
|
/* ulong */
|
|
/* Constructor */
|
|
cl_ulong a = 0;
|
|
cl_ulong2 a2 = {{0, 1}};
|
|
cl_ulong4 a4 = {{0, 1, 2, 3}};
|
|
cl_ulong8 a8 = {{0, 1, 2, 3, 4, 5, 6, 7}};
|
|
cl_ulong16 a16 = {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}};
|
|
|
|
/* assignment */
|
|
cl_ulong b = a;
|
|
cl_ulong2 b2 = a2;
|
|
cl_ulong4 b4 = a4;
|
|
cl_ulong8 b8 = a8;
|
|
cl_ulong16 b16 = a16;
|
|
|
|
printf("\nVerifying assignment:\n");
|
|
printf("b: %lld\n", b);
|
|
printf("b2: %lld %lld \n", b2.s[0], b2.s[1]);
|
|
printf("b4: %lld %lld %lld %lld\n", b4.s[0], b4.s[1], b4.s[2], b4.s[3]);
|
|
printf("b8: %lld %lld %lld %lld %lld %lld %lld %lld\n", b8.s[0], b8.s[1], b8.s[2], b8.s[3],
|
|
b8.s[4], b8.s[5], b8.s[6], b8.s[7]);
|
|
printf("b16: %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld\n",
|
|
b16.s[0], b16.s[1], b16.s[2], b16.s[3], b16.s[4], b16.s[5], b16.s[6], b16.s[7], b16.s[8],
|
|
b16.s[9], b16.s[10], b16.s[11], b16.s[12], b16.s[13], b16.s[14], b16.s[15]);
|
|
|
|
/* vector access */
|
|
printf("\nVerifying vector access:\n");
|
|
#if defined(__CL_ULONG2__)
|
|
__cl_ulong2 v2 = b2.v2;
|
|
printf("__cl_ulong2: %lld %lld \n", ((cl_ulong*)&v2)[0], ((cl_ulong*)&v2)[1]);
|
|
#else
|
|
printf("__cl_ulong2 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_ULONG4__)
|
|
__cl_ulong4 v4 = b4.v4;
|
|
printf("__cl_ulong4: %lld %lld %lld %lld \n", ((cl_ulong*)&v4)[0], ((cl_ulong*)&v4)[1],
|
|
((cl_ulong*)&v4)[2], ((cl_ulong*)&v4)[3]);
|
|
#else
|
|
printf("__cl_ulong4 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_ULONG8__)
|
|
__cl_ulong8 v8 = b8.v8;
|
|
printf("__cl_ulong8: %lld %lld %lld %lld %lld %lld %lld %lld \n", ((cl_ulong*)&v8)[0],
|
|
((cl_ulong*)&v8)[1], ((cl_ulong*)&v8)[2], ((cl_ulong*)&v8)[3], ((cl_ulong*)&v8)[4],
|
|
((cl_ulong*)&v8)[5], ((cl_ulong*)&v8)[6], ((cl_ulong*)&v8)[7]);
|
|
#else
|
|
printf("__cl_ulong8 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_ULONG16__)
|
|
__cl_ulong16 v16 = b16.v16;
|
|
printf(
|
|
"__cl_ulong16: %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld "
|
|
"%lld \n",
|
|
((cl_ulong*)&v16)[0], ((cl_ulong*)&v16)[1], ((cl_ulong*)&v16)[2], ((cl_ulong*)&v16)[3],
|
|
((cl_ulong*)&v16)[4], ((cl_ulong*)&v16)[5], ((cl_ulong*)&v16)[6], ((cl_ulong*)&v16)[7],
|
|
((cl_ulong*)&v16)[8], ((cl_ulong*)&v16)[9], ((cl_ulong*)&v16)[10], ((cl_ulong*)&v16)[11],
|
|
((cl_ulong*)&v16)[12], ((cl_ulong*)&v16)[13], ((cl_ulong*)&v16)[14], ((cl_ulong*)&v16)[15]);
|
|
#else
|
|
printf("__cl_ulong16 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
printf("\n");
|
|
return 0;
|
|
}
|
|
|
|
int test_float() {
|
|
/* float */
|
|
/* Constructor */
|
|
cl_float a = 0.0f;
|
|
cl_float2 a2 = {{0.0f, 1.0f}};
|
|
cl_float4 a4 = {{0.0f, 1.0f, 2.0f, 3.0f}};
|
|
cl_float8 a8 = {{0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f}};
|
|
cl_float16 a16 = {{0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f,
|
|
12.0f, 13.0f, 14.0f, 15.0f}};
|
|
|
|
/* assignment */
|
|
cl_float b = a;
|
|
cl_float2 b2 = a2;
|
|
cl_float4 b4 = a4;
|
|
cl_float8 b8 = a8;
|
|
cl_float16 b16 = a16;
|
|
|
|
printf("\nVerifying assignment:\n");
|
|
printf("b: %f\n", b);
|
|
printf("b2: %f %f \n", b2.s[0], b2.s[1]);
|
|
printf("b4: %f %f %f %f\n", b4.s[0], b4.s[1], b4.s[2], b4.s[3]);
|
|
printf("b8: %f %f %f %f %f %f %f %f\n", b8.s[0], b8.s[1], b8.s[2], b8.s[3], b8.s[4], b8.s[5],
|
|
b8.s[6], b8.s[7]);
|
|
printf("b16: %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n", b16.s[0], b16.s[1], b16.s[2],
|
|
b16.s[3], b16.s[4], b16.s[5], b16.s[6], b16.s[7], b16.s[8], b16.s[9], b16.s[10], b16.s[11],
|
|
b16.s[12], b16.s[13], b16.s[14], b16.s[15]);
|
|
|
|
/* vector access */
|
|
printf("\nVerifying vector access:\n");
|
|
#if defined(__CL_FLOAT2__)
|
|
__cl_float2 v2 = b2.v2;
|
|
printf("__cl_float2: %f %f \n", ((cl_float*)&v2)[0], ((cl_float*)&v2)[1]);
|
|
#else
|
|
printf("__cl_float2 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_FLOAT4__)
|
|
{
|
|
__cl_float4 v4 = b4.v4;
|
|
printf("__cl_float4: %f %f %f %f \n", ((cl_float*)&v4)[0], ((cl_float*)&v4)[1],
|
|
((cl_float*)&v4)[2], ((cl_float*)&v4)[3]);
|
|
}
|
|
#else
|
|
printf("__cl_float4 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_FLOAT8__)
|
|
__cl_float8 v8 = b8.v8;
|
|
printf("__cl_float8: %f %f %f %f %f %f %f %f \n", ((cl_float*)&v8)[0], ((cl_float*)&v8)[1],
|
|
((cl_float*)&v8)[2], ((cl_float*)&v8)[3], ((cl_float*)&v8)[4], ((cl_float*)&v8)[5],
|
|
((cl_float*)&v8)[6], ((cl_float*)&v8)[7]);
|
|
#else
|
|
printf("__cl_float8 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_FLOAT16__)
|
|
__cl_float16 v16 = b16.v16;
|
|
printf("__cl_float16: %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f \n", ((cl_float*)&v16)[0],
|
|
((cl_float*)&v16)[1], ((cl_float*)&v16)[2], ((cl_float*)&v16)[3], ((cl_float*)&v16)[4],
|
|
((cl_float*)&v16)[5], ((cl_float*)&v16)[6], ((cl_float*)&v16)[7], ((cl_float*)&v16)[8],
|
|
((cl_float*)&v16)[9], ((cl_float*)&v16)[10], ((cl_float*)&v16)[11], ((cl_float*)&v16)[12],
|
|
((cl_float*)&v16)[13], ((cl_float*)&v16)[14], ((cl_float*)&v16)[15]);
|
|
#else
|
|
printf("__cl_float16 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
printf("\n");
|
|
return 0;
|
|
}
|
|
|
|
int test_double() {
|
|
/* double */
|
|
/* Constructor */
|
|
cl_double a = 0.0f;
|
|
cl_double2 a2 = {{0.0f, 1.0f}};
|
|
cl_double4 a4 = {{0.0f, 1.0f, 2.0f, 3.0f}};
|
|
cl_double8 a8 = {{0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f}};
|
|
cl_double16 a16 = {{0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f,
|
|
12.0f, 13.0f, 14.0f, 15.0f}};
|
|
|
|
/* assignment */
|
|
cl_double b = a;
|
|
cl_double2 b2 = a2;
|
|
cl_double4 b4 = a4;
|
|
cl_double8 b8 = a8;
|
|
cl_double16 b16 = a16;
|
|
|
|
printf("\nVerifying assignment:\n");
|
|
printf("b: %f\n", b);
|
|
printf("b2: %f %f \n", b2.s[0], b2.s[1]);
|
|
printf("b4: %f %f %f %f\n", b4.s[0], b4.s[1], b4.s[2], b4.s[3]);
|
|
printf("b8: %f %f %f %f %f %f %f %f\n", b8.s[0], b8.s[1], b8.s[2], b8.s[3], b8.s[4], b8.s[5],
|
|
b8.s[6], b8.s[7]);
|
|
printf("b16: %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n", b16.s[0], b16.s[1], b16.s[2],
|
|
b16.s[3], b16.s[4], b16.s[5], b16.s[6], b16.s[7], b16.s[8], b16.s[9], b16.s[10], b16.s[11],
|
|
b16.s[12], b16.s[13], b16.s[14], b16.s[15]);
|
|
|
|
/* vector access */
|
|
printf("\nVerifying vector access:\n");
|
|
#if defined(__CL_DOUBLE2__)
|
|
__cl_double2 v2 = b2.v2;
|
|
printf("__cl_double2: %f %f \n", ((cl_double*)&v2)[0], ((cl_double*)&v2)[1]);
|
|
#else
|
|
printf("__cl_double2 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_DOUBLE4__)
|
|
__cl_double4 v4 = b4.v4;
|
|
printf("__cl_double4: %f %f %f %f \n", ((cl_double*)&v4)[0], ((cl_double*)&v4)[1],
|
|
((cl_double*)&v4)[2], ((cl_double*)&v4)[3]);
|
|
#else
|
|
printf("__cl_double4 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_DOUBLE8__)
|
|
__cl_double8 v8 = b8.v8;
|
|
printf("__cl_double8: %f %f %f %f %f %f %f %f \n", ((cl_double*)&v8)[0], ((cl_double*)&v8)[1],
|
|
((cl_double*)&v8)[2], ((cl_double*)&v8)[3], ((cl_double*)&v8)[4], ((cl_double*)&v8)[5],
|
|
((cl_double*)&v8)[6], ((cl_double*)&v8)[7]);
|
|
#else
|
|
printf("__cl_double8 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
#if defined(__CL_DOUBLE16__)
|
|
__cl_double16 v16 = b16.v16;
|
|
printf("__cl_double16: %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f \n", ((cl_double*)&v16)[0],
|
|
((cl_double*)&v16)[1], ((cl_double*)&v16)[2], ((cl_double*)&v16)[3], ((cl_double*)&v16)[4],
|
|
((cl_double*)&v16)[5], ((cl_double*)&v16)[6], ((cl_double*)&v16)[7], ((cl_double*)&v16)[8],
|
|
((cl_double*)&v16)[9], ((cl_double*)&v16)[10], ((cl_double*)&v16)[11],
|
|
((cl_double*)&v16)[12], ((cl_double*)&v16)[13], ((cl_double*)&v16)[14],
|
|
((cl_double*)&v16)[15]);
|
|
#else
|
|
printf("__cl_double16 SIMD vectors not supported on this architecture.\n");
|
|
#endif
|
|
|
|
printf("\n");
|
|
return 0;
|
|
}
|
|
|
|
int main(void) {
|
|
printf(
|
|
"\nChecking operations on cl_types.\nNumbers, where presented, should walk upward from 0, "
|
|
"with step of 1:\n");
|
|
|
|
test_char();
|
|
test_uchar();
|
|
test_short();
|
|
test_ushort();
|
|
test_long();
|
|
test_ulong();
|
|
test_float();
|
|
test_double();
|
|
|
|
return 0;
|
|
}
|