diff --git a/paddle/fluid/framework/details/nan_inf_utils_detail.cc b/paddle/fluid/framework/details/nan_inf_utils_detail.cc index 829772448eb91e428224647168029395d95ab9f6..f9aa14bf7e8d7e9a632cafefa8b88f0ae35c5a6c 100644 --- a/paddle/fluid/framework/details/nan_inf_utils_detail.cc +++ b/paddle/fluid/framework/details/nan_inf_utils_detail.cc @@ -159,10 +159,6 @@ static void PrintNanInf(const T* value, const size_t numel, int print_num, #pragma omp declare reduction(+ : paddle::platform::float16 : omp_out += omp_in) #pragma omp declare reduction(+ : paddle::platform::bfloat16 : omp_out += \ omp_in) -#pragma omp declare reduction(+ : paddle::platform::complex64 : omp_out += \ - omp_in) -#pragma omp declare reduction(+ : paddle::platform::complex128 : omp_out += \ - omp_in) #pragma omp declare reduction(+ : paddle::platform::complex < \ float > : omp_out += omp_in) #pragma omp declare reduction(+ : paddle::platform::complex < \ @@ -222,58 +218,6 @@ void CheckNanInf( } } -template <> -void CheckNanInf( - const paddle::platform::complex64* value, const size_t numel, int print_num, - const std::string& op_type, const std::string& var_name) { - float real_sum = 0.0f; -#pragma omp parallel for reduction(+ : real_sum) - for (size_t i = 0; i < numel; ++i) { - real_sum += (value[i].real - value[i].real); - } - - float imag_sum = 0.0f; -#pragma omp parallel for reduction(+ : imag_sum) - for (size_t i = 0; i < numel; ++i) { - imag_sum += (value[i].imag - value[i].imag); - } - - if (std::isnan(real_sum) || std::isinf(real_sum) || std::isnan(imag_sum) || - std::isinf(imag_sum)) { - // hot fix for compile failed in gcc4.8 - // here also need print detail info of nan or inf later - PADDLE_THROW(platform::errors::PreconditionNotMet( - "There are `nan` or `inf` in tensor (%s) of operator (%s).", var_name, - op_type)); - } -} - -template <> -void CheckNanInf( - const paddle::platform::complex128* value, const size_t numel, - int print_num, const std::string& op_type, const std::string& var_name) { - double real_sum = 0.0; -#pragma omp parallel for reduction(+ : real_sum) - for (size_t i = 0; i < numel; ++i) { - real_sum += (value[i].real - value[i].real); - } - - double imag_sum = 0.0; -#pragma omp parallel for reduction(+ : imag_sum) - for (size_t i = 0; i < numel; ++i) { - imag_sum += (value[i].imag - value[i].imag); - } - - if (std::isnan(real_sum) || std::isinf(real_sum) || std::isnan(imag_sum) || - std::isinf(imag_sum)) { - // hot fix for compile failed in gcc4.8 - // here also need print detail info of nan or inf later - PADDLE_THROW(platform::errors::PreconditionNotMet( - "There are `nan` or `inf` in tensor (%s) of operator (%s).", var_name, - op_type)); - } -} - template <> void CheckNanInf>( const paddle::platform::complex* value, const size_t numel, diff --git a/paddle/fluid/framework/dlpack_tensor.cc b/paddle/fluid/framework/dlpack_tensor.cc index 54d8fc92b29459ec062b6809ef4cd5156d50c21a..f1f5ba7789ea6137800e7fcfe2d404ca2d87845b 100644 --- a/paddle/fluid/framework/dlpack_tensor.cc +++ b/paddle/fluid/framework/dlpack_tensor.cc @@ -29,9 +29,7 @@ template static ::DLDataType GetDLDataTypeCode() { ::DLDataType dtype; if (std::is_same>::value || - std::is_same>::value || - std::is_same::value || - std::is_same::value) { + std::is_same>::value) { // The current dlpack library version is v0.2, and does not define // kDLComplex value. But kDLComplex is defined by 5U in v0.4, so we set // dtype.code to 5U directly here. After the dlpack library version being diff --git a/paddle/fluid/platform/complex64.h b/paddle/fluid/platform/complex64.h deleted file mode 100644 index 0aad7bd9dd2a8f1d59833720b442e34afa176ca6..0000000000000000000000000000000000000000 --- a/paddle/fluid/platform/complex64.h +++ /dev/null @@ -1,538 +0,0 @@ -// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. -// -// 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. - -#pragma once - -#include - -#include -#include -#include -#include - -#ifdef PADDLE_WITH_CUDA -#include -#include -#endif // PADDLE_WITH_CUDA - -#ifdef PADDLE_WITH_HIP -#include -#include // NOLINT -#endif - -#if !defined(_WIN32) -#define PADDLE_ALIGN(x) __attribute__((aligned(x))) -#else -#define PADDLE_ALIGN(x) __declspec(align(x)) -#endif - -#if (defined(__CUDACC__) || defined(__HIPCC__)) -#define HOSTDEVICE __host__ __device__ -#define DEVICE __device__ -#define HOST __host__ -#else -#define HOSTDEVICE -#define DEVICE -#define HOST -#endif - -#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP) -#define PADDLE_WITH_CUDA_OR_HIP_COMPLEX64 -#endif - -#include "complex128.h" // NOLINT - -namespace paddle { -namespace platform { - -struct PADDLE_ALIGN(8) complex64 { - public: - float real; - float imag; - - complex64() = default; - complex64(const complex64& o) = default; - complex64& operator=(const complex64& o) = default; - complex64(complex64&& o) = default; - complex64& operator=(complex64&& o) = default; - ~complex64() = default; - - HOSTDEVICE complex64(float real, float imag) : real(real), imag(imag) {} -#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP) - - HOSTDEVICE inline explicit complex64(const thrust::complex& c) { - real = c.real(); - imag = c.imag(); - } - - HOSTDEVICE inline explicit operator thrust::complex() const { - return thrust::complex(real, imag); - } - -#ifdef PADDLE_WITH_HIP - HOSTDEVICE inline explicit operator hipFloatComplex() const { - return make_hipFloatComplex(real, imag); - } -#else - HOSTDEVICE inline explicit operator cuFloatComplex() const { - return make_cuFloatComplex(real, imag); - } -#endif -#endif - - HOSTDEVICE complex64(const float& val) : real(val), imag(0) {} - HOSTDEVICE complex64(const double& val) - : real(static_cast(val)), imag(0) {} - HOSTDEVICE complex64(const int& val) - : real(static_cast(val)), imag(0) {} - HOSTDEVICE complex64(const int64_t& val) - : real(static_cast(val)), imag(0) {} - HOSTDEVICE complex64(const complex128& val) - : real(static_cast(val.real)), - imag(static_cast(val.imag)) {} - - HOSTDEVICE inline explicit operator std::complex() { - return static_cast>(std::complex(real, imag)); - } - - template - HOSTDEVICE inline explicit complex64(const T& val) - : real(complex64(static_cast(val)).real) {} - - HOSTDEVICE complex64(const std::complex val) - : real(val.real()), imag(val.imag()) {} - - HOSTDEVICE inline complex64& operator=(bool b) { - real = b ? 1 : 0; - imag = 0; - return *this; - } - - HOSTDEVICE inline complex64& operator=(int8_t val) { - real = static_cast(val); - imag = 0; - return *this; - } - - HOSTDEVICE inline complex64& operator=(uint8_t val) { - real = static_cast(val); - imag = 0; - return *this; - } - - HOSTDEVICE inline complex64& operator=(int16_t val) { - real = static_cast(val); - imag = 0; - return *this; - } - - HOSTDEVICE inline complex64& operator=(uint16_t val) { - real = static_cast(val); - imag = 0; - return *this; - } - - HOSTDEVICE inline complex64& operator=(int32_t val) { - real = static_cast(val); - imag = 0; - return *this; - } - - HOSTDEVICE inline complex64& operator=(uint32_t val) { - real = static_cast(val); - imag = 0; - return *this; - } - - HOSTDEVICE inline complex64& operator=(int64_t val) { - real = static_cast(val); - imag = 0; - return *this; - } - - HOSTDEVICE inline complex64& operator=(uint64_t val) { - real = static_cast(val); - imag = 0; - return *this; - } - - HOSTDEVICE inline complex64& operator=(float val) { - real = val; - imag = 0; - return *this; - } - - HOSTDEVICE inline complex64& operator=(double val) { - real = static_cast(val); - imag = 0; - return *this; - } - - HOSTDEVICE inline operator float() const { return this->real; } - - HOSTDEVICE inline explicit operator bool() const { - return static_cast(this->real) || static_cast(this->imag); - } - - HOSTDEVICE inline explicit operator int8_t() const { - return static_cast(this->real); - } - - HOSTDEVICE inline explicit operator uint8_t() const { - return static_cast(this->real); - } - - HOSTDEVICE inline explicit operator int16_t() const { - return static_cast(this->real); - } - - HOSTDEVICE inline explicit operator uint16_t() const { - return static_cast(this->real); - } - - HOSTDEVICE inline explicit operator int32_t() const { - return static_cast(this->real); - } - - HOSTDEVICE inline explicit operator uint32_t() const { - return static_cast(this->real); - } - - HOSTDEVICE inline explicit operator int64_t() const { - return static_cast(this->real); - } - - HOSTDEVICE inline explicit operator uint64_t() const { - return static_cast(this->real); - } - - HOSTDEVICE inline explicit operator double() const { - return static_cast(this->real); - } - - HOSTDEVICE inline operator complex128() const { - return complex128(static_cast(this->real), - static_cast(this->imag)); - } -}; - -HOSTDEVICE inline complex64 operator+(const complex64& a, const complex64& b) { -#if defined(PADDLE_WITH_CUDA_OR_HIP_COMPLEX64) && \ - (defined(__CUDA_ARCH__) || defined(__HIPCC__)) - return complex64(thrust::complex(a.real, a.imag) + - thrust::complex(b.real, b.imag)); -#else - return complex64(a.real + b.real, a.imag + b.imag); -#endif -} - -HOSTDEVICE inline complex64 operator-(const complex64& a, const complex64& b) { -#if defined(PADDLE_WITH_CUDA_OR_HIP_COMPLEX64) && \ - (defined(__CUDA_ARCH__) || defined(__HIPCC__)) - return complex64(thrust::complex(a.real, a.imag) - - thrust::complex(b.real, b.imag)); -#else - return complex64(a.real - b.real, a.imag - b.imag); -#endif -} - -HOSTDEVICE inline complex64 operator*(const complex64& a, const complex64& b) { -#if defined(PADDLE_WITH_CUDA_OR_HIP_COMPLEX64) && \ - (defined(__CUDA_ARCH__) || defined(__HIPCC__)) - return complex64(thrust::complex(a.real, a.imag) * - thrust::complex(b.real, b.imag)); -#else - return complex64(a.real * b.real - a.imag * b.imag, - a.imag * b.real + b.imag * a.real); -#endif -} - -HOSTDEVICE inline complex64 operator/(const complex64& a, const complex64& b) { -#if defined(PADDLE_WITH_CUDA_OR_HIP_COMPLEX64) && \ - (defined(__CUDA_ARCH__) || defined(__HIPCC__)) - return complex64(thrust::complex(a.real, a.imag) / - thrust::complex(b.real, b.imag)); -#else - float denominator = b.real * b.real + b.imag * b.imag; - return complex64((a.real * b.real + a.imag * b.imag) / denominator, - (a.imag * b.real - a.real * b.imag) / denominator); -#endif -} - -HOSTDEVICE inline complex64 operator-(const complex64& a) { -#if defined(PADDLE_WITH_CUDA_OR_HIP_COMPLEX64) && \ - (defined(__CUDA_ARCH__) || defined(__HIPCC__)) - return complex64(-thrust::complex(a.real, a.imag)); -#else - complex64 res; - res.real = -a.real; - res.imag = -a.imag; - return res; -#endif -} - -HOSTDEVICE inline complex64& operator+=(complex64& a, // NOLINT - const complex64& b) { -#if defined(PADDLE_WITH_CUDA_OR_HIP_COMPLEX64) && \ - (defined(__CUDA_ARCH__) || defined(__HIPCC__)) - a = complex64(thrust::complex(a.real, a.imag) += - thrust::complex(b.real, b.imag)); - return a; -#else - a.real += b.real; - a.imag += b.imag; - return a; -#endif -} - -HOSTDEVICE inline complex64& operator-=(complex64& a, // NOLINT - const complex64& b) { -#if defined(PADDLE_WITH_CUDA_OR_HIP_COMPLEX64) && \ - (defined(__CUDA_ARCH__) || defined(__HIPCC__)) - a = complex64(thrust::complex(a.real, a.imag) -= - thrust::complex(b.real, b.imag)); - return a; -#else - a.real -= b.real; - a.imag -= b.imag; - return a; -#endif -} - -HOSTDEVICE inline complex64& operator*=(complex64& a, // NOLINT - const complex64& b) { -#if defined(PADDLE_WITH_CUDA_OR_HIP_COMPLEX64) && \ - (defined(__CUDA_ARCH__) || defined(__HIPCC__)) - a = complex64(thrust::complex(a.real, a.imag) *= - thrust::complex(b.real, b.imag)); - return a; -#else - a.real = a.real * b.real - a.imag * b.imag; - a.imag = a.imag * b.real + b.imag * a.real; - return a; -#endif -} - -HOSTDEVICE inline complex64& operator/=(complex64& a, // NOLINT - const complex64& b) { -#if defined(PADDLE_WITH_CUDA_OR_HIP_COMPLEX64) && \ - (defined(__CUDA_ARCH__) || defined(__HIPCC__)) - a = complex64(thrust::complex(a.real, a.imag) /= - thrust::complex(b.real, b.imag)); - return a; -#else - float denominator = b.real * b.real + b.imag * b.imag; - a.real = (a.real * b.real + a.imag * b.imag) / denominator; - a.imag = (a.imag * b.real - a.real * b.imag) / denominator; - return a; -#endif -} - -HOSTDEVICE inline complex64 raw_uint16_to_complex64(uint16_t a) { - complex64 res; - res.real = a; - return res; -} - -HOSTDEVICE inline bool operator==(const complex64& a, const complex64& b) { - return a.real == b.real && a.imag == b.imag; -} - -HOSTDEVICE inline bool operator!=(const complex64& a, const complex64& b) { - return a.real != b.real || a.imag != b.imag; -} - -HOSTDEVICE inline bool operator<(const complex64& a, const complex64& b) { - return static_cast(a.real) < static_cast(b.real); -} - -HOSTDEVICE inline bool operator<=(const complex64& a, const complex64& b) { - return static_cast(a.real) <= static_cast(b.real); -} - -HOSTDEVICE inline bool operator>(const complex64& a, const complex64& b) { - return static_cast(a.real) > static_cast(b.real); -} - -HOSTDEVICE inline bool operator>=(const complex64& a, const complex64& b) { - return static_cast(a.real) >= static_cast(b.real); -} - -HOSTDEVICE inline bool(isnan)(const complex64& a) { -#if defined(PADDLE_WITH_CUDA) && defined(__CUDA_ARCH__) - // __isnanf not supported on HIP platform - return __isnanf(a.real) || __isnanf(a.imag); -#else - return std::isnan(a.real) || std::isnan(a.imag); -#endif -} - -HOSTDEVICE inline bool(isinf)(const complex64& a) { -#if defined(PADDLE_WITH_CUDA) && defined(__CUDA_ARCH__) - // __isinff not supported on HIP platform - return __isinff(a.real) || __isinff(a.imag); -#else - return std::isinf(a.real) || std::isinf(a.imag); -#endif -} - -HOSTDEVICE inline bool(isfinite)(const complex64& a) { - return !((isnan)(a)) && !((isinf)(a)); -} - -HOSTDEVICE inline float(abs)(const complex64& a) { -#if defined(PADDLE_WITH_CUDA_OR_HIP_COMPLEX64) && \ - (defined(__CUDA_ARCH__) || defined(__HIPCC__)) - return complex64(thrust::abs(thrust::complex(a.real, a.imag))); -#else - return std::abs(std::complex(a.real, a.imag)); -#endif -} - -HOSTDEVICE inline complex64(pow)(const complex64& a, const complex64& b) { -#if defined(PADDLE_WITH_CUDA_OR_HIP_COMPLEX64) && \ - (defined(__CUDA_ARCH__) || defined(__HIPCC__)) - return complex64(thrust::pow(thrust::complex(a.real, a.imag), - thrust::complex(b.real, b.imag))); -#else - return std::pow(std::complex(a), std::complex(b)); -#endif -} - -HOSTDEVICE inline complex64(sqrt)(const complex64& a) { -#if defined(PADDLE_WITH_CUDA_OR_HIP_COMPLEX64) && \ - (defined(__CUDA_ARCH__) || defined(__HIPCC__)) - return complex64(thrust::sqrt(thrust::complex(a.real, a.imag))); -#else - return std::sqrt(std::complex(a)); -#endif -} - -HOSTDEVICE inline complex64(tanh)(const complex64& a) { -#if defined(PADDLE_WITH_CUDA_OR_HIP_COMPLEX64) && \ - (defined(__CUDA_ARCH__) || defined(__HIPCC__)) - return complex64(thrust::tanh(thrust::complex(a.real, a.imag))); -#else - return std::tanh(std::complex(a)); -#endif -} - -HOSTDEVICE inline complex64(log)(const complex64& a) { -#if defined(PADDLE_WITH_CUDA_OR_HIP_COMPLEX64) && \ - (defined(__CUDA_ARCH__) || defined(__HIPCC__)) - return complex64(thrust::log(thrust::complex(a.real, a.imag))); -#else - return std::log(std::complex(a)); -#endif -} - -inline std::ostream& operator<<(std::ostream& os, const complex64& a) { - os << "real:" << a.real << " imag:" << a.imag; - return os; -} - -} // namespace platform -} // namespace paddle - -namespace std { - -template <> -struct is_pod { - static const bool value = - is_trivial::value && - is_standard_layout::value; -}; - -template <> -struct is_floating_point - : std::integral_constant< - bool, std::is_same::type>::value> {}; -template <> -struct is_signed { - static const bool value = false; -}; - -template <> -struct is_unsigned { - static const bool value = false; -}; - -inline bool isnan(const paddle::platform::complex64& a) { - return paddle::platform::isnan(a); -} - -inline bool isinf(const paddle::platform::complex64& a) { - return paddle::platform::isinf(a); -} - -template <> -struct numeric_limits { - static const bool is_specialized = false; - static const bool is_signed = false; - static const bool is_integer = false; - static const bool is_exact = false; - static const bool has_infinity = false; - static const bool has_quiet_NaN = false; - static const bool has_signaling_NaN = false; - static const float_denorm_style has_denorm = denorm_absent; - static const bool has_denorm_loss = false; - static const std::float_round_style round_style = std::round_toward_zero; - static const bool is_iec559 = false; - static const bool is_bounded = false; - static const bool is_modulo = false; - static const int digits = 0; - static const int digits10 = 0; - static const int max_digits10 = 0; - static const int radix = 0; - static const int min_exponent = 0; - static const int min_exponent10 = 0; - static const int max_exponent = 0; - static const int max_exponent10 = 0; - static const bool traps = false; - static const bool tinyness_before = false; - - static paddle::platform::complex64(min)() { - return paddle::platform::complex64(0.0, 0.0); - } - static paddle::platform::complex64 lowest() { - return paddle::platform::complex64(0.0, 0.0); - } - static paddle::platform::complex64(max)() { - return paddle::platform::complex64(0.0, 0.0); - } - static paddle::platform::complex64 epsilon() { - return paddle::platform::complex64(0.0, 0.0); - } - static paddle::platform::complex64 round_error() { - return paddle::platform::complex64(0.0, 0.0); - } - static paddle::platform::complex64 infinity() { - return paddle::platform::complex64(0.0, 0.0); - } - static paddle::platform::complex64 quiet_NaN() { - return paddle::platform::complex64(0.0, 0.0); - } - static paddle::platform::complex64 signaling_NaN() { - return paddle::platform::complex64(0.0, 0.0); - } - static paddle::platform::complex64 denorm_min() { - return paddle::platform::complex64(0.0, 0.0); - } -}; - -} // namespace std - -#define MKL_Complex8 paddle::platform::complex64 diff --git a/paddle/fluid/platform/eigen_ext.h b/paddle/fluid/platform/eigen_ext.h index 4eea87e909d1b45e1f5323f774138529961961c8..49bd57f0406d63ba2421025e9592004e75cea2d4 100644 --- a/paddle/fluid/platform/eigen_ext.h +++ b/paddle/fluid/platform/eigen_ext.h @@ -17,7 +17,6 @@ #include "paddle/fluid/platform/bfloat16.h" #include "paddle/fluid/platform/complex.h" #include "paddle/fluid/platform/complex128.h" -#include "paddle/fluid/platform/complex64.h" #include "paddle/fluid/platform/float16.h" #include "paddle/fluid/platform/hostdevice.h" @@ -25,7 +24,6 @@ namespace Eigen { -using complex64 = paddle::platform::complex64; using complex128 = paddle::platform::complex128; using float16 = paddle::platform::float16; template @@ -64,28 +62,6 @@ struct NumTraits } }; -template <> -struct NumTraits : GenericNumTraits> { - typedef float Real; - typedef typename NumTraits::Literal Literal; - enum { - IsComplex = 1, - RequireInitialization = NumTraits::RequireInitialization, - ReadCost = 2 * NumTraits::ReadCost, - AddCost = 2 * NumTraits::AddCost, - MulCost = 4 * NumTraits::MulCost + 2 * NumTraits::AddCost - }; - - EIGEN_DEVICE_FUNC - static inline Real epsilon() { return NumTraits::epsilon(); } - EIGEN_DEVICE_FUNC - static inline Real dummy_precision() { - return NumTraits::dummy_precision(); - } - EIGEN_DEVICE_FUNC - static inline int digits10() { return NumTraits::digits10(); } -}; - template <> struct NumTraits : GenericNumTraits> { typedef double Real; @@ -271,71 +247,6 @@ HOSTDEVICE inline paddle::platform::bfloat16 maxi( return a < b ? b : a; } -//////////// complex64 methods ///////////// - -template <> -HOSTDEVICE inline bool(isnan)(const complex64& a) { - return (paddle::platform::isnan)(a); -} - -template <> -HOSTDEVICE inline bool(isinf)(const complex64& a) { - return (paddle::platform::isinf)(a); -} - -template <> -HOSTDEVICE inline bool(isfinite)(const complex64& a) { - return (paddle::platform::isfinite)(a); -} - -template <> -HOSTDEVICE inline complex64 exp(const complex64& a) { - float com = ::expf(a.real); - float res_real = com * ::cosf(a.imag); - float res_imag = com * ::sinf(a.imag); - return complex64(res_real, res_imag); -} - -template <> -HOSTDEVICE inline complex64 log(const complex64& a) { - return paddle::platform::log(a); -} - -template <> -HOSTDEVICE inline complex64 tanh(const complex64& a) { - return paddle::platform::tanh(a); -} - -template <> -HOSTDEVICE inline complex64 sqrt(const complex64& a) { - return paddle::platform::sqrt(a); -} - -template <> -HOSTDEVICE inline complex64 ceil(const complex64& a) { - return complex64(::ceilf(a.real), ::ceilf(a.imag)); -} - -template <> -HOSTDEVICE inline complex64 floor(const complex64& a) { - return complex64(::floorf(a.real), ::floor(a.imag)); -} - -template <> -HOSTDEVICE inline complex64 round(const complex64& a) { - return complex64(::roundf(a.real), ::roundf(a.imag)); -} - -template <> -HOSTDEVICE inline complex64 pow(const complex64& a, const complex64& b) { - return paddle::platform::pow(a, b); -} - -template <> -HOSTDEVICE inline float abs(const complex64& a) { - return paddle::platform::abs(a); -} - //////////// complex128 methods ///////////// template <> diff --git a/python/setup.py.in b/python/setup.py.in index 3bc3057b335919186c206366c1487b66cb5e53d8..98d05c367f162330fd4f19d046c311bf01480399 100644 --- a/python/setup.py.in +++ b/python/setup.py.in @@ -404,8 +404,6 @@ headers = ( list(find_files('*', '${BOOST_INCLUDE_DIR}/boost', True)) + # boost # For paddle uew custom op, only copy data type headers from `paddle/fluid/platform` # to `extension/incude`, - ['@PADDLE_SOURCE_DIR@/paddle/fluid/platform/complex64.h'] + - ['@PADDLE_SOURCE_DIR@/paddle/fluid/platform/complex128.h'] + ['@PADDLE_SOURCE_DIR@/paddle/fluid/platform/complex.h'] + ['@PADDLE_SOURCE_DIR@/paddle/fluid/platform/float16.h'])