experiments/STT-tensorflow
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

For Android slim mode the first type of Register is used.

Browse Source 
Eigen::half has been previously introduced and now occupies this position.
Change the order so that the first type is float again.
Change: 120274210
This commit is contained in:
A. Unique TensorFlower 2016-04-19 14:02:36 -08:00 committed by TensorFlower Gardener
parent b1d7f22fc6
commit 97880edb4e
35 changed files with 71 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tensorflow/core/kernels/cwise_op_abs.cc
View File

@ -16,14 +16,14 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER5(UnaryOp, CPU, "Abs", functor::abs, Eigen::half, float, double, int32,
REGISTER5(UnaryOp, CPU, "Abs", functor::abs, float, Eigen::half, double, int32,
int64);
#if !defined(__ANDROID__)
REGISTER_KERNEL_BUILDER(Name("ComplexAbs").Device(DEVICE_CPU),
UnaryOp<CPUDevice, functor::abs<complex64>>);
#endif
#if GOOGLE_CUDA
REGISTER4(UnaryOp, GPU, "Abs", functor::abs, Eigen::half, float, double, int64);
REGISTER4(UnaryOp, GPU, "Abs", functor::abs, float, Eigen::half, double, int64);
// A special GPU kernel for int32.
// TODO(b/25387198): Also enable int32 in device memory. This kernel

4
tensorflow/core/kernels/cwise_op_add.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER9(BinaryOp, CPU, "Add", functor::add, Eigen::half, float, double, int32,
REGISTER9(BinaryOp, CPU, "Add", functor::add, float, Eigen::half, double, int32,
int64, int8, int16, complex64, string);
#if GOOGLE_CUDA
REGISTER4(BinaryOp, GPU, "Add", functor::add, Eigen::half, float, double,
REGISTER4(BinaryOp, GPU, "Add", functor::add, float, Eigen::half, double,
int64);
// A special GPU kernel for int32.

4
tensorflow/core/kernels/cwise_op_ceil.cc
View File

@ -16,8 +16,8 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER3(UnaryOp, CPU, "Ceil", functor::ceil, Eigen::half, float, double);
REGISTER3(UnaryOp, CPU, "Ceil", functor::ceil, float, Eigen::half, double);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "Ceil", functor::ceil, Eigen::half, float, double);
REGISTER3(UnaryOp, GPU, "Ceil", functor::ceil, float, Eigen::half, double);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_cos.cc
View File

@ -16,9 +16,9 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER4(UnaryOp, CPU, "Cos", functor::cos, Eigen::half, float, double,
REGISTER4(UnaryOp, CPU, "Cos", functor::cos, float, Eigen::half, double,
complex64);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "Cos", functor::cos, Eigen::half, float, double);
REGISTER3(UnaryOp, GPU, "Cos", functor::cos, float, Eigen::half, double);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_digamma.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER3(UnaryOp, CPU, "Digamma", functor::digamma, Eigen::half, float,
REGISTER3(UnaryOp, CPU, "Digamma", functor::digamma, float, Eigen::half,
double);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "Digamma", functor::digamma, Eigen::half, float,
REGISTER3(UnaryOp, GPU, "Digamma", functor::digamma, float, Eigen::half,
double);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_div.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER8(BinaryOp, CPU, "Div", functor::div, Eigen::half, float, double, uint8,
REGISTER8(BinaryOp, CPU, "Div", functor::div, float, Eigen::half, double, uint8,
int16, int32, int64, complex64);
#if GOOGLE_CUDA
REGISTER6(BinaryOp, GPU, "Div", functor::div, Eigen::half, float, double, uint8,
REGISTER6(BinaryOp, GPU, "Div", functor::div, float, Eigen::half, double, uint8,
int16, int64);
// A special GPU kernel for int32.

4
tensorflow/core/kernels/cwise_op_equal_to.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER10(BinaryOp, CPU, "Equal", functor::equal_to, Eigen::half, float,
REGISTER10(BinaryOp, CPU, "Equal", functor::equal_to, float, Eigen::half,
double, uint8, int8, int16, int32, int64, complex64, string);
#if GOOGLE_CUDA
REGISTER7(BinaryOp, GPU, "Equal", functor::equal_to, Eigen::half, float, double,
REGISTER7(BinaryOp, GPU, "Equal", functor::equal_to, float, Eigen::half, double,
uint8, int8, int16, int64);
// A special GPU kernel for int32.

4
tensorflow/core/kernels/cwise_op_erf.cc
View File

@ -16,8 +16,8 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER3(UnaryOp, CPU, "Erf", functor::erf, Eigen::half, float, double);
REGISTER3(UnaryOp, CPU, "Erf", functor::erf, float, Eigen::half, double);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "Erf", functor::erf, Eigen::half, float, double);
REGISTER3(UnaryOp, GPU, "Erf", functor::erf, float, Eigen::half, double);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_erfc.cc
View File

@ -16,8 +16,8 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER3(UnaryOp, CPU, "Erfc", functor::erfc, Eigen::half, float, double);
REGISTER3(UnaryOp, CPU, "Erfc", functor::erfc, float, Eigen::half, double);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "Erfc", functor::erfc, Eigen::half, float, double);
REGISTER3(UnaryOp, GPU, "Erfc", functor::erfc, float, Eigen::half, double);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_exp.cc
View File

@ -16,9 +16,9 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER4(UnaryOp, CPU, "Exp", functor::exp, Eigen::half, float, double,
REGISTER4(UnaryOp, CPU, "Exp", functor::exp, float, Eigen::half, double,
complex64);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "Exp", functor::exp, Eigen::half, float, double);
REGISTER3(UnaryOp, GPU, "Exp", functor::exp, float, Eigen::half, double);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_floor.cc
View File

@ -16,8 +16,8 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER3(UnaryOp, CPU, "Floor", functor::floor, Eigen::half, float, double);
REGISTER3(UnaryOp, CPU, "Floor", functor::floor, float, Eigen::half, double);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "Floor", functor::floor, Eigen::half, float, double);
REGISTER3(UnaryOp, GPU, "Floor", functor::floor, float, Eigen::half, double);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_greater.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER8(BinaryOp, CPU, "Greater", functor::greater, Eigen::half, float,
REGISTER8(BinaryOp, CPU, "Greater", functor::greater, float, Eigen::half,
double, int32, int64, uint8, int8, int16);
#if GOOGLE_CUDA
REGISTER7(BinaryOp, GPU, "Greater", functor::greater, Eigen::half, float,
REGISTER7(BinaryOp, GPU, "Greater", functor::greater, float, Eigen::half,
double, int64, uint8, int8, int16);
// A special GPU kernel for int32.

8
tensorflow/core/kernels/cwise_op_greater_equal.cc
View File

@ -16,11 +16,11 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER8(BinaryOp, CPU, "GreaterEqual", functor::greater_equal, Eigen::half,
float, double, int32, int64, uint8, int8, int16);
REGISTER8(BinaryOp, CPU, "GreaterEqual", functor::greater_equal, float,
Eigen::half, double, int32, int64, uint8, int8, int16);
#if GOOGLE_CUDA
REGISTER7(BinaryOp, GPU, "GreaterEqual", functor::greater_equal, Eigen::half,
float, double, int64, uint8, int8, int16);
REGISTER7(BinaryOp, GPU, "GreaterEqual", functor::greater_equal, float,
Eigen::half, double, int64, uint8, int8, int16);
// A special GPU kernel for int32.
// TODO(b/25387198): Also enable int32 in device memory. This kernel

4
tensorflow/core/kernels/cwise_op_inverse.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER4(UnaryOp, CPU, "Inv", functor::inverse, Eigen::half, float, double,
REGISTER4(UnaryOp, CPU, "Inv", functor::inverse, float, Eigen::half, double,
complex64);
#if GOOGLE_CUDA
REGISTER4(UnaryOp, GPU, "Inv", functor::inverse, Eigen::half, float, double,
REGISTER4(UnaryOp, GPU, "Inv", functor::inverse, float, Eigen::half, double,
int64);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_isfinite.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER3(UnaryOp, CPU, "IsFinite", functor::isfinite, Eigen::half, float,
REGISTER3(UnaryOp, CPU, "IsFinite", functor::isfinite, float, Eigen::half,
double);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "IsFinite", functor::isfinite, Eigen::half, float,
REGISTER3(UnaryOp, GPU, "IsFinite", functor::isfinite, float, Eigen::half,
double);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_isinf.cc
View File

@ -16,8 +16,8 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER3(UnaryOp, CPU, "IsInf", functor::isinf, Eigen::half, float, double);
REGISTER3(UnaryOp, CPU, "IsInf", functor::isinf, float, Eigen::half, double);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "IsInf", functor::isinf, Eigen::half, float, double);
REGISTER3(UnaryOp, GPU, "IsInf", functor::isinf, float, Eigen::half, double);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_isnan.cc
View File

@ -16,8 +16,8 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER3(UnaryOp, CPU, "IsNan", functor::isnan, Eigen::half, float, double);
REGISTER3(UnaryOp, CPU, "IsNan", functor::isnan, float, Eigen::half, double);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "IsNan", functor::isnan, Eigen::half, float, double);
REGISTER3(UnaryOp, GPU, "IsNan", functor::isnan, float, Eigen::half, double);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_less.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER8(BinaryOp, CPU, "Less", functor::less, Eigen::half, float, double,
REGISTER8(BinaryOp, CPU, "Less", functor::less, float, Eigen::half, double,
int32, int64, uint8, int8, int16);
#if GOOGLE_CUDA
REGISTER7(BinaryOp, GPU, "Less", functor::less, Eigen::half, float, double,
REGISTER7(BinaryOp, GPU, "Less", functor::less, float, Eigen::half, double,
int64, uint8, int8, int16);
// A special GPU kernel for int32.

4
tensorflow/core/kernels/cwise_op_less_equal.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER8(BinaryOp, CPU, "LessEqual", functor::less_equal, Eigen::half, float,
REGISTER8(BinaryOp, CPU, "LessEqual", functor::less_equal, float, Eigen::half,
double, int32, int64, uint8, int8, int16);
#if GOOGLE_CUDA
REGISTER7(BinaryOp, GPU, "LessEqual", functor::less_equal, Eigen::half, float,
REGISTER7(BinaryOp, GPU, "LessEqual", functor::less_equal, float, Eigen::half,
double, int64, uint8, int8, int16);
// A special GPU kernel for int32.

4
tensorflow/core/kernels/cwise_op_lgamma.cc
View File

@ -16,8 +16,8 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER3(UnaryOp, CPU, "Lgamma", functor::lgamma, Eigen::half, float, double);
REGISTER3(UnaryOp, CPU, "Lgamma", functor::lgamma, float, Eigen::half, double);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "Lgamma", functor::lgamma, Eigen::half, float, double);
REGISTER3(UnaryOp, GPU, "Lgamma", functor::lgamma, float, Eigen::half, double);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_log.cc
View File

@ -16,9 +16,9 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER4(UnaryOp, CPU, "Log", functor::log, Eigen::half, float, double,
REGISTER4(UnaryOp, CPU, "Log", functor::log, float, Eigen::half, double,
complex64);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "Log", functor::log, Eigen::half, float, double);
REGISTER3(UnaryOp, GPU, "Log", functor::log, float, Eigen::half, double);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_maximum.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER5(BinaryOp, CPU, "Maximum", functor::maximum, Eigen::half, float,
REGISTER5(BinaryOp, CPU, "Maximum", functor::maximum, float, Eigen::half,
double, int32, int64);
#if GOOGLE_CUDA
REGISTER4(BinaryOp, GPU, "Maximum", functor::maximum, Eigen::half, float,
REGISTER4(BinaryOp, GPU, "Maximum", functor::maximum, float, Eigen::half,
double, int64);
// A special GPU kernel for int32.

4
tensorflow/core/kernels/cwise_op_minimum.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER5(BinaryOp, CPU, "Minimum", functor::minimum, Eigen::half, float,
REGISTER5(BinaryOp, CPU, "Minimum", functor::minimum, float, Eigen::half,
double, int32, int64);
#if GOOGLE_CUDA
REGISTER4(BinaryOp, GPU, "Minimum", functor::minimum, Eigen::half, float,
REGISTER4(BinaryOp, GPU, "Minimum", functor::minimum, float, Eigen::half,
double, int64);
// A special GPU kernel for int32.

4
tensorflow/core/kernels/cwise_op_mul.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER9(BinaryOp, CPU, "Mul", functor::mul, Eigen::half, float, double, uint8,
REGISTER9(BinaryOp, CPU, "Mul", functor::mul, float, Eigen::half, double, uint8,
int8, int16, int32, int64, complex64);
#if GOOGLE_CUDA
REGISTER7(BinaryOp, GPU, "Mul", functor::mul, Eigen::half, float, double, uint8,
REGISTER7(BinaryOp, GPU, "Mul", functor::mul, float, Eigen::half, double, uint8,
int8, int16, int64);
// A special GPU kernel for int32.
// TODO(b/25387198): Also enable int32 in device memory. This kernel

4
tensorflow/core/kernels/cwise_op_neg.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER6(UnaryOp, CPU, "Neg", functor::neg, Eigen::half, float, double, int32,
REGISTER6(UnaryOp, CPU, "Neg", functor::neg, float, Eigen::half, double, int32,
complex64, int64);
#if GOOGLE_CUDA
REGISTER4(UnaryOp, GPU, "Neg", functor::neg, Eigen::half, float, double, int64);
REGISTER4(UnaryOp, GPU, "Neg", functor::neg, float, Eigen::half, double, int64);
// A special GPU kernel for int32.
// TODO(b/25387198): Also enable int32 in device memory. This kernel

4
tensorflow/core/kernels/cwise_op_not_equal_to.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER10(BinaryOp, CPU, "NotEqual", functor::not_equal_to, Eigen::half, float,
REGISTER10(BinaryOp, CPU, "NotEqual", functor::not_equal_to, float, Eigen::half,
double, uint8, int8, int16, int32, int64, complex64, string);
#if GOOGLE_CUDA
REGISTER7(BinaryOp, GPU, "NotEqual", functor::not_equal_to, Eigen::half, float,
REGISTER7(BinaryOp, GPU, "NotEqual", functor::not_equal_to, float, Eigen::half,
double, uint8, int8, int16, int64);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_pow.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER6(BinaryOp, CPU, "Pow", functor::pow, Eigen::half, float, double, int32,
REGISTER6(BinaryOp, CPU, "Pow", functor::pow, float, Eigen::half, double, int32,
int64, complex64);
#if GOOGLE_CUDA
REGISTER4(BinaryOp, GPU, "Pow", functor::pow, Eigen::half, float, double,
REGISTER4(BinaryOp, GPU, "Pow", functor::pow, float, Eigen::half, double,
int64);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_rsqrt.cc
View File

@ -16,9 +16,9 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER4(UnaryOp, CPU, "Rsqrt", functor::rsqrt, Eigen::half, float, double,
REGISTER4(UnaryOp, CPU, "Rsqrt", functor::rsqrt, float, Eigen::half, double,
complex64);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "Rsqrt", functor::rsqrt, Eigen::half, float, double);
REGISTER3(UnaryOp, GPU, "Rsqrt", functor::rsqrt, float, Eigen::half, double);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_sigmoid.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER4(UnaryOp, CPU, "Sigmoid", functor::sigmoid, Eigen::half, float, double,
REGISTER4(UnaryOp, CPU, "Sigmoid", functor::sigmoid, float, Eigen::half, double,
complex64);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "Sigmoid", functor::sigmoid, Eigen::half, float,
REGISTER3(UnaryOp, GPU, "Sigmoid", functor::sigmoid, float, Eigen::half,
double);
#endif
} // namespace tensorflow

2
tensorflow/core/kernels/cwise_op_sign.cc
View File

@ -19,7 +19,7 @@ namespace tensorflow {
REGISTER6(UnaryOp, CPU, "Sign", functor::sign, float, double, int32, int64,
complex64, Eigen::half);
#if GOOGLE_CUDA
REGISTER4(UnaryOp, GPU, "Sign", functor::sign, Eigen::half, float, double,
REGISTER4(UnaryOp, GPU, "Sign", functor::sign, float, Eigen::half, double,
int64);
// A special GPU kernel for int32.

4
tensorflow/core/kernels/cwise_op_sin.cc
View File

@ -16,9 +16,9 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER4(UnaryOp, CPU, "Sin", functor::sin, Eigen::half, float, double,
REGISTER4(UnaryOp, CPU, "Sin", functor::sin, float, Eigen::half, double,
complex64);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "Sin", functor::sin, Eigen::half, float, double);
REGISTER3(UnaryOp, GPU, "Sin", functor::sin, float, Eigen::half, double);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_sqrt.cc
View File

@ -16,9 +16,9 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER4(UnaryOp, CPU, "Sqrt", functor::sqrt, Eigen::half, float, double,
REGISTER4(UnaryOp, CPU, "Sqrt", functor::sqrt, float, Eigen::half, double,
complex64);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "Sqrt", functor::sqrt, Eigen::half, float, double);
REGISTER3(UnaryOp, GPU, "Sqrt", functor::sqrt, float, Eigen::half, double);
#endif
} // namespace tensorflow

4
tensorflow/core/kernels/cwise_op_square.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER6(UnaryOp, CPU, "Square", functor::square, Eigen::half, float, double,
REGISTER6(UnaryOp, CPU, "Square", functor::square, float, Eigen::half, double,
int32, complex64, int64);
#if GOOGLE_CUDA
REGISTER4(UnaryOp, GPU, "Square", functor::square, Eigen::half, float, double,
REGISTER4(UnaryOp, GPU, "Square", functor::square, float, Eigen::half, double,
int64);
// A special GPU kernel for int32.

4
tensorflow/core/kernels/cwise_op_sub.cc
View File

@ -16,10 +16,10 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER6(BinaryOp, CPU, "Sub", functor::sub, Eigen::half, float, double, int32,
REGISTER6(BinaryOp, CPU, "Sub", functor::sub, float, Eigen::half, double, int32,
int64, complex64);
#if GOOGLE_CUDA
REGISTER4(BinaryOp, GPU, "Sub", functor::sub, Eigen::half, float, double,
REGISTER4(BinaryOp, GPU, "Sub", functor::sub, float, Eigen::half, double,
int64);
// A special GPU kernel for int32.

4
tensorflow/core/kernels/cwise_op_tanh.cc
View File

@ -16,9 +16,9 @@ limitations under the License.
#include "tensorflow/core/kernels/cwise_ops_common.h"
namespace tensorflow {
REGISTER4(UnaryOp, CPU, "Tanh", functor::tanh, Eigen::half, float, double,
REGISTER4(UnaryOp, CPU, "Tanh", functor::tanh, float, Eigen::half, double,
complex64);
#if GOOGLE_CUDA
REGISTER3(UnaryOp, GPU, "Tanh", functor::tanh, Eigen::half, float, double);
REGISTER3(UnaryOp, GPU, "Tanh", functor::tanh, float, Eigen::half, double);
#endif
} // namespace tensorflow