gaspersic/triton
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

C++: Now using standard C++ types instead of stdint

Browse Source
This commit is contained in:
Philippe Tillet
2015-05-04 21:23:05 -04:00
parent 5cdbef7b4e
commit 278109eef8
5 changed files with 273 additions and 257 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
include/isaac/array.h
View File

@@ -2,7 +2,6 @@
#define ISAAC_ARRAY_H_
#include <iostream>
#include <CL/cl.hpp>
#include "isaac/types.h"
#include "isaac/driver/backend.h"
#include "isaac/symbolic/expression.h"
@@ -98,7 +97,10 @@ protected:
class scalar : public array
{
friend value_scalar::value_scalar(const scalar &);
friend value_scalar::value_scalar(const array_expression &);
private:
void inject(values_holder&) const;
template<class T> T cast() const;
public:
explicit scalar(numeric_type dtype, driver::Buffer const & data, int_t offset, driver::Context context = driver::queues.default_context());
@@ -110,17 +112,16 @@ public:
using array::operator =;
#define INSTANTIATE(type) operator type() const;
INSTANTIATE(bool)
INSTANTIATE(cl_char)
INSTANTIATE(cl_uchar)
INSTANTIATE(cl_short)
INSTANTIATE(cl_ushort)
INSTANTIATE(cl_int)
INSTANTIATE(cl_uint)
INSTANTIATE(cl_long)
INSTANTIATE(cl_ulong)
INSTANTIATE(cl_float)
INSTANTIATE(cl_double)
INSTANTIATE(char)
INSTANTIATE(unsigned char)
INSTANTIATE(short)
INSTANTIATE(unsigned short)
INSTANTIATE(int)
INSTANTIATE(unsigned int)
INSTANTIATE(long)
INSTANTIATE(unsigned long)
INSTANTIATE(float)
INSTANTIATE(double)
#undef INSTANTIATE
};

38
include/isaac/types.h
View File

@@ -77,20 +77,6 @@ inline std::string numeric_type_to_string(numeric_type const & type)
}
}
template<class T> struct to_numeric_type;
//template<> struct to_numeric_type<cl_bool> { static const numeric_type value = BOOL_TYPE; };
template<> struct to_numeric_type<cl_char> { static const numeric_type value = CHAR_TYPE; };
template<> struct to_numeric_type<cl_uchar> { static const numeric_type value = UCHAR_TYPE; };
template<> struct to_numeric_type<cl_short> { static const numeric_type value = SHORT_TYPE; };
template<> struct to_numeric_type<cl_ushort> { static const numeric_type value = USHORT_TYPE; };
template<> struct to_numeric_type<cl_int> { static const numeric_type value = INT_TYPE; };
template<> struct to_numeric_type<cl_uint> { static const numeric_type value = UINT_TYPE; };
template<> struct to_numeric_type<cl_long> { static const numeric_type value = LONG_TYPE; };
template<> struct to_numeric_type<cl_ulong> { static const numeric_type value = ULONG_TYPE; };
//template<> struct to_numeric_type<cl_float> { static const numeric_type value = HALF_TYPE; };
template<> struct to_numeric_type<cl_float> { static const numeric_type value = FLOAT_TYPE; };
template<> struct to_numeric_type<cl_double> { static const numeric_type value = DOUBLE_TYPE; };
inline unsigned int size_of(numeric_type type)
{
switch (type)
@@ -115,6 +101,30 @@ inline unsigned int size_of(numeric_type type)
}
}
template<size_t size, bool is_unsigned>
struct to_int_numeric_type_impl;
#define ISAAC_INSTANTIATE_INT_TYPE_IMPL(SIZE, IS_UNSIGNED, TYPE) \
template<> struct to_int_numeric_type_impl<SIZE, IS_UNSIGNED> { static const numeric_type value = TYPE; }
ISAAC_INSTANTIATE_INT_TYPE_IMPL(1, false, CHAR_TYPE);
ISAAC_INSTANTIATE_INT_TYPE_IMPL(2, false, SHORT_TYPE);
ISAAC_INSTANTIATE_INT_TYPE_IMPL(4, false, INT_TYPE);
ISAAC_INSTANTIATE_INT_TYPE_IMPL(8, false, LONG_TYPE);
ISAAC_INSTANTIATE_INT_TYPE_IMPL(1, true, UCHAR_TYPE);
ISAAC_INSTANTIATE_INT_TYPE_IMPL(2, true, USHORT_TYPE);
ISAAC_INSTANTIATE_INT_TYPE_IMPL(4, true, UINT_TYPE);
ISAAC_INSTANTIATE_INT_TYPE_IMPL(8, true, ULONG_TYPE);
#undef ISAAC_INSTANTIATE_INT_TYPE_IMPL
template<class T>
struct to_int_numeric_type
{ static const numeric_type value = to_int_numeric_type_impl<sizeof(T), std::is_unsigned<T>::value>::value; };
template<class T> struct to_numeric_type { static const numeric_type value = to_int_numeric_type<T>::value; };
template<> struct to_numeric_type<float> { static const numeric_type value = FLOAT_TYPE; };
template<> struct to_numeric_type<double> { static const numeric_type value = DOUBLE_TYPE; };
enum expression_type
{
SCALAR_AXPY_TYPE,

96
include/isaac/value_scalar.h
View File

@@ -12,7 +12,6 @@ class array_expression;
union values_holder
{
// int8_t bool8;
int8_t int8;
u_int8_t uint8;
int16_t int16;
@@ -21,9 +20,8 @@ union values_holder
u_int32_t uint32;
int64_t int64;
u_int64_t uint64;
// cl_half float16;
cl_float float32;
cl_double float64;
float float32;
double float64;
};
class value_scalar
@@ -31,19 +29,17 @@ class value_scalar
template<class T> void init(T const &);
template<class T> T cast() const;
public:
#define ISAAC_INSTANTIATE(CLTYPE, ADTYPE) value_scalar(CLTYPE value, numeric_type dtype = ADTYPE);
// ISAAC_INSTANTIATE(cl_bool, BOOL_TYPE)
ISAAC_INSTANTIATE(int8_t, CHAR_TYPE)
ISAAC_INSTANTIATE(uint8_t, UCHAR_TYPE)
ISAAC_INSTANTIATE(int16_t, SHORT_TYPE)
ISAAC_INSTANTIATE(u_int16_t, USHORT_TYPE)
ISAAC_INSTANTIATE(int32_t, INT_TYPE)
ISAAC_INSTANTIATE(u_int32_t, UINT_TYPE)
ISAAC_INSTANTIATE(int64_t, LONG_TYPE)
ISAAC_INSTANTIATE(u_int64_t, ULONG_TYPE)
// ISAAC_INSTANTIATE(cl_half, HALF_TYPE)
ISAAC_INSTANTIATE(cl_float, FLOAT_TYPE)
ISAAC_INSTANTIATE(cl_double, DOUBLE_TYPE)
#define ISAAC_INSTANTIATE(TYPE) value_scalar(TYPE value, numeric_type dtype = to_numeric_type<TYPE>::value);
ISAAC_INSTANTIATE(char)
ISAAC_INSTANTIATE(unsigned char)
ISAAC_INSTANTIATE(short)
ISAAC_INSTANTIATE(unsigned short)
ISAAC_INSTANTIATE(int)
ISAAC_INSTANTIATE(unsigned int)
ISAAC_INSTANTIATE(long)
ISAAC_INSTANTIATE(unsigned long)
ISAAC_INSTANTIATE(float)
ISAAC_INSTANTIATE(double)
#undef ISAAC_INSTANTIATE
value_scalar(values_holder value, numeric_type dtype);
explicit value_scalar(scalar const &);
@@ -55,16 +51,16 @@ public:
#define INSTANTIATE(type) operator type() const;
INSTANTIATE(bool)
INSTANTIATE(int8_t)
INSTANTIATE(uint8_t)
INSTANTIATE(int16_t)
INSTANTIATE(u_int16_t)
INSTANTIATE(int32_t)
INSTANTIATE(u_int32_t)
INSTANTIATE(int64_t)
INSTANTIATE(u_int64_t)
INSTANTIATE(cl_float)
INSTANTIATE(cl_double)
INSTANTIATE(char)
INSTANTIATE(unsigned char)
INSTANTIATE(short)
INSTANTIATE(unsigned short)
INSTANTIATE(int)
INSTANTIATE(unsigned int)
INSTANTIATE(long)
INSTANTIATE(unsigned long)
INSTANTIATE(float)
INSTANTIATE(double)
#undef INSTANTIATE
private:
values_holder values_;
@@ -72,40 +68,40 @@ private:
};
value_scalar int8(int8_t v);
value_scalar uint8(uint8_t v);
value_scalar uint8(u_int8_t v);
value_scalar int16(int16_t v);
value_scalar uint16(u_int16_t v);
value_scalar int32(int32_t v);
value_scalar uint32(u_int32_t v);
value_scalar int64(int64_t v);
value_scalar uint64(u_int64_t v);
value_scalar float32(cl_float v);
value_scalar float64(cl_double v);
value_scalar float32(float v);
value_scalar float64(double v);
template<class T>
T cast(isaac::value_scalar const &);
#define ISAAC_DECLARE_BINARY_OPERATOR(RET, OPNAME) \
RET OPNAME (value_scalar const &, int8_t );\
RET OPNAME (value_scalar const &, uint8_t );\
RET OPNAME (value_scalar const &, int16_t );\
RET OPNAME (value_scalar const &, u_int16_t);\
RET OPNAME (value_scalar const &, int32_t );\
RET OPNAME (value_scalar const &, u_int32_t );\
RET OPNAME (value_scalar const &, int64_t );\
RET OPNAME (value_scalar const &, u_int64_t );\
RET OPNAME (value_scalar const &, cl_float );\
RET OPNAME (value_scalar const &, cl_double);\
RET OPNAME (int8_t , value_scalar const &);\
RET OPNAME (uint8_t , value_scalar const &);\
RET OPNAME (int16_t , value_scalar const &);\
RET OPNAME (u_int16_t , value_scalar const &);\
RET OPNAME (int32_t , value_scalar const &);\
RET OPNAME (u_int32_t , value_scalar const &);\
RET OPNAME (int64_t , value_scalar const &);\
RET OPNAME (u_int64_t , value_scalar const &);\
RET OPNAME (cl_float , value_scalar const &);\
RET OPNAME (cl_double , value_scalar const &);\
RET OPNAME (value_scalar const &, char );\
RET OPNAME (value_scalar const &, unsigned char );\
RET OPNAME (value_scalar const &, short );\
RET OPNAME (value_scalar const &, unsigned short);\
RET OPNAME (value_scalar const &, int );\
RET OPNAME (value_scalar const &, unsigned int );\
RET OPNAME (value_scalar const &, long );\
RET OPNAME (value_scalar const &, unsigned long );\
RET OPNAME (value_scalar const &, float );\
RET OPNAME (value_scalar const &, double);\
RET OPNAME (char , value_scalar const &);\
RET OPNAME (unsigned char , value_scalar const &);\
RET OPNAME (short , value_scalar const &);\
RET OPNAME (unsigned short , value_scalar const &);\
RET OPNAME (int , value_scalar const &);\
RET OPNAME (unsigned int , value_scalar const &);\
RET OPNAME (long , value_scalar const &);\
RET OPNAME (unsigned long , value_scalar const &);\
RET OPNAME (float , value_scalar const &);\
RET OPNAME (double , value_scalar const &);\
RET OPNAME (value_scalar const &, value_scalar const &);
ISAAC_DECLARE_BINARY_OPERATOR(value_scalar, operator +)

242
lib/array.cpp
View File

@@ -1,7 +1,6 @@
#include <cassert>
#include "isaac/array.h"
#include <CL/cl.hpp>
#include "isaac/exception/unknown_datatype.h"
#include "isaac/model/model.h"
#include "isaac/symbolic/execute.h"
@@ -31,16 +30,16 @@ array::array(array & v, slice const & s0) : dtype_(v.dtype_), shape_(s0.size, 1,
{}
#define INSTANTIATE(T) template array::array(std::vector<T> const &, driver::Context)
INSTANTIATE(cl_char);
INSTANTIATE(cl_uchar);
INSTANTIATE(cl_short);
INSTANTIATE(cl_ushort);
INSTANTIATE(cl_int);
INSTANTIATE(cl_uint);
INSTANTIATE(cl_long);
INSTANTIATE(cl_ulong);
INSTANTIATE(cl_float);
INSTANTIATE(cl_double);
INSTANTIATE(char);
INSTANTIATE(unsigned char);
INSTANTIATE(short);
INSTANTIATE(unsigned short);
INSTANTIATE(int);
INSTANTIATE(unsigned int);
INSTANTIATE(long);
INSTANTIATE(unsigned long);
INSTANTIATE(float);
INSTANTIATE(double);
#undef INSTANTIATE
// 2D
@@ -69,16 +68,16 @@ array::array(int_t shape0, int_t shape1, std::vector<DT> const & data, driver::C
}
#define INSTANTIATE(T) template array::array(int_t, int_t, std::vector<T> const &, driver::Context)
INSTANTIATE(cl_char);
INSTANTIATE(cl_uchar);
INSTANTIATE(cl_short);
INSTANTIATE(cl_ushort);
INSTANTIATE(cl_int);
INSTANTIATE(cl_uint);
INSTANTIATE(cl_long);
INSTANTIATE(cl_ulong);
INSTANTIATE(cl_float);
INSTANTIATE(cl_double);
INSTANTIATE(char);
INSTANTIATE(unsigned char);
INSTANTIATE(short);
INSTANTIATE(unsigned short);
INSTANTIATE(int);
INSTANTIATE(unsigned int);
INSTANTIATE(long);
INSTANTIATE(unsigned long);
INSTANTIATE(float);
INSTANTIATE(double);
#undef INSTANTIATE
// General
@@ -163,16 +162,16 @@ array & array::operator=(std::vector<DT> const & rhs)
#define INSTANTIATE(T) template array & array::operator=<T>(std::vector<T> const &)
INSTANTIATE(cl_char);
INSTANTIATE(cl_uchar);
INSTANTIATE(cl_short);
INSTANTIATE(cl_ushort);
INSTANTIATE(cl_int);
INSTANTIATE(cl_uint);
INSTANTIATE(cl_long);
INSTANTIATE(cl_ulong);
INSTANTIATE(cl_float);
INSTANTIATE(cl_double);
INSTANTIATE(char);
INSTANTIATE(unsigned char);
INSTANTIATE(short);
INSTANTIATE(unsigned short);
INSTANTIATE(int);
INSTANTIATE(unsigned int);
INSTANTIATE(long);
INSTANTIATE(unsigned long);
INSTANTIATE(float);
INSTANTIATE(double);
#undef INSTANTIATE
array_expression array::operator-()
@@ -265,18 +264,16 @@ scalar::scalar(value_scalar value, driver::Context context) : array(1, value.dty
{
switch(dtype_)
{
// case BOOL_TYPE: detail::copy(context_, data_, (cl_bool)value); break;
case CHAR_TYPE: detail::copy(context_, data_, (cl_char)value); break;
case UCHAR_TYPE: detail::copy(context_, data_, (cl_uchar)value); break;
case SHORT_TYPE: detail::copy(context_, data_, (cl_short)value); break;
case USHORT_TYPE: detail::copy(context_, data_, (cl_ushort)value); break;
case INT_TYPE: detail::copy(context_, data_, (cl_int)value); break;
case UINT_TYPE: detail::copy(context_, data_, (cl_uint)value); break;
case LONG_TYPE: detail::copy(context_, data_, (cl_long)value); break;
case ULONG_TYPE: detail::copy(context_, data_, (cl_ulong)value); break;
// case HALF_TYPE: detail::copy(context_, data_, (cl_float)value); break;
case FLOAT_TYPE: detail::copy(context_, data_, (cl_float)value); break;
case DOUBLE_TYPE: detail::copy(context_, data_, (cl_double)value); break;
case CHAR_TYPE: detail::copy(context_, data_, (char)value); break;
case UCHAR_TYPE: detail::copy(context_, data_, (unsigned char)value); break;
case SHORT_TYPE: detail::copy(context_, data_, (short)value); break;
case USHORT_TYPE: detail::copy(context_, data_, (unsigned short)value); break;
case INT_TYPE: detail::copy(context_, data_, (int)value); break;
case UINT_TYPE: detail::copy(context_, data_, (unsigned int)value); break;
case LONG_TYPE: detail::copy(context_, data_, (long)value); break;
case ULONG_TYPE: detail::copy(context_, data_, (unsigned long)value); break;
case FLOAT_TYPE: detail::copy(context_, data_, (float)value); break;
case DOUBLE_TYPE: detail::copy(context_, data_, (double)value); break;
default: throw unknown_datatype(dtype_);
}
}
@@ -287,19 +284,15 @@ scalar::scalar(numeric_type dtype, driver::Context context) : array(1, dtype, co
scalar::scalar(array_expression const & proxy) : array(proxy){ }
template<class T>
T scalar::cast() const
void scalar::inject(values_holder & v) const
{
values_holder v;
int_t dtsize = size_of(dtype_);
#define HANDLE_CASE(DTYPE, VAL) \
case DTYPE:\
driver::queues[context_][0].read(data_, CL_TRUE, start_[0]*dtsize, dtsize, (void*)&v.VAL);\
return v.VAL
switch(dtype_)
{
// HANDLE_CASE(BOOL_TYPE, bool8);
HANDLE_CASE(CHAR_TYPE, int8);
HANDLE_CASE(UCHAR_TYPE, uint8);
HANDLE_CASE(SHORT_TYPE, int16);
@@ -308,7 +301,31 @@ case DTYPE:\
HANDLE_CASE(UINT_TYPE, uint32);
HANDLE_CASE(LONG_TYPE, int64);
HANDLE_CASE(ULONG_TYPE, uint64);
// HANDLE_CASE(HALF_TYPE, float16);
HANDLE_CASE(FLOAT_TYPE, float32);
HANDLE_CASE(DOUBLE_TYPE, float64);
default: throw unknown_datatype(dtype_);
}
#undef HANDLE_CASE
}
template<class T>
T scalar::cast() const
{
values_holder v;
inject(v);
#define HANDLE_CASE(DTYPE, VAL) case DTYPE: return v.VAL
switch(dtype_)
{
HANDLE_CASE(CHAR_TYPE, int8);
HANDLE_CASE(UCHAR_TYPE, uint8);
HANDLE_CASE(SHORT_TYPE, int16);
HANDLE_CASE(USHORT_TYPE, uint16);
HANDLE_CASE(INT_TYPE, int32);
HANDLE_CASE(UINT_TYPE, uint32);
HANDLE_CASE(LONG_TYPE, int64);
HANDLE_CASE(ULONG_TYPE, uint64);
HANDLE_CASE(FLOAT_TYPE, float32);
HANDLE_CASE(DOUBLE_TYPE, float64);
default: throw unknown_datatype(dtype_);
@@ -330,38 +347,31 @@ scalar& scalar::operator=(value_scalar const & s)
}
switch(dtype_)
{
// HANDLE_CASE(BOOL_TYPE, cl_bool)
HANDLE_CASE(CHAR_TYPE, cl_char)
HANDLE_CASE(UCHAR_TYPE, cl_uchar)
HANDLE_CASE(SHORT_TYPE, cl_short)
HANDLE_CASE(USHORT_TYPE, cl_ushort)
HANDLE_CASE(INT_TYPE, cl_int)
HANDLE_CASE(UINT_TYPE, cl_uint)
HANDLE_CASE(LONG_TYPE, cl_long)
HANDLE_CASE(ULONG_TYPE, cl_ulong)
// HANDLE_CASE(HALF_TYPE, cl_half)
HANDLE_CASE(FLOAT_TYPE, cl_float)
HANDLE_CASE(DOUBLE_TYPE, cl_double)
HANDLE_CASE(CHAR_TYPE, char)
HANDLE_CASE(UCHAR_TYPE, unsigned char)
HANDLE_CASE(SHORT_TYPE, short)
HANDLE_CASE(USHORT_TYPE, unsigned short)
HANDLE_CASE(INT_TYPE, int)
HANDLE_CASE(UINT_TYPE, unsigned int)
HANDLE_CASE(LONG_TYPE, long)
HANDLE_CASE(ULONG_TYPE, unsigned long)
HANDLE_CASE(FLOAT_TYPE, float)
HANDLE_CASE(DOUBLE_TYPE, double)
default: throw unknown_datatype(dtype_);
}
}
//scalar& scalar::operator=(scalar const & s)
//{
// return scalar::operator =(value_scalar(s));
//}
#define INSTANTIATE(type) scalar::operator type() const { return cast<type>(); }
INSTANTIATE(cl_char)
INSTANTIATE(cl_uchar)
INSTANTIATE(cl_short)
INSTANTIATE(cl_ushort)
INSTANTIATE(cl_int)
INSTANTIATE(cl_uint)
INSTANTIATE(cl_long)
INSTANTIATE(cl_ulong)
INSTANTIATE(cl_float)
INSTANTIATE(cl_double)
INSTANTIATE(char)
INSTANTIATE(unsigned char)
INSTANTIATE(short)
INSTANTIATE(unsigned short)
INSTANTIATE(int)
INSTANTIATE(unsigned int)
INSTANTIATE(long)
INSTANTIATE(unsigned long)
INSTANTIATE(float)
INSTANTIATE(double)
#undef INSTANTIATE
std::ostream & operator<<(std::ostream & os, scalar const & s)
@@ -369,17 +379,17 @@ std::ostream & operator<<(std::ostream & os, scalar const & s)
switch(s.dtype())
{
// case BOOL_TYPE: return os << static_cast<cl_bool>(s);
case CHAR_TYPE: return os << static_cast<cl_char>(s);
case UCHAR_TYPE: return os << static_cast<cl_uchar>(s);
case SHORT_TYPE: return os << static_cast<cl_short>(s);
case USHORT_TYPE: return os << static_cast<cl_ushort>(s);
case INT_TYPE: return os << static_cast<cl_int>(s);
case UINT_TYPE: return os << static_cast<cl_uint>(s);
case LONG_TYPE: return os << static_cast<cl_long>(s);
case ULONG_TYPE: return os << static_cast<cl_ulong>(s);
case CHAR_TYPE: return os << static_cast<char>(s);
case UCHAR_TYPE: return os << static_cast<unsigned char>(s);
case SHORT_TYPE: return os << static_cast<short>(s);
case USHORT_TYPE: return os << static_cast<unsigned short>(s);
case INT_TYPE: return os << static_cast<int>(s);
case UINT_TYPE: return os << static_cast<unsigned int>(s);
case LONG_TYPE: return os << static_cast<long>(s);
case ULONG_TYPE: return os << static_cast<unsigned long>(s);
// case HALF_TYPE: return os << static_cast<cl_half>(s);
case FLOAT_TYPE: return os << static_cast<cl_float>(s);
case DOUBLE_TYPE: return os << static_cast<cl_double>(s);
case FLOAT_TYPE: return os << static_cast<float>(s);
case DOUBLE_TYPE: return os << static_cast<double>(s);
default: throw unknown_datatype(s.dtype());
}
}
@@ -824,16 +834,16 @@ void copy(array const & x, std::vector<T> & cx, bool blocking)
template void copy<T>(std::vector<T> const &, array &, bool);\
template void copy<T>(array const &, std::vector<T> &, bool)
INSTANTIATE(cl_char);
INSTANTIATE(cl_uchar);
INSTANTIATE(cl_short);
INSTANTIATE(cl_ushort);
INSTANTIATE(cl_int);
INSTANTIATE(cl_uint);
INSTANTIATE(cl_long);
INSTANTIATE(cl_ulong);
INSTANTIATE(cl_float);
INSTANTIATE(cl_double);
INSTANTIATE(char);
INSTANTIATE(unsigned char);
INSTANTIATE(short);
INSTANTIATE(unsigned short);
INSTANTIATE(int);
INSTANTIATE(unsigned int);
INSTANTIATE(long);
INSTANTIATE(unsigned long);
INSTANTIATE(float);
INSTANTIATE(double);
#undef INSTANTIATE
/*--- Stream operators----*/
@@ -896,17 +906,17 @@ std::ostream& operator<<(std::ostream & os, array const & a)
switch(dtype)
{
// HANDLE(BOOL_TYPE, cl_bool)
HANDLE(CHAR_TYPE, cl_char)
HANDLE(UCHAR_TYPE, cl_uchar)
HANDLE(SHORT_TYPE, cl_short)
HANDLE(USHORT_TYPE, cl_ushort)
HANDLE(INT_TYPE, cl_int)
HANDLE(UINT_TYPE, cl_uint)
HANDLE(LONG_TYPE, cl_long)
HANDLE(ULONG_TYPE, cl_ulong)
HANDLE(CHAR_TYPE, char)
HANDLE(UCHAR_TYPE, unsigned char)
HANDLE(SHORT_TYPE, short)
HANDLE(USHORT_TYPE, unsigned short)
HANDLE(INT_TYPE, int)
HANDLE(UINT_TYPE, unsigned int)
HANDLE(LONG_TYPE, long)
HANDLE(ULONG_TYPE, unsigned long)
// HANDLE(HALF_TYPE, cl_half)
HANDLE(FLOAT_TYPE, cl_float)
HANDLE(DOUBLE_TYPE, cl_double)
HANDLE(FLOAT_TYPE, float)
HANDLE(DOUBLE_TYPE, double)
default: throw unknown_datatype(dtype);
}
if(i < upper-1)
@@ -922,17 +932,17 @@ std::ostream& operator<<(std::ostream & os, array const & a)
switch(dtype)
{
// HANDLE(BOOL_TYPE, cl_bool)
HANDLE(CHAR_TYPE, cl_char)
HANDLE(UCHAR_TYPE, cl_uchar)
HANDLE(SHORT_TYPE, cl_short)
HANDLE(USHORT_TYPE, cl_ushort)
HANDLE(INT_TYPE, cl_int)
HANDLE(UINT_TYPE, cl_uint)
HANDLE(LONG_TYPE, cl_long)
HANDLE(ULONG_TYPE, cl_ulong)
HANDLE(CHAR_TYPE, char)
HANDLE(UCHAR_TYPE, unsigned char)
HANDLE(SHORT_TYPE, short)
HANDLE(USHORT_TYPE, unsigned short)
HANDLE(INT_TYPE, int)
HANDLE(UINT_TYPE, unsigned int)
HANDLE(LONG_TYPE, long)
HANDLE(ULONG_TYPE, unsigned long)
// HANDLE(HALF_TYPE, cl_half)
HANDLE(FLOAT_TYPE, cl_float)
HANDLE(DOUBLE_TYPE, cl_double)
HANDLE(FLOAT_TYPE, float)
HANDLE(DOUBLE_TYPE, double)
default: throw unknown_datatype(dtype);
}
}

127
lib/value_scalar.cpp
View File

@@ -28,24 +28,24 @@ void value_scalar::init(T const & s)
}
}
#define INSTANTIATE(CLTYPE, ADTYPE) value_scalar::value_scalar(CLTYPE value, numeric_type dtype) : dtype_(dtype) { init(value); }
#define INSTANTIATE(CLTYPE) value_scalar::value_scalar(CLTYPE value, numeric_type dtype) : dtype_(dtype) { init(value); }
INSTANTIATE(int8_t, CHAR_TYPE)
INSTANTIATE(u_int8_t, UCHAR_TYPE)
INSTANTIATE(int16_t, SHORT_TYPE)
INSTANTIATE(u_int16_t, USHORT_TYPE)
INSTANTIATE(int32_t, INT_TYPE)
INSTANTIATE(u_int32_t, UINT_TYPE)
INSTANTIATE(int64_t, LONG_TYPE)
INSTANTIATE(u_int64_t, ULONG_TYPE)
INSTANTIATE(cl_float, FLOAT_TYPE)
INSTANTIATE(cl_double, DOUBLE_TYPE)
INSTANTIATE(char)
INSTANTIATE(unsigned char)
INSTANTIATE(short)
INSTANTIATE(unsigned short)
INSTANTIATE(int)
INSTANTIATE(unsigned int)
INSTANTIATE(long)
INSTANTIATE(unsigned long)
INSTANTIATE(float)
INSTANTIATE(double)
#undef INSTANTIATE
value_scalar::value_scalar(numeric_type dtype) : dtype_(dtype) {}
value_scalar::value_scalar(scalar const & s) : dtype_(s.dtype()) { init(s); }
value_scalar::value_scalar(array_expression const &expr) : dtype_(expr.dtype()) { init(scalar(expr)); }
value_scalar::value_scalar(scalar const & s) : dtype_(s.dtype()) { s.inject(values_); }
value_scalar::value_scalar(array_expression const &expr) : dtype_(expr.dtype()) { scalar(expr).inject(values_); }
values_holder value_scalar::values() const
{ return values_; }
@@ -66,7 +66,6 @@ T value_scalar::cast() const
case UINT_TYPE: return values_.uint32;
case LONG_TYPE: return values_.int64;
case ULONG_TYPE: return values_.uint64;
// case HALF_TYPE: return values_.float16;
case FLOAT_TYPE: return values_.float32;
case DOUBLE_TYPE: return values_.float64;
default: throw unknown_datatype(dtype_); //unreachable
@@ -75,16 +74,16 @@ T value_scalar::cast() const
#define INSTANTIATE(type) value_scalar::operator type() const { return cast<type>(); }
INSTANTIATE(bool)
INSTANTIATE(int8_t)
INSTANTIATE(u_int8_t)
INSTANTIATE(int16_t)
INSTANTIATE(u_int16_t)
INSTANTIATE(int32_t)
INSTANTIATE(u_int32_t)
INSTANTIATE(int64_t)
INSTANTIATE(u_int64_t)
INSTANTIATE(cl_float)
INSTANTIATE(cl_double)
INSTANTIATE(char)
INSTANTIATE(unsigned char)
INSTANTIATE(short)
INSTANTIATE(unsigned short)
INSTANTIATE(int)
INSTANTIATE(unsigned int)
INSTANTIATE(long)
INSTANTIATE(unsigned long)
INSTANTIATE(float)
INSTANTIATE(double)
#undef INSTANTIATE
value_scalar int8(int8_t v) { return value_scalar(v); }
@@ -104,41 +103,41 @@ value_scalar NAME(LDEC, RDEC)\
{\
switch(x.dtype())\
{\
case CHAR_TYPE: return VALUE(int8_t, OP, x, y);\
case UCHAR_TYPE: return VALUE(u_int8_t, OP, x, y);\
case SHORT_TYPE: return VALUE(int16_t, OP, x, y);\
case USHORT_TYPE: return VALUE(u_int16_t, OP, x, y);\
case INT_TYPE: return VALUE(int32_t, OP, x, y);\
case UINT_TYPE: return VALUE(u_int32_t, OP, x, y);\
case LONG_TYPE: return VALUE(int64_t, OP, x, y);\
case ULONG_TYPE: return VALUE(u_int64_t, OP, x, y);\
case FLOAT_TYPE: return VALUE(cl_float, OP, x, y);\
case DOUBLE_TYPE: return VALUE(cl_double, OP, x, y);\
case CHAR_TYPE: return VALUE(char, OP, x, y);\
case UCHAR_TYPE: return VALUE(unsigned char, OP, x, y);\
case SHORT_TYPE: return VALUE(short, OP, x, y);\
case USHORT_TYPE: return VALUE(unsigned short, OP, x, y);\
case INT_TYPE: return VALUE(int, OP, x, y);\
case UINT_TYPE: return VALUE(unsigned int, OP, x, y);\
case LONG_TYPE: return VALUE(long, OP, x, y);\
case ULONG_TYPE: return VALUE(unsigned long, OP, x, y);\
case FLOAT_TYPE: return VALUE(float, OP, x, y);\
case DOUBLE_TYPE: return VALUE(double, OP, x, y);\
default: throw unknown_datatype(x.dtype());\
}\
}
#define INSTANTIATE_ALL(NAME, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, int8_t y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, u_int8_t y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, int16_t y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, u_int16_t y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, int32_t y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, u_int32_t y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, int64_t y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, u_int64_t y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, cl_float y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, cl_double y, EXPR)\
INSTANTIATE(NAME, int8_t y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, u_int8_t y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, int16_t y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, u_int16_t y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, int32_t y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, u_int32_t y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, int64_t y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, u_int64_t y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, cl_float y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, cl_double y, value_scalar const & x, EXPR)
INSTANTIATE(NAME, value_scalar const & x, char y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, unsigned char y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, short y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, unsigned short y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, int y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, unsigned int y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, long y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, unsigned long y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, float y, EXPR)\
INSTANTIATE(NAME, value_scalar const & x, double y, EXPR)\
INSTANTIATE(NAME, char y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, unsigned char y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, short y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, unsigned short y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, int y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, unsigned int y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, long y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, unsigned long y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, float y, value_scalar const & x, EXPR)\
INSTANTIATE(NAME, double y, value_scalar const & x, EXPR)
INSTANTIATE_ALL(operator+, +)
INSTANTIATE_ALL(operator-, -)
@@ -167,16 +166,16 @@ std::ostream & operator<<(std::ostream & os, value_scalar const & s)
{
switch(s.dtype())
{
case CHAR_TYPE: return os << static_cast<int8_t>(s);
case UCHAR_TYPE: return os << static_cast<u_int8_t>(s);
case SHORT_TYPE: return os << static_cast<int16_t>(s);
case USHORT_TYPE: return os << static_cast<u_int16_t>(s);
case INT_TYPE: return os << static_cast<int32_t>(s);
case UINT_TYPE: return os << static_cast<u_int32_t>(s);
case LONG_TYPE: return os << static_cast<int64_t>(s);
case ULONG_TYPE: return os << static_cast<u_int64_t>(s);
case FLOAT_TYPE: return os << static_cast<cl_float>(s);
case DOUBLE_TYPE: return os << static_cast<cl_double>(s);
case CHAR_TYPE: return os << static_cast<char>(s);
case UCHAR_TYPE: return os << static_cast<unsigned char>(s);
case SHORT_TYPE: return os << static_cast<short>(s);
case USHORT_TYPE: return os << static_cast<unsigned short>(s);
case INT_TYPE: return os << static_cast<int>(s);
case UINT_TYPE: return os << static_cast<unsigned int>(s);
case LONG_TYPE: return os << static_cast<long>(s);
case ULONG_TYPE: return os << static_cast<unsigned long>(s);
case FLOAT_TYPE: return os << static_cast<float>(s);
case DOUBLE_TYPE: return os << static_cast<double>(s);
default: throw unknown_datatype(s.dtype());;
}
}