mirror of
https://github.com/KhronosGroup/OpenCL-CTS.git
synced 2026-03-19 14:09:03 +00:00
704 lines
20 KiB
C++
704 lines
20 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.
|
|
//
|
|
#ifndef TEST_CONFORMANCE_CLCPP_INTEGER_FUNCS_NUMERIC_HPP
|
|
#define TEST_CONFORMANCE_CLCPP_INTEGER_FUNCS_NUMERIC_HPP
|
|
|
|
#include "common.hpp"
|
|
#include <type_traits>
|
|
|
|
template<class IN1, class OUT1>
|
|
struct int_func_abs : public unary_func<IN1, OUT1>
|
|
{
|
|
std::string str()
|
|
{
|
|
return "abs";
|
|
}
|
|
|
|
std::string headers()
|
|
{
|
|
return "#include <opencl_integer>\n";
|
|
}
|
|
|
|
OUT1 operator()(const IN1& x)
|
|
{
|
|
static_assert(
|
|
std::is_unsigned<OUT1>::value,
|
|
"OUT1 type must be unsigned"
|
|
);
|
|
if(x < IN1(0))
|
|
return static_cast<OUT1>(-x);
|
|
return static_cast<OUT1>(x);
|
|
}
|
|
};
|
|
|
|
template<class IN1, class IN2, class OUT1>
|
|
struct int_func_abs_diff : public binary_func<IN1, IN2, OUT1>
|
|
{
|
|
std::string str()
|
|
{
|
|
return "abs_diff";
|
|
}
|
|
|
|
std::string headers()
|
|
{
|
|
return "#include <opencl_integer>\n";
|
|
}
|
|
|
|
OUT1 operator()(const IN1& x, const IN2& y)
|
|
{
|
|
static_assert(
|
|
std::is_same<IN1, IN2>::value,
|
|
"IN1 must be IN2"
|
|
);
|
|
static_assert(
|
|
std::is_unsigned<OUT1>::value,
|
|
"OUT1 type must be unsigned"
|
|
);
|
|
if(x < y)
|
|
return static_cast<OUT1>(y-x);
|
|
return static_cast<OUT1>(x-y);
|
|
}
|
|
};
|
|
|
|
template<class IN1, class IN2, class OUT1>
|
|
struct int_func_add_sat : public binary_func<IN1, IN2, OUT1>
|
|
{
|
|
std::string str()
|
|
{
|
|
return "add_sat";
|
|
}
|
|
|
|
std::string headers()
|
|
{
|
|
return "#include <opencl_integer>\n";
|
|
}
|
|
|
|
OUT1 operator()(const IN1& x, const IN2& y)
|
|
{
|
|
static_assert(
|
|
std::is_same<IN1, IN2>::value,
|
|
"IN1 must be IN2"
|
|
);
|
|
static_assert(
|
|
std::is_same<OUT1, IN2>::value,
|
|
"OUT1 must be IN2"
|
|
);
|
|
// sat unsigned integers
|
|
if(std::is_unsigned<OUT1>::value)
|
|
{
|
|
OUT1 z = x + y;
|
|
if(z < x || z < y)
|
|
return (std::numeric_limits<OUT1>::max)();
|
|
return z;
|
|
}
|
|
// sat signed integers
|
|
OUT1 z = x + y;
|
|
if(y > 0)
|
|
{
|
|
if(z < x)
|
|
return (std::numeric_limits<OUT1>::max)();
|
|
}
|
|
else
|
|
{
|
|
if(z > x)
|
|
return (std::numeric_limits<OUT1>::min)();
|
|
}
|
|
return z;
|
|
}
|
|
};
|
|
|
|
template<class IN1, class IN2, class OUT1>
|
|
struct int_func_hadd : public binary_func<IN1, IN2, OUT1>
|
|
{
|
|
std::string str()
|
|
{
|
|
return "hadd";
|
|
}
|
|
|
|
std::string headers()
|
|
{
|
|
return "#include <opencl_integer>\n";
|
|
}
|
|
|
|
OUT1 operator()(const IN1& x, const IN2& y)
|
|
{
|
|
static_assert(
|
|
std::is_same<IN1, IN2>::value,
|
|
"IN1 must be IN2"
|
|
);
|
|
static_assert(
|
|
std::is_same<OUT1, IN2>::value,
|
|
"OUT1 must be IN2"
|
|
);
|
|
return (x >> OUT1(1)) + (y >> OUT1(1)) + (x & y & OUT1(1));
|
|
}
|
|
};
|
|
|
|
template<class IN1, class IN2, class OUT1>
|
|
struct int_func_rhadd : public binary_func<IN1, IN2, OUT1>
|
|
{
|
|
std::string str()
|
|
{
|
|
return "rhadd";
|
|
}
|
|
|
|
std::string headers()
|
|
{
|
|
return "#include <opencl_integer>\n";
|
|
}
|
|
|
|
OUT1 operator()(const IN1& x, const IN2& y)
|
|
{
|
|
static_assert(
|
|
std::is_same<IN1, IN2>::value,
|
|
"IN1 must be IN2"
|
|
);
|
|
static_assert(
|
|
std::is_same<OUT1, IN2>::value,
|
|
"OUT1 must be IN2"
|
|
);
|
|
return (x >> OUT1(1)) + (y >> OUT1(1)) + ((x | y) & OUT1(1));
|
|
}
|
|
};
|
|
|
|
// clamp for scalars
|
|
template<class IN1, class IN2, class IN3, class OUT1, class Enable = void>
|
|
struct int_func_clamp : public ternary_func<IN1, IN2, IN3, OUT1>
|
|
{
|
|
std::string str()
|
|
{
|
|
return "clamp";
|
|
}
|
|
|
|
std::string headers()
|
|
{
|
|
return "#include <opencl_integer>\n";
|
|
}
|
|
|
|
OUT1 operator()(const IN1& x, const IN2& minval, const IN3& maxval)
|
|
{
|
|
static_assert(
|
|
std::is_same<IN2, IN3>::value,
|
|
"IN3 must be IN2"
|
|
);
|
|
static_assert(
|
|
std::is_same<OUT1, IN1>::value,
|
|
"OUT1 must be IN1"
|
|
);
|
|
return (std::min)((std::max)(x, minval), maxval);
|
|
}
|
|
|
|
IN2 min2()
|
|
{
|
|
return (std::numeric_limits<IN2>::min)();
|
|
}
|
|
|
|
IN2 max2()
|
|
{
|
|
return (std::numeric_limits<IN2>::max)() / IN2(2);
|
|
}
|
|
|
|
IN3 min3()
|
|
{
|
|
return IN3(1) + ((std::numeric_limits<IN3>::max)() / IN3(2));
|
|
}
|
|
|
|
IN3 max3()
|
|
{
|
|
return (std::numeric_limits<IN3>::max)();
|
|
}
|
|
};
|
|
|
|
// gentype clamp(gentype x, scalar minval, scalar maxval);
|
|
template<class IN1, class IN2, class IN3, class OUT1>
|
|
struct int_func_clamp<IN1, IN2, IN3, OUT1, typename std::enable_if<is_vector_type<OUT1>::value>::type> : public ternary_func<IN1, IN2, IN3, OUT1>
|
|
{
|
|
std::string str()
|
|
{
|
|
return "clamp";
|
|
}
|
|
|
|
std::string headers()
|
|
{
|
|
return "#include <opencl_integer>\n";
|
|
}
|
|
|
|
OUT1 operator()(const IN1& x, const IN2& minval, const IN3& maxval)
|
|
{
|
|
static_assert(
|
|
std::is_same<IN2, IN3>::value,
|
|
"IN3 must be IN2"
|
|
);
|
|
static_assert(
|
|
!is_vector_type<IN2>::value && !is_vector_type<IN3>::value,
|
|
"IN3 and IN2 must be scalar"
|
|
);
|
|
static_assert(
|
|
std::is_same<OUT1, IN1>::value,
|
|
"OUT1 must be IN1"
|
|
);
|
|
OUT1 result;
|
|
for(size_t i = 0; i < vector_size<OUT1>::value; i++)
|
|
{
|
|
result.s[i] = (std::min)((std::max)(x.s[i], minval), maxval);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
IN1 min1()
|
|
{
|
|
typedef typename scalar_type<IN1>::type SCALAR1;
|
|
IN1 min1;
|
|
for(size_t i = 0; i < vector_size<IN1>::value; i++)
|
|
{
|
|
min1.s[i] = (std::numeric_limits<SCALAR1>::min)();
|
|
}
|
|
return min1;
|
|
}
|
|
|
|
IN1 max1()
|
|
{
|
|
typedef typename scalar_type<IN1>::type SCALAR1;
|
|
IN1 max1;
|
|
for(size_t i = 0; i < vector_size<IN1>::value; i++)
|
|
{
|
|
max1.s[i] = (std::numeric_limits<SCALAR1>::max)();
|
|
}
|
|
return max1;
|
|
}
|
|
|
|
IN2 min2()
|
|
{
|
|
return (std::numeric_limits<IN2>::min)();
|
|
}
|
|
|
|
IN2 max2()
|
|
{
|
|
return (std::numeric_limits<IN2>::max)() / IN2(2);
|
|
}
|
|
|
|
IN3 min3()
|
|
{
|
|
return IN3(1) + ((std::numeric_limits<IN3>::max)() / IN3(2));
|
|
}
|
|
|
|
IN3 max3()
|
|
{
|
|
return (std::numeric_limits<IN3>::max)();
|
|
}
|
|
};
|
|
|
|
template<class IN1, class IN2, class OUT1>
|
|
struct int_func_mul_hi : public binary_func<IN1, IN2, OUT1>
|
|
{
|
|
std::string str()
|
|
{
|
|
return "mul_hi";
|
|
}
|
|
|
|
std::string headers()
|
|
{
|
|
return "#include <opencl_integer>\n";
|
|
}
|
|
|
|
OUT1 operator()(const IN1& x, const IN2& y)
|
|
{
|
|
static_assert(
|
|
std::is_same<IN1, IN2>::value
|
|
&& std::is_same<IN2, OUT1>::value,
|
|
"Types must be the same"
|
|
);
|
|
static_assert(
|
|
!std::is_same<IN1, cl_long>::value && !std::is_same<IN1, cl_ulong>::value,
|
|
"Operation unimplemented for 64-bit scalars"
|
|
);
|
|
cl_long xl = static_cast<cl_long>(x);
|
|
cl_long yl = static_cast<cl_long>(y);
|
|
return static_cast<OUT1>((xl * yl) >> (8 * sizeof(OUT1)));
|
|
}
|
|
};
|
|
|
|
template<class IN1, class IN2, class IN3, class OUT1>
|
|
struct int_func_mad_hi : public ternary_func<IN1, IN2, IN3, OUT1>
|
|
{
|
|
std::string str()
|
|
{
|
|
return "mad_hi";
|
|
}
|
|
|
|
std::string headers()
|
|
{
|
|
return "#include <opencl_integer>\n";
|
|
}
|
|
|
|
OUT1 operator()(const IN1& x, const IN2& y, const IN3& z)
|
|
{
|
|
static_assert(
|
|
std::is_same<IN1, IN2>::value
|
|
&& std::is_same<IN2, IN3>::value
|
|
&& std::is_same<IN3, OUT1>::value,
|
|
"Types must be the same"
|
|
);
|
|
return int_func_mul_hi<IN1, IN2, OUT1>()(x, y) + z;
|
|
}
|
|
};
|
|
|
|
// This test is implemented only for unsigned integers
|
|
template<class IN1, class IN2, class IN3, class OUT1>
|
|
struct int_func_mad_sat : public ternary_func<IN1, IN2, IN3, OUT1>
|
|
{
|
|
std::string str()
|
|
{
|
|
return "mad_sat";
|
|
}
|
|
|
|
std::string headers()
|
|
{
|
|
return "#include <opencl_integer>\n";
|
|
}
|
|
|
|
OUT1 operator()(const IN1& x, const IN2& y, const IN3& z)
|
|
{
|
|
static_assert(
|
|
std::is_same<IN1, IN2>::value
|
|
&& std::is_same<IN2, IN3>::value
|
|
&& std::is_same<IN3, OUT1>::value,
|
|
"Types must be the same"
|
|
);
|
|
static_assert(
|
|
std::is_unsigned<OUT1>::value,
|
|
"Test operation is not implemented for signed integers"
|
|
);
|
|
// mad_sat unsigned integers
|
|
OUT1 w1 = (x * y);
|
|
if (x != 0 && w1 / x != y)
|
|
return (std::numeric_limits<OUT1>::max)();
|
|
OUT1 w2 = w1 + z;
|
|
if(w2 < w1)
|
|
return (std::numeric_limits<OUT1>::max)();
|
|
return w2;
|
|
}
|
|
};
|
|
|
|
template<class IN1, class IN2, class OUT1>
|
|
struct int_func_sub_sat : public binary_func<IN1, IN2, OUT1>
|
|
{
|
|
std::string str()
|
|
{
|
|
return "sub_sat";
|
|
}
|
|
|
|
std::string headers()
|
|
{
|
|
return "#include <opencl_integer>\n";
|
|
}
|
|
|
|
OUT1 operator()(const IN1& x, const IN2& y)
|
|
{
|
|
static_assert(
|
|
std::is_same<IN1, IN2>::value && std::is_same<IN2, OUT1>::value,
|
|
"IN1, IN2 and OUT1 must be the same types"
|
|
);
|
|
// sat unsigned integers
|
|
if(std::is_unsigned<OUT1>::value)
|
|
{
|
|
OUT1 z = x - y;
|
|
if(x < y)
|
|
return (std::numeric_limits<OUT1>::min)();
|
|
return z;
|
|
}
|
|
// sat signed integers
|
|
OUT1 z = x - y;
|
|
if(y < 0)
|
|
{
|
|
if(z < x)
|
|
return (std::numeric_limits<OUT1>::max)();
|
|
}
|
|
else
|
|
{
|
|
if(z > x)
|
|
return (std::numeric_limits<OUT1>::min)();
|
|
}
|
|
return z;
|
|
}
|
|
};
|
|
|
|
template<class IN1, class IN2, class OUT1, class Enable = void>
|
|
struct int_func_max : public binary_func<IN1, IN2, OUT1>
|
|
{
|
|
std::string str()
|
|
{
|
|
return "max";
|
|
}
|
|
|
|
std::string headers()
|
|
{
|
|
return "#include <opencl_integer>\n";
|
|
}
|
|
|
|
OUT1 operator()(const IN1& x, const IN2& y)
|
|
{
|
|
static_assert(
|
|
std::is_same<IN1, IN2>::value && std::is_same<IN2, OUT1>::value,
|
|
"IN1, IN2 and OUT1 must be the same types"
|
|
);
|
|
return (std::max)(x, y);
|
|
}
|
|
};
|
|
|
|
template<class IN1, class IN2, class OUT1>
|
|
struct int_func_max<IN1, IN2, OUT1, typename std::enable_if<is_vector_type<OUT1>::value>::type> : public binary_func<IN1, IN2, OUT1>
|
|
{
|
|
std::string str()
|
|
{
|
|
return "max";
|
|
}
|
|
|
|
std::string headers()
|
|
{
|
|
return "#include <opencl_integer>\n";
|
|
}
|
|
|
|
IN1 min1()
|
|
{
|
|
typedef typename scalar_type<IN1>::type SCALAR1;
|
|
IN1 min1;
|
|
for(size_t i = 0; i < vector_size<IN1>::value; i++)
|
|
{
|
|
min1.s[i] = (std::numeric_limits<SCALAR1>::min)();
|
|
}
|
|
return min1;
|
|
}
|
|
|
|
IN1 max1()
|
|
{
|
|
typedef typename scalar_type<IN1>::type SCALAR1;
|
|
IN1 max1;
|
|
for(size_t i = 0; i < vector_size<IN1>::value; i++)
|
|
{
|
|
max1.s[i] = (std::numeric_limits<SCALAR1>::max)();
|
|
}
|
|
return max1;
|
|
}
|
|
|
|
OUT1 operator()(const IN1& x, const IN2& y)
|
|
{
|
|
static_assert(
|
|
std::is_same<IN1, OUT1>::value,
|
|
"IN1 and OUT1 must be the same types"
|
|
);
|
|
static_assert(
|
|
!is_vector_type<IN2>::value,
|
|
"IN2 must be scalar"
|
|
);
|
|
static_assert(
|
|
std::is_same<typename scalar_type<OUT1>::type, IN2>::value,
|
|
"IN2 must match with OUT1 and IN1"
|
|
);
|
|
IN1 result = x;
|
|
for(size_t i = 0; i < vector_size<IN1>::value; i++)
|
|
{
|
|
result.s[i] = (std::max)(x.s[i], y);
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
|
|
template<class IN1, class IN2, class OUT1, class Enable = void>
|
|
struct int_func_min : public binary_func<IN1, IN2, OUT1>
|
|
{
|
|
std::string str()
|
|
{
|
|
return "min";
|
|
}
|
|
|
|
std::string headers()
|
|
{
|
|
return "#include <opencl_integer>\n";
|
|
}
|
|
|
|
OUT1 operator()(const IN1& x, const IN2& y)
|
|
{
|
|
static_assert(
|
|
std::is_same<IN1, IN2>::value && std::is_same<IN2, OUT1>::value,
|
|
"IN1, IN2 and OUT1 must be the same types"
|
|
);
|
|
return (std::min)(x, y);
|
|
}
|
|
};
|
|
|
|
template<class IN1, class IN2, class OUT1>
|
|
struct int_func_min<IN1, IN2, OUT1, typename std::enable_if<is_vector_type<OUT1>::value>::type> : public binary_func<IN1, IN2, OUT1>
|
|
{
|
|
std::string str()
|
|
{
|
|
return "min";
|
|
}
|
|
|
|
std::string headers()
|
|
{
|
|
return "#include <opencl_integer>\n";
|
|
}
|
|
|
|
IN1 min1()
|
|
{
|
|
typedef typename scalar_type<IN1>::type SCALAR1;
|
|
IN1 min1;
|
|
for(size_t i = 0; i < vector_size<IN1>::value; i++)
|
|
{
|
|
min1.s[i] = (std::numeric_limits<SCALAR1>::min)();
|
|
}
|
|
return min1;
|
|
}
|
|
|
|
IN1 max1()
|
|
{
|
|
typedef typename scalar_type<IN1>::type SCALAR1;
|
|
IN1 max1;
|
|
for(size_t i = 0; i < vector_size<IN1>::value; i++)
|
|
{
|
|
max1.s[i] = (std::numeric_limits<SCALAR1>::max)();
|
|
}
|
|
return max1;
|
|
}
|
|
|
|
OUT1 operator()(const IN1& x, const IN2& y)
|
|
{
|
|
static_assert(
|
|
std::is_same<IN1, OUT1>::value,
|
|
"IN1 and OUT1 must be the same types"
|
|
);
|
|
static_assert(
|
|
!is_vector_type<IN2>::value,
|
|
"IN2 must be scalar"
|
|
);
|
|
static_assert(
|
|
std::is_same<typename scalar_type<OUT1>::type, IN2>::value,
|
|
"IN2 must match with OUT1 and IN1"
|
|
);
|
|
IN1 result = x;
|
|
for(size_t i = 0; i < vector_size<IN1>::value; i++)
|
|
{
|
|
result.s[i] = (std::min)(x.s[i], y);
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
|
|
AUTO_TEST_CASE(test_int_numeric_funcs)
|
|
(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
|
|
{
|
|
int error = CL_SUCCESS;
|
|
int last_error = CL_SUCCESS;
|
|
|
|
// ugentype abs(gentype x);
|
|
TEST_UNARY_FUNC_MACRO((int_func_abs<cl_int, cl_uint>()))
|
|
TEST_UNARY_FUNC_MACRO((int_func_abs<cl_uint, cl_uint>()))
|
|
TEST_UNARY_FUNC_MACRO((int_func_abs<cl_long, cl_ulong>()))
|
|
TEST_UNARY_FUNC_MACRO((int_func_abs<cl_ulong, cl_ulong>()))
|
|
|
|
// ugentype abs_diff(gentype x, gentype y);
|
|
TEST_BINARY_FUNC_MACRO((int_func_abs_diff<cl_int, cl_int, cl_uint>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_abs_diff<cl_uint, cl_uint, cl_uint>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_abs_diff<cl_long, cl_long, cl_ulong>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_abs_diff<cl_ulong, cl_ulong, cl_ulong>()))
|
|
|
|
// gentype add_sat(gentype x, gentype y);
|
|
TEST_BINARY_FUNC_MACRO((int_func_add_sat<cl_int, cl_int, cl_int>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_add_sat<cl_uint, cl_uint, cl_uint>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_add_sat<cl_long, cl_long, cl_long>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_add_sat<cl_ulong, cl_ulong, cl_ulong>()))
|
|
|
|
// gentype hadd(gentype x, gentype y);
|
|
TEST_BINARY_FUNC_MACRO((int_func_hadd<cl_int, cl_int, cl_int>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_hadd<cl_uint, cl_uint, cl_uint>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_hadd<cl_long, cl_long, cl_long>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_hadd<cl_ulong, cl_ulong, cl_ulong>()))
|
|
|
|
// gentype rhadd(gentype x, gentype y);
|
|
TEST_BINARY_FUNC_MACRO((int_func_rhadd<cl_int, cl_int, cl_int>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_rhadd<cl_uint, cl_uint, cl_uint>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_rhadd<cl_long, cl_long, cl_long>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_rhadd<cl_ulong, cl_ulong, cl_ulong>()))
|
|
|
|
// gentype clamp(gentype x, gentype minval, gentype maxval);
|
|
TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_int, cl_int, cl_int, cl_int>()))
|
|
TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_uint, cl_uint, cl_uint, cl_uint>()))
|
|
TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_long, cl_long, cl_long, cl_long>()))
|
|
TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_ulong, cl_ulong, cl_ulong, cl_ulong>()))
|
|
|
|
// gentype clamp(gentype x, scalar minval, scalar maxval);
|
|
TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_int2, cl_int, cl_int, cl_int2>()))
|
|
TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_uint4, cl_uint, cl_uint, cl_uint4>()))
|
|
TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_long8, cl_long, cl_long, cl_long8>()))
|
|
TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_ulong16, cl_ulong, cl_ulong, cl_ulong16>()))
|
|
|
|
// gentype mad_hi(gentype a, gentype b, gentype c);
|
|
TEST_TERNARY_FUNC_MACRO((int_func_mad_hi<cl_short, cl_short, cl_short, cl_short>()))
|
|
TEST_TERNARY_FUNC_MACRO((int_func_mad_hi<cl_ushort, cl_ushort, cl_ushort, cl_ushort>()))
|
|
TEST_TERNARY_FUNC_MACRO((int_func_mad_hi<cl_int, cl_int, cl_int, cl_int>()))
|
|
TEST_TERNARY_FUNC_MACRO((int_func_mad_hi<cl_uint, cl_uint, cl_uint, cl_uint>()))
|
|
|
|
// gentype mad_sat(gentype a, gentype b, gentype c);
|
|
TEST_TERNARY_FUNC_MACRO((int_func_mad_sat<cl_ushort, cl_ushort, cl_ushort, cl_ushort>()))
|
|
TEST_TERNARY_FUNC_MACRO((int_func_mad_sat<cl_uint, cl_uint, cl_uint, cl_uint>()))
|
|
TEST_TERNARY_FUNC_MACRO((int_func_mad_sat<cl_ulong, cl_ulong, cl_ulong, cl_ulong>()))
|
|
|
|
// gentype max(gentype x, gentype y);
|
|
TEST_BINARY_FUNC_MACRO((int_func_max<cl_int, cl_int, cl_int>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_max<cl_uint, cl_uint, cl_uint>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_max<cl_long, cl_long, cl_long>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_max<cl_ulong, cl_ulong, cl_ulong>()))
|
|
|
|
// gentype max(gentype x, scalar y);
|
|
TEST_BINARY_FUNC_MACRO((int_func_max<cl_int2, cl_int, cl_int2>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_max<cl_uint4, cl_uint, cl_uint4>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_max<cl_long8, cl_long, cl_long8>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_max<cl_ulong16, cl_ulong, cl_ulong16>()))
|
|
|
|
// gentype min(gentype x, gentype y);
|
|
TEST_BINARY_FUNC_MACRO((int_func_min<cl_int, cl_int, cl_int>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_min<cl_uint, cl_uint, cl_uint>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_min<cl_long, cl_long, cl_long>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_min<cl_ulong, cl_ulong, cl_ulong>()))
|
|
|
|
// gentype min(gentype x, scalar y);
|
|
TEST_BINARY_FUNC_MACRO((int_func_min<cl_int2, cl_int, cl_int2>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_min<cl_uint4, cl_uint, cl_uint4>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_min<cl_long8, cl_long, cl_long8>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_min<cl_ulong16, cl_ulong, cl_ulong16>()))
|
|
|
|
// gentype mul_hi(gentype x, gentype y);
|
|
TEST_BINARY_FUNC_MACRO((int_func_mul_hi<cl_short, cl_short, cl_short>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_mul_hi<cl_ushort, cl_ushort, cl_ushort>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_mul_hi<cl_int, cl_int, cl_int>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_mul_hi<cl_uint, cl_uint, cl_uint>()))
|
|
|
|
// gentype sub_sat(gentype x, gentype y);
|
|
TEST_BINARY_FUNC_MACRO((int_func_sub_sat<cl_int, cl_int, cl_int>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_sub_sat<cl_uint, cl_uint, cl_uint>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_sub_sat<cl_long, cl_long, cl_long>()))
|
|
TEST_BINARY_FUNC_MACRO((int_func_sub_sat<cl_ulong, cl_ulong, cl_ulong>()))
|
|
|
|
if(error != CL_SUCCESS)
|
|
{
|
|
return -1;
|
|
}
|
|
return error;
|
|
}
|
|
|
|
#endif // TEST_CONFORMANCE_CLCPP_INTEGER_FUNCS_NUMERIC_HPP
|