diff --git a/paddle/fluid/eager/eager_tensor.h b/paddle/fluid/eager/eager_tensor.h index 4383cf0fcf9702e5b7e6d28f9cc10821b5c92854..fafdf9b65b171bb73c9b5608d8a2c5950b4dbb43 100644 --- a/paddle/fluid/eager/eager_tensor.h +++ b/paddle/fluid/eager/eager_tensor.h @@ -21,7 +21,7 @@ #include "paddle/pten/api/all.h" #include "paddle/pten/api/lib/api_declare.h" #include "paddle/pten/api/lib/utils/tensor_utils.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" /** * This class is used by Eager mode for now. It's painful to do this in Eager * Mode, the better diff --git a/paddle/fluid/framework/custom_kernel.cc b/paddle/fluid/framework/custom_kernel.cc index a5498623941f81b32aa72d7849074f1c4bfd7b7d..1ba7c4481edb1b29ec7be45db1efadfd33bf7e07 100644 --- a/paddle/fluid/framework/custom_kernel.cc +++ b/paddle/fluid/framework/custom_kernel.cc @@ -25,7 +25,7 @@ limitations under the License. */ #include "paddle/fluid/framework/operator.h" #include "paddle/fluid/platform/enforce.h" #include "paddle/pten/api/ext/op_kernel_info.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/kernel_context.h" #include "paddle/pten/core/kernel_registry.h" diff --git a/paddle/fluid/framework/custom_operator.cc b/paddle/fluid/framework/custom_operator.cc index 0fa1d1f8cb708be18463a707581d6f55e63dd4eb..35b6b918931d4fe0bcd9dcfa63d91fbb8ee551dd 100644 --- a/paddle/fluid/framework/custom_operator.cc +++ b/paddle/fluid/framework/custom_operator.cc @@ -37,7 +37,7 @@ limitations under the License. */ #include "paddle/pten/api/lib/api_declare.h" #include "paddle/pten/api/lib/ext_compat_utils.h" #include "paddle/pten/api/lib/utils/tensor_utils.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/utils/any.h" namespace paddle { diff --git a/paddle/fluid/framework/dim.h b/paddle/fluid/framework/dim.h index 6abae4e73183295257c0a32c7069cf257507e794..21975485add1b33f81a77e05da61e675d2b6d199 100644 --- a/paddle/fluid/framework/dim.h +++ b/paddle/fluid/framework/dim.h @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. #pragma once -#include "paddle/pten/core/dim.h" +#include "paddle/pten/core/utils/dim.h" namespace paddle { namespace framework { diff --git a/paddle/fluid/framework/infershape_utils.cc b/paddle/fluid/framework/infershape_utils.cc index 52c0aa003e8fa18c15cb6fc9351ac408f07506a5..80787c3b87121da0508cac7f3e0069e066ed534e 100644 --- a/paddle/fluid/framework/infershape_utils.cc +++ b/paddle/fluid/framework/infershape_utils.cc @@ -18,12 +18,12 @@ limitations under the License. */ #include "paddle/fluid/framework/pten_utils.h" #include "paddle/fluid/platform/enforce.h" #include "paddle/pten/core/compat/arg_map_context.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/compat/op_utils.h" -#include "paddle/pten/core/compat_utils.h" -#include "paddle/pten/core/convert_utils.h" #include "paddle/pten/core/dense_tensor.h" #include "paddle/pten/core/infermeta_utils.h" #include "paddle/pten/core/meta_tensor.h" +#include "paddle/pten/core/tensor_utils.h" namespace paddle { namespace framework { @@ -126,8 +126,9 @@ class CompatMetaTensor : public pten::MetaTensor { auto* var = BOOST_GET_CONST(Variable*, var_); return var->Get().layout(); } else { - PADDLE_THROW(platform::errors::Unimplemented( - "Unsupported get layout for VarDesc now.")); + // NOTE(chenweihang): do nothing + // Unsupported get layout for VarDesc now + return DataLayout::UNDEFINED; } } @@ -135,7 +136,7 @@ class CompatMetaTensor : public pten::MetaTensor { if (is_runtime_) { auto* var = BOOST_GET(Variable*, var_); LoDTensor* tensor = var->GetMutable(); - pten::CompatibleDenseTensorUtils::GetMutableMeta( + pten::DenseTensorUtils::GetMutableMeta( static_cast(tensor)) ->dims = dims; } else { @@ -148,7 +149,7 @@ class CompatMetaTensor : public pten::MetaTensor { if (is_runtime_) { auto* var = BOOST_GET(Variable*, var_); LoDTensor* tensor = var->GetMutable(); - pten::CompatibleDenseTensorUtils::GetMutableMeta( + pten::DenseTensorUtils::GetMutableMeta( static_cast(tensor)) ->dtype = dtype; } else { @@ -161,12 +162,12 @@ class CompatMetaTensor : public pten::MetaTensor { if (is_runtime_) { auto* var = BOOST_GET(Variable*, var_); LoDTensor* tensor = var->GetMutable(); - pten::CompatibleDenseTensorUtils::GetMutableMeta( + pten::DenseTensorUtils::GetMutableMeta( static_cast(tensor)) ->layout = layout; } else { - PADDLE_THROW(platform::errors::Unimplemented( - "Unsupported set layout for VarDesc now.")); + // NOTE(chenweihang): do nothing + // Unsupported set layout for VarDesc now } } @@ -174,7 +175,7 @@ class CompatMetaTensor : public pten::MetaTensor { if (is_runtime_) { auto* var = BOOST_GET(Variable*, var_); LoDTensor* tensor = var->GetMutable(); - pten::CompatibleDenseTensorUtils::GetMutableMeta( + pten::DenseTensorUtils::GetMutableMeta( static_cast(tensor)) ->lod = static_cast(meta_tensor).GetRuntimeLoD(); diff --git a/paddle/fluid/framework/pten_utils.cc b/paddle/fluid/framework/pten_utils.cc index 336f8423d6f0b46250279c16289947376ba3e8c9..afcee19c6fafed8873f39c67272dbae7916e0b5e 100644 --- a/paddle/fluid/framework/pten_utils.cc +++ b/paddle/fluid/framework/pten_utils.cc @@ -15,8 +15,8 @@ limitations under the License. */ #include #include "paddle/fluid/framework/pten_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/compat/op_utils.h" -#include "paddle/pten/core/convert_utils.h" #include "paddle/pten/core/kernel_factory.h" #include "paddle/fluid/framework/lod_tensor.h" diff --git a/paddle/fluid/framework/tensor.cc b/paddle/fluid/framework/tensor.cc index bb8d7df7457501566c6e60033daff4813cb64973..2f0c7c5b2c86f32a0c4fbe2561fc639400f738b1 100644 --- a/paddle/fluid/framework/tensor.cc +++ b/paddle/fluid/framework/tensor.cc @@ -13,7 +13,6 @@ See the License for the specific language governing permissions and limitations under the License. */ #include "paddle/fluid/framework/tensor.h" -#include "paddle/pten/api/lib/utils/storage.h" DECLARE_bool(use_stream_safe_cuda_allocator); diff --git a/paddle/fluid/framework/type_defs.h b/paddle/fluid/framework/type_defs.h index fe376a5669c984e439fcb8b93de25b96462d21de..5a13df783ae78eb7313b238573fe1085f3faae5e 100644 --- a/paddle/fluid/framework/type_defs.h +++ b/paddle/fluid/framework/type_defs.h @@ -22,7 +22,7 @@ limitations under the License. */ #include #include #include "paddle/fluid/platform/variant.h" -#include "paddle/pten/core/type_defs.h" +#include "paddle/pten/core/compat/type_defs.h" #include "paddle/utils/small_vector.h" namespace paddle { diff --git a/paddle/fluid/imperative/type_defs.h b/paddle/fluid/imperative/type_defs.h index a0258c7a8806fb4562102f7e681d292227bee5ae..a248f29ee9c08473775e419dcc8fc78c1416ca08 100644 --- a/paddle/fluid/imperative/type_defs.h +++ b/paddle/fluid/imperative/type_defs.h @@ -13,4 +13,4 @@ See the License for the specific language governing permissions and limitations under the License. */ #pragma once -#include "paddle/pten/core/type_defs.h" +#include "paddle/pten/core/compat/type_defs.h" diff --git a/paddle/fluid/operators/elementwise/elementwise_functor.h b/paddle/fluid/operators/elementwise/elementwise_functor.h index daca105ce46bb266ff8e53d93286415804a2594a..19d3a6c385c603b4455320ddd9ae3961237da216 100644 --- a/paddle/fluid/operators/elementwise/elementwise_functor.h +++ b/paddle/fluid/operators/elementwise/elementwise_functor.h @@ -15,7 +15,7 @@ limitations under the License. */ #pragma once #include "paddle/fluid/platform/complex.h" -#include "paddle/pten/core/array.h" +#include "paddle/pten/core/utils/array.h" #include "paddle/pten/kernels/funcs/elementwise_functor.h" namespace paddle { diff --git a/paddle/fluid/operators/roll_op.cu b/paddle/fluid/operators/roll_op.cu index 7e8e37bd2ee8fd332762a952ec8fd493de2ae3bb..0f861179b2d9679751012e5b8d5b46c8d6306233 100644 --- a/paddle/fluid/operators/roll_op.cu +++ b/paddle/fluid/operators/roll_op.cu @@ -17,7 +17,7 @@ #include "paddle/fluid/operators/roll_op.h" #include "paddle/fluid/platform/complex.h" #include "paddle/fluid/platform/device/gpu/gpu_primitives.h" -#include "paddle/pten/core/array.h" +#include "paddle/pten/core/utils/array.h" namespace paddle { namespace operators { diff --git a/paddle/fluid/pybind/eager.cc b/paddle/fluid/pybind/eager.cc index 0aacbe5e3251939390d108e7f0b032a76a05a935..6ace81594260522c6f4568bd41ec45d2209f355a 100644 --- a/paddle/fluid/pybind/eager.cc +++ b/paddle/fluid/pybind/eager.cc @@ -24,7 +24,7 @@ limitations under the License. */ #include "paddle/fluid/pybind/eager.h" #include "paddle/fluid/pybind/eager_utils.h" #include "paddle/pten/common/data_type.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/dense_tensor.h" #include "pybind11/detail/internals.h" #include "pybind11/numpy.h" diff --git a/paddle/fluid/pybind/eager_functions.cc b/paddle/fluid/pybind/eager_functions.cc index 44fc95938392c04341d7b6ef1c1e57c93cbfc314..a5167e9ebae8c2e3afe490e1a015eecb59ea0e3d 100644 --- a/paddle/fluid/pybind/eager_functions.cc +++ b/paddle/fluid/pybind/eager_functions.cc @@ -32,7 +32,7 @@ limitations under the License. */ #include "paddle/pten/api/lib/utils/storage.h" #include "paddle/pten/api/lib/utils/tensor_utils.h" #include "paddle/pten/common/data_type.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/dense_tensor.h" namespace paddle { diff --git a/paddle/fluid/pybind/eager_method.cc b/paddle/fluid/pybind/eager_method.cc index 4835d8873af19f2e79c27c857325d86ed4d3c696..414c60adf03b33a3ed828e7a7e0b524727e04d0d 100644 --- a/paddle/fluid/pybind/eager_method.cc +++ b/paddle/fluid/pybind/eager_method.cc @@ -29,7 +29,7 @@ limitations under the License. */ #include "paddle/fluid/pybind/exception.h" #include "paddle/pten/api/include/api.h" #include "paddle/pten/common/data_type.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/dense_tensor.h" namespace paddle { namespace pybind { diff --git a/paddle/fluid/pybind/eager_properties.cc b/paddle/fluid/pybind/eager_properties.cc index 5f1d809168a42dd5994dca5a0cf471fe5810f7c0..d8dac3c62875085481e5c0b8b9e2249da2692261 100644 --- a/paddle/fluid/pybind/eager_properties.cc +++ b/paddle/fluid/pybind/eager_properties.cc @@ -26,7 +26,7 @@ limitations under the License. */ #include "paddle/fluid/pybind/eager_utils.h" #include "paddle/fluid/pybind/exception.h" #include "paddle/pten/common/data_type.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/dense_tensor.h" #pragma GCC diagnostic ignored "-Wwrite-strings" diff --git a/paddle/fluid/pybind/eager_utils.cc b/paddle/fluid/pybind/eager_utils.cc index 1e0697246e9257388765da82ee9b4e1bda147f30..0f21bd4ae3769a4ae706f8f3d7a31ff3022568b5 100644 --- a/paddle/fluid/pybind/eager_utils.cc +++ b/paddle/fluid/pybind/eager_utils.cc @@ -24,7 +24,7 @@ limitations under the License. */ #include "paddle/fluid/pybind/op_function_common.h" #include "paddle/fluid/pybind/tensor_py.h" #include "paddle/pten/common/data_type.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/dense_tensor.h" namespace paddle { diff --git a/paddle/pten/api/lib/api_utils.h b/paddle/pten/api/lib/api_utils.h index f3e7d74db1e89fddc27af6272c47a8e9e05af8bb..6332132fac2fd0c529eeef6754d173d33195d39d 100644 --- a/paddle/pten/api/lib/api_utils.h +++ b/paddle/pten/api/lib/api_utils.h @@ -16,7 +16,7 @@ limitations under the License. */ #include "paddle/pten/api/include/tensor.h" #include "paddle/pten/api/lib/utils/storage.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/dense_tensor.h" namespace paddle { diff --git a/paddle/pten/api/lib/kernel_dispatch.cc b/paddle/pten/api/lib/kernel_dispatch.cc index 7930869632a6698581242584efd2b710d6b0b5f5..831d01b7cf5adc58d12d30113052b23fa691fba6 100644 --- a/paddle/pten/api/lib/kernel_dispatch.cc +++ b/paddle/pten/api/lib/kernel_dispatch.cc @@ -14,7 +14,7 @@ limitations under the License. */ #include "paddle/pten/api/lib/kernel_dispatch.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" namespace paddle { namespace experimental { diff --git a/paddle/pten/api/lib/tensor.cc b/paddle/pten/api/lib/tensor.cc index 02fd918d799be6c226da73813efecd930b9bb56b..5ab6e5e76325b4649e9b5b46c6d9db6eb547d869 100644 --- a/paddle/pten/api/lib/tensor.cc +++ b/paddle/pten/api/lib/tensor.cc @@ -23,11 +23,11 @@ limitations under the License. */ #include "paddle/pten/api/lib/ext_compat_utils.h" #include "paddle/pten/api/lib/utils/allocator.h" #include "paddle/pten/api/lib/utils/storage.h" -#include "paddle/pten/core/compat_utils.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/dense_tensor.h" #include "paddle/pten/core/tensor_base.h" #include "paddle/pten/core/tensor_meta.h" +#include "paddle/pten/core/tensor_utils.h" /** * [ Why still include the fluid headers? ] @@ -77,7 +77,7 @@ Tensor::Tensor(const PlaceType &place) std::move(pten::make_intrusive( ConvertExtPlaceToInnerPlace(place))), std::move(pten::DenseTensorMeta(pten::DataType::UNDEFINED, - framework::make_ddim({}), + pten::framework::make_ddim({}), pten::DataLayout::NCHW))))), place_{place} {} @@ -86,7 +86,7 @@ Tensor::Tensor(const PlaceType &place, const std::vector &shape) std::move(pten::make_intrusive( ConvertExtPlaceToInnerPlace(place))), std::move(pten::DenseTensorMeta(pten::DataType::UNDEFINED, - framework::make_ddim(shape), + pten::framework::make_ddim(shape), pten::DataLayout::NCHW))))), place_{place} {} @@ -113,7 +113,7 @@ void Tensor::reshape(const std::vector &shape) { "the tensor to remain constant."; if (is_dense_tensor()) { std::dynamic_pointer_cast(impl_)->set_meta( - pten::DenseTensorMeta(dtype(), framework::make_ddim(shape))); + pten::DenseTensorMeta(dtype(), pten::framework::make_ddim(shape))); } else { PADDLE_THROW(pten::errors::Unimplemented( "Only support reshape operation on DenseTensor now.")); @@ -270,7 +270,7 @@ Tensor::data(); Tensor Tensor::slice(int64_t begin_idx, int64_t end_idx) const { if (is_dense_tensor()) { return Tensor(std::make_shared( - std::move(pten::CompatibleDenseTensorUtils::Slice( + std::move(pten::DenseTensorUtils::Slice( *(std::dynamic_pointer_cast(impl_).get()), begin_idx, end_idx)))); diff --git a/paddle/pten/api/lib/utils/storage.h b/paddle/pten/api/lib/utils/storage.h index a02e5d46a65c5b97550a67aa743577164a2ec231..4e311135eebb89419c7743d57d1c83ec01aee275 100644 --- a/paddle/pten/api/lib/utils/storage.h +++ b/paddle/pten/api/lib/utils/storage.h @@ -22,7 +22,7 @@ namespace experimental { class ExternalStorage : public pten::Storage { public: - ExternalStorage(void* ptr, size_t size, const paddle::platform::Place& place); + ExternalStorage(void* ptr, size_t size, const pten::Place& place); ExternalStorage(const pten::intrusive_ptr& root, size_t delta, size_t size); @@ -52,7 +52,7 @@ class ExternalStorage : public pten::Storage { } size_t size() const noexcept override { return size_; } - const paddle::platform::Place& place() const override { + const pten::Place& place() const override { PADDLE_ENFORCE_NOT_NULL( data_, paddle::platform::errors::Unavailable( @@ -78,9 +78,7 @@ class SharedStorage : public pten::Storage { // In order to be compatible with the original Tensor design and execution // system, we need to allow the uninitialized SharedStorage to exist, // and it can be removed after the compatibility phase is over in the future - explicit SharedStorage(const paddle::platform::Place& place) { - place_ = place; - } + explicit SharedStorage(const pten::Place& place) { place_ = place; } void Realloc(size_t n) override { this->Clear(); @@ -106,14 +104,14 @@ class SharedStorage : public pten::Storage { std::shared_ptr&& move_data_shared() override { size_ = 0; - place_ = Place(); + place_ = pten::Place(); return std::move(data_); } size_t size() const noexcept override { return data_ ? data_->size() : size_; } - const paddle::platform::Place& place() const override { + const pten::Place& place() const override { return data_ ? data_->place() : place_; } bool OwnsMemory() const noexcept override { return false; } @@ -130,15 +128,13 @@ class SharedStorage : public pten::Storage { } // Temporary method: For compatible with fluid Tensor and improve performance - void ResetAllocationPlace(const paddle::platform::Place& place) { - place_ = place; - } + void ResetAllocationPlace(const pten::Place& place) { place_ = place; } // Temporary method: For compatible with fluid Tensor and improve performance void Reset() { this->Clear(); } private: - Place place_; + pten::Place place_; int64_t size_{0}; }; diff --git a/paddle/pten/api/lib/utils/tensor_utils.cc b/paddle/pten/api/lib/utils/tensor_utils.cc index 1289353a6c760de1c52b338ec885d830b46631ed..8fdfc29540bfada65c1b32137eca018a293459b1 100644 --- a/paddle/pten/api/lib/utils/tensor_utils.cc +++ b/paddle/pten/api/lib/utils/tensor_utils.cc @@ -17,7 +17,7 @@ limitations under the License. */ #include #include -#include "paddle/pten/core/compat_utils.h" +#include "paddle/pten/core/tensor_utils.h" namespace paddle { namespace experimental { @@ -201,7 +201,7 @@ pten::ScalarArray MakePtenScalarArrayFromVarList( void ResetTensorByArgDef(pten::DenseTensor* dst, const pten::TensorArgDef& arg_def) { VLOG(5) << "ResetTensor by TensorArgDef."; - auto* meta = pten::CompatibleDenseTensorUtils::GetMutableMeta(dst); + auto* meta = pten::DenseTensorUtils::GetMutableMeta(dst); meta->dtype = arg_def.dtype; meta->layout = arg_def.layout; } diff --git a/paddle/pten/api/lib/utils/tensor_utils.h b/paddle/pten/api/lib/utils/tensor_utils.h index bf8d9b83174952f877a0aea7e5e7e58056d8e08c..1ffcc7d4d5b70a11f288efbd8a8c46a716fb42dc 100644 --- a/paddle/pten/api/lib/utils/tensor_utils.h +++ b/paddle/pten/api/lib/utils/tensor_utils.h @@ -23,7 +23,7 @@ limitations under the License. */ #include "paddle/pten/api/lib/utils/storage.h" #include "paddle/pten/common/scalar.h" #include "paddle/pten/common/scalar_array.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/dense_tensor.h" #include "paddle/pten/core/kernel_factory.h" diff --git a/paddle/pten/core/CMakeLists.txt b/paddle/pten/core/CMakeLists.txt index ab6a99319732d4c07f6224b181d05e7efd696aba..46cd2a96414de05fd33886e9b21a7499abc663b4 100644 --- a/paddle/pten/core/CMakeLists.txt +++ b/paddle/pten/core/CMakeLists.txt @@ -1,14 +1,6 @@ -# utils used for compatible for fluid op system +# compatible utils used for fluid op system add_subdirectory(compat) -if(WITH_GPU) - cc_library(convert_utils SRCS convert_utils.cc DEPS data_type place gpu_info) -elseif(WITH_ROCM) - cc_library(convert_utils SRCS convert_utils.cc DEPS data_type place gpu_info) -else() - cc_library(convert_utils SRCS convert_utils.cc DEPS data_type place) -endif() - cc_library(errors SRCS errors.cc) set(pten_enforce_deps errors flags) if(WITH_GPU) @@ -19,21 +11,20 @@ cc_library(pten_enforce INTERFACE SRCS enforce.cc DEPS ${pten_enforce_deps}) cc_library(kernel_factory SRCS kernel_factory.cc DEPS pten_enforce convert_utils) cc_library(kernel_context SRCS kernel_context.cc DEPS pten_enforce pten_context) -cc_library(tensor_base SRCS tensor_base.cc allocator.cc storage.cc DEPS pten_enforce) +cc_library(ddim SRCS ddim.cc DEPS pten_enforce) +cc_library(tensor_base SRCS tensor_base.cc allocator.cc DEPS pten_enforce) cc_library(tensor_meta SRCS tensor_meta.cc DEPS pten_enforce mixed_vector) cc_library(lod_utils SRCS lod_utils.cc DEPS pten_enforce mixed_vector) + +cc_library(pten_device_context SRCS device_context.cc DEPS tensor_base) +cc_library(dense_tensor SRCS dense_tensor.cc dense_tensor_impl.cc DEPS convert_utils tensor_meta tensor_base) cc_library(sparse_coo_tensor SRCS sparse_coo_tensor.cc DEPS tensor_meta tensor_base) cc_library(sparse_csr_tensor SRCS sparse_csr_tensor.cc DEPS dense_tensor tensor_base) -cc_library(dense_tensor SRCS dense_tensor.cc dense_tensor_impl.cc DEPS convert_utils tensor_meta tensor_base) -cc_library(pten_device_context SRCS device_context.cc DEPS tensor_base ) cc_library(meta_tensor SRCS meta_tensor.cc DEPS tensor_base tensor_meta dense_tensor) cc_library(infermeta_utils SRCS infermeta_utils.cc DEPS meta_tensor) cc_library(selected_rows SRCS selected_rows.cc DEPS dense_tensor mixed_vector pten_enforce ddim) -cc_test(unroll_array_ops_test SRCS unroll_array_ops_test.cc) -cc_library(ddim SRCS ddim.cc DEPS eigen3 boost enforce) - # Will remove once we implemented MKLDNN_Tensor if(WITH_MKLDNN) add_dependencies(dense_tensor mkldnn) diff --git a/paddle/pten/core/allocator.h b/paddle/pten/core/allocator.h index 75d42c4fd15cb13e10c86dd1f1b42700a53b83bd..098e5698deea484e33ddf2a0ca0562133d26cdf7 100644 --- a/paddle/pten/core/allocator.h +++ b/paddle/pten/core/allocator.h @@ -16,7 +16,9 @@ limitations under the License. */ #include #include -#include "paddle/fluid/platform/place.h" +#include + +#include "paddle/pten/common/place.h" namespace pten { @@ -26,7 +28,7 @@ namespace pten { /// support being inherited. class Allocation { public: - using Place = paddle::platform::Place; + using Place = pten::Place; using DeleterFnPtr = void (*)(Allocation*); Allocation() = default; diff --git a/paddle/pten/core/compat/CMakeLists.txt b/paddle/pten/core/compat/CMakeLists.txt index 0c081edb81ccf740ed74c377070f4847650a1ff2..f97d5cb9f6a2db479c724e5263cbb0f67c17c85f 100644 --- a/paddle/pten/core/compat/CMakeLists.txt +++ b/paddle/pten/core/compat/CMakeLists.txt @@ -1,2 +1,9 @@ cc_library(arg_map_context SRCS arg_map_context.cc DEPS pten_enforce) +if(WITH_GPU) + cc_library(convert_utils SRCS convert_utils.cc DEPS data_type place gpu_info) +elseif(WITH_ROCM) + cc_library(convert_utils SRCS convert_utils.cc DEPS data_type place gpu_info) +else() + cc_library(convert_utils SRCS convert_utils.cc DEPS data_type place) +endif() cc_library(op_utils SRCS op_utils.cc DEPS arg_map_context enforce convert_utils) diff --git a/paddle/pten/core/compat/arg_map_context.cc b/paddle/pten/core/compat/arg_map_context.cc index 73fa0b300cf96cb653129148ea86883a8536ebe0..b6b2bf6627009d93eb906e58b6a993433dec7da8 100644 --- a/paddle/pten/core/compat/arg_map_context.cc +++ b/paddle/pten/core/compat/arg_map_context.cc @@ -14,8 +14,8 @@ limitations under the License. */ #include "paddle/pten/core/compat/arg_map_context.h" -#include "paddle/fluid/string/string_helper.h" #include "paddle/pten/core/enforce.h" +#include "paddle/utils/string/string_helper.h" namespace pten { std::ostream& operator<<(std::ostream& os, KernelSignature signature) { diff --git a/paddle/pten/core/convert_utils.cc b/paddle/pten/core/compat/convert_utils.cc similarity index 93% rename from paddle/pten/core/convert_utils.cc rename to paddle/pten/core/compat/convert_utils.cc index 70184e31f7db6465ccb1af110f503c26470043f6..a8170b6a93637c758247479cd059ae093bccf973 100644 --- a/paddle/pten/core/convert_utils.cc +++ b/paddle/pten/core/compat/convert_utils.cc @@ -11,8 +11,11 @@ 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 "paddle/pten/core/convert_utils.h" -#include "paddle/pten/core/kernel_alias_name.h" + +#include "paddle/pten/core/compat/convert_utils.h" + +#include "paddle/pten/core/compat/kernel_alias_name.h" + // See Note [ Why still include the fluid headers? ] #include "paddle/fluid/platform/device/gpu/gpu_info.h" @@ -126,26 +129,6 @@ paddle::framework::proto::VarType::Type TransToProtoVarType( } } -paddle::framework::LoD TransToFluidLoD(const pten::LoD& lod) { - paddle::framework::LoD out; - out.reserve(lod.size()); - - for (auto& elem : lod) { - out.emplace_back(elem); - } - return out; -} - -pten::LoD TransToPtenLoD(const paddle::framework::LoD& lod) { - pten::LoD out; - out.reserve(lod.size()); - - for (auto& elem : lod) { - out.emplace_back(elem); - } - return out; -} - size_t DataTypeSize(DataType dtype) { switch (dtype) { case DataType::UNDEFINED: diff --git a/paddle/pten/core/convert_utils.h b/paddle/pten/core/compat/convert_utils.h similarity index 75% rename from paddle/pten/core/convert_utils.h rename to paddle/pten/core/compat/convert_utils.h index 9e33d37c4a8e8342d0639a5575aa560e32386399..c67d051cad85063ef01bf60186035a5ef3608993 100644 --- a/paddle/pten/core/convert_utils.h +++ b/paddle/pten/core/compat/convert_utils.h @@ -17,33 +17,26 @@ limitations under the License. */ #include "paddle/pten/common/backend.h" #include "paddle/pten/common/data_type.h" #include "paddle/pten/common/layout.h" +#include "paddle/pten/common/place.h" #include "paddle/pten/core/tensor_meta.h" // See Note [ Why still include the fluid headers? ] #include "paddle/fluid/framework/data_type.h" -#include "paddle/fluid/framework/lod_tensor.h" -#include "paddle/fluid/platform/place.h" // TODO(chenweihang): this file may need to be removed namespace pten { -using DataType = paddle::experimental::DataType; -using DataLayout = paddle::experimental::DataLayout; - const std::string& TransToPtenKernelName(const std::string& fluid_op_name); -Backend TransToPtenBackend(const paddle::platform::Place& place); +Backend TransToPtenBackend(const pten::Place& place); DataType TransToPtenDataType( const paddle::framework::proto::VarType::Type& dtype); -paddle::platform::Place TransToFluidPlace(const Backend& backend); +pten::Place TransToFluidPlace(const Backend& backend); paddle::framework::proto::VarType::Type TransToProtoVarType( const DataType& dtype); -paddle::framework::LoD TransToFluidLoD(const pten::LoD& lod); -pten::LoD TransToPtenLoD(const paddle::framework::LoD& lod); - size_t DataTypeSize(DataType dtype); DataType String2DataType(const std::string& str); std::string DataType2String(DataType dtype); diff --git a/paddle/pten/core/kernel_alias_name.h b/paddle/pten/core/compat/kernel_alias_name.h similarity index 100% rename from paddle/pten/core/kernel_alias_name.h rename to paddle/pten/core/compat/kernel_alias_name.h diff --git a/paddle/pten/core/compat/op_utils.h b/paddle/pten/core/compat/op_utils.h index 505ef13891aeea1454c8807cfee59223ce49cbab..d35eeffd7ef830dc2f786c4f37581899332a32e5 100644 --- a/paddle/pten/core/compat/op_utils.h +++ b/paddle/pten/core/compat/op_utils.h @@ -17,13 +17,12 @@ limitations under the License. */ #include #include "paddle/pten/core/compat/arg_map_context.h" +#include "paddle/pten/core/enforce.h" #include "paddle/pten/core/infermeta_utils.h" -#include "paddle/pten/core/kernel_def.h" #include "paddle/pten/core/macros.h" +#include "paddle/pten/core/type_defs.h" #include "paddle/utils/flat_hash_map.h" -#include "paddle/fluid/platform/enforce.h" - namespace pten { class DefaultKernelSignatureMap { @@ -37,7 +36,7 @@ class DefaultKernelSignatureMap { PADDLE_ENFORCE_NE( it, map_.end(), - paddle::platform::errors::NotFound( + pten::errors::NotFound( "Operator `%s`'s kernel signature is not registered.", op_type)); return it->second; } @@ -46,7 +45,7 @@ class DefaultKernelSignatureMap { PADDLE_ENFORCE_NE( Has(op_type), true, - paddle::platform::errors::AlreadyExists( + pten::errors::AlreadyExists( "Operator (%s)'s Kernel Siginature has been registered.", op_type)); map_.insert({std::move(op_type), std::move(signature)}); } @@ -71,7 +70,7 @@ class OpUtilsMap { PADDLE_ENFORCE_EQ( name_map_.count(op_type), 0UL, - paddle::platform::errors::AlreadyExists( + pten::errors::AlreadyExists( "Operator (%s)'s api name has been registered.", op_type)); name_map_.insert({std::move(op_type), std::move(api_name)}); } @@ -80,7 +79,7 @@ class OpUtilsMap { PADDLE_ENFORCE_EQ( arg_mapping_fn_map_.count(op_type), 0UL, - paddle::platform::errors::AlreadyExists( + pten::errors::AlreadyExists( "Operator (%s)'s argu,emt mapping function has been registered.", op_type)); arg_mapping_fn_map_.insert({std::move(op_type), std::move(fn)}); diff --git a/paddle/pten/core/compat/type_defs.h b/paddle/pten/core/compat/type_defs.h new file mode 100644 index 0000000000000000000000000000000000000000..eb5459b1b6ea723d7118a2a05addc1988987efcc --- /dev/null +++ b/paddle/pten/core/compat/type_defs.h @@ -0,0 +1,96 @@ +/* Copyright (c) 2016 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 +#include + +#include + +namespace egr { +class EagerTensor; +} +namespace paddle { +namespace framework { +// The order should be as same as framework.proto +// NOTE(xiongkun): we extract from framework/typedef.h to ensure we can transfer +// enforce.h +class BlockDesc; +using Attribute = boost::variant, + std::vector, + std::vector, + bool, + std::vector, + BlockDesc*, + int64_t, + std::vector, + std::vector, + std::vector>; +using AttributeMap = std::unordered_map; +} // namespace framework + +namespace imperative { + +class VariableWrapper; +class SavedVariableWrapperList; +class VarBase; +class OpBase; +class GradOpNode; +class Tracer; + +using WeakNameVarBaseMap = + std::map>>; + +namespace details { +template +struct NameVarMapTrait {}; + +template <> +struct NameVarMapTrait { + using Type = std::map>>; +}; + +template <> +struct NameVarMapTrait { + using Type = std::map; +}; + +template <> +struct NameVarMapTrait { + using Type = + std::map>>; +}; + +} // namespace details + +template +using NameVarMap = typename details::NameVarMapTrait::Type; + +using NameVarBaseMap = NameVarMap; +using NameVariableWrapperMap = NameVarMap; +using NameTensorMap = NameVarMap; + +using VariableWrapperList = std::vector>; + +} // namespace imperative +} // namespace paddle diff --git a/paddle/pten/core/ddim.cc b/paddle/pten/core/ddim.cc index 663f92a5bf8d0a833be8f35af77a6326a5f14fae..1846b7cf7fc65db52ee88f125c0919b985f54888 100644 --- a/paddle/pten/core/ddim.cc +++ b/paddle/pten/core/ddim.cc @@ -13,10 +13,10 @@ // limitations under the License. #include "paddle/pten/core/ddim.h" + #include namespace pten { -namespace platform = paddle::platform; namespace framework { DDim make_ddim(std::initializer_list dims) { @@ -84,7 +84,7 @@ DDim slice_ddim(const DDim& dim, int begin, int end) { PADDLE_ENFORCE_EQ( (begin >= 0 && end <= dim.size()), true, - platform::errors::InvalidArgument( + pten::errors::InvalidArgument( "[begin(%d), end(%d)) must be inside [0, %d) in ddim slice.", begin, end, @@ -111,30 +111,30 @@ std::ostream& operator<<(std::ostream& os, const DDim& ddim) { } DDim flatten_to_3d(const DDim& src, int num_row_dims, int num_col_dims) { - PADDLE_ENFORCE_GE(src.size(), - 3, - platform::errors::InvalidArgument( - "The rank of src dim should be at least 3 " - "in flatten_to_3d, but received %d.", - src.size())); - PADDLE_ENFORCE_EQ((num_row_dims >= 1 && num_row_dims < src.size()), - true, - platform::errors::InvalidArgument( - "The num_row_dims should be inside [1, %d] " - "in flatten_to_3d, but received %d.", - src.size() - 1, - num_row_dims)); - PADDLE_ENFORCE_EQ((num_col_dims >= 2 && num_col_dims <= src.size()), - true, - platform::errors::InvalidArgument( - "The num_col_dims should be inside [2, %d] " - "in flatten_to_3d, but received %d.", - src.size(), - num_col_dims)); + PADDLE_ENFORCE_GE( + src.size(), + 3, + pten::errors::InvalidArgument("The rank of src dim should be at least 3 " + "in flatten_to_3d, but received %d.", + src.size())); + PADDLE_ENFORCE_EQ( + (num_row_dims >= 1 && num_row_dims < src.size()), + true, + pten::errors::InvalidArgument("The num_row_dims should be inside [1, %d] " + "in flatten_to_3d, but received %d.", + src.size() - 1, + num_row_dims)); + PADDLE_ENFORCE_EQ( + (num_col_dims >= 2 && num_col_dims <= src.size()), + true, + pten::errors::InvalidArgument("The num_col_dims should be inside [2, %d] " + "in flatten_to_3d, but received %d.", + src.size(), + num_col_dims)); PADDLE_ENFORCE_GE( num_col_dims, num_row_dims, - platform::errors::InvalidArgument( + pten::errors::InvalidArgument( "The num_row_dims should be less than num_col_dims in flatten_to_3d," "but received num_row_dims = %d, num_col_dims = %d.", num_row_dims, @@ -181,7 +181,7 @@ DDim DDim::reshape(const std::vector& shape) const { if (shape[i] == copy_dim_val) { PADDLE_ENFORCE_LT(static_cast(i), in_dims.size(), - platform::errors::InvalidArgument( + pten::errors::InvalidArgument( "Index %d of shape under which the value of 0 " "is stored, must be lower than the number of " "old dimensions. But received shape[%d] = 0, " @@ -205,22 +205,22 @@ DDim DDim::transpose(const std::vector& axis) const { auto axis_set = std::set(axis.begin(), axis.end()); PADDLE_ENFORCE_EQ(axis_set.size(), axis_size, - platform::errors::InvalidArgument( + pten::errors::InvalidArgument( "In an axis array, elements must be unique.")); PADDLE_ENFORCE_EQ( in_rank, axis_size, - platform::errors::InvalidArgument("The input dimension's size " - "should be equal to the axis's size. " - "But received dimension is %d, " - "axis's size is %d", - in_rank, - axis_size)); + pten::errors::InvalidArgument("The input dimension's size " + "should be equal to the axis's size. " + "But received dimension is %d, " + "axis's size is %d", + in_rank, + axis_size)); PADDLE_ENFORCE_LT(*std::max_element(axis.begin(), axis.end()), axis_size, - platform::errors::InvalidArgument( + pten::errors::InvalidArgument( "Axis values must be ranging from 0 to (dims - 1).")); DDim out_dims(in_dims); @@ -231,4 +231,4 @@ DDim DDim::transpose(const std::vector& axis) const { } } // namespace framework -} // namespace pten \ No newline at end of file +} // namespace pten diff --git a/paddle/pten/core/ddim.h b/paddle/pten/core/ddim.h index 148c32481c0086059b5e66910a094dd427e9bbda..71ee732be276b5493a5ec1c2865c356d42c2e8f9 100644 --- a/paddle/pten/core/ddim.h +++ b/paddle/pten/core/ddim.h @@ -17,10 +17,10 @@ #include #include -#include "paddle/pten/core/dim.h" +#include "paddle/pten/core/enforce.h" +#include "paddle/pten/core/utils/dim.h" namespace pten { -namespace platform = paddle::platform; namespace framework { #define PADDLE_VISIT_DDIM_BASE(rank, callback) \ @@ -42,7 +42,7 @@ namespace framework { PADDLE_VISIT_DDIM_BASE(8, callback); \ PADDLE_VISIT_DDIM_BASE(9, callback); \ default: \ - PADDLE_THROW(platform::errors::Unimplemented( \ + PADDLE_THROW(pten::errors::Unimplemented( \ "Invalid dimension to be accessed. Now only supports access to " \ "dimension 0 to 9, but received dimension is %d.", \ rank)); \ @@ -98,14 +98,14 @@ class DDim { int64_t& at(int idx) { PADDLE_ENFORCE_GE(idx, 0, - platform::errors::InvalidArgument( + pten::errors::InvalidArgument( "Invalid DDim index to be accessed. The valid index " "is between 0 and %d, but received index is %d.", rank_, idx)); PADDLE_ENFORCE_LT(idx, rank_, - platform::errors::InvalidArgument( + pten::errors::InvalidArgument( "Invalid DDim index to be accessed. The valid index " "is between 0 and %d, but received index is %d.", rank_, @@ -116,14 +116,14 @@ class DDim { int64_t at(int idx) const { PADDLE_ENFORCE_GE(idx, 0, - platform::errors::InvalidArgument( + pten::errors::InvalidArgument( "Invalid DDim index to be accessed. The valid index " "is between 0 and %d, but received index is %d.", rank_, idx)); PADDLE_ENFORCE_LT(idx, rank_, - platform::errors::InvalidArgument( + pten::errors::InvalidArgument( "Invalid DDim index to be accessed. The valid index " "is between 0 and %d, but received index is %d.", rank_, diff --git a/paddle/pten/core/dense_tensor.cc b/paddle/pten/core/dense_tensor.cc index 7373ba79c0a5cfeb537ecda7ec318e533e23b555..36d56212e216af208362c6b78612cbaf5c058628 100644 --- a/paddle/pten/core/dense_tensor.cc +++ b/paddle/pten/core/dense_tensor.cc @@ -14,13 +14,13 @@ limitations under the License. */ #include "paddle/pten/core/dense_tensor.h" -// See Note [ Why still include the fluid headers? ] #include "paddle/pten/common/bfloat16.h" #include "paddle/pten/common/complex.h" #include "paddle/pten/common/float16.h" +#include "paddle/pten/core/compat/convert_utils.h" -#include "paddle/pten/api/lib/utils/storage.h" -#include "paddle/pten/core/convert_utils.h" +// See Note [ Why still include the fluid headers? ] +#include "paddle/fluid/memory/malloc.h" namespace pten { diff --git a/paddle/pten/core/dense_tensor.h b/paddle/pten/core/dense_tensor.h index fbecbcf0a1f2682abc87c7dbf605ead291fdf8fb..8d10753b58d23085eda7461a35db691909901176 100644 --- a/paddle/pten/core/dense_tensor.h +++ b/paddle/pten/core/dense_tensor.h @@ -14,15 +14,15 @@ limitations under the License. */ #pragma once -#include "paddle/fluid/framework/data_layout.h" -#include "paddle/fluid/framework/data_type.h" -#include "paddle/fluid/platform/stream/stream.h" - #include "paddle/pten/core/allocator.h" #include "paddle/pten/core/storage.h" #include "paddle/pten/core/tensor_base.h" #include "paddle/pten/core/tensor_meta.h" +// See Note [ Why still include the fluid headers? ] +#include "paddle/fluid/framework/data_type.h" +#include "paddle/fluid/platform/stream/stream.h" + /* @jim19930609: Move to MKLDNN_Tensor in the future */ #ifdef PADDLE_WITH_MKLDNN @@ -31,7 +31,7 @@ limitations under the License. */ namespace pten { -class CompatibleDenseTensorUtils; +class DenseTensorUtils; /// \brief The Dense tensor store values in a contiguous sequential block /// of memory where all values are represented. Tensors or multi-dimensional @@ -120,8 +120,8 @@ class DenseTensor : public TensorBase, /// \return Whether the metadata is valid. bool valid() const noexcept override { return meta_.valid(); } - /// \brief Test whether the storage is allocated. - /// return Whether the storage is allocated. + /// \brief Test whether the allocation is allocated. + /// return Whether the allocation is allocated. bool initialized() const override { return holder_ && holder_->ptr(); } /// \brief Allocate memory with requested size from allocator. @@ -130,12 +130,12 @@ class DenseTensor : public TensorBase, DataType dtype, size_t requested_size = 0) override; - /// \brief Check if storage is shared with other objects. - /// \return Whether the storage is shared with other objects. + /// \brief Check if allocation is shared with other objects. + /// \return Whether the allocation is shared with other objects. bool IsSharedWith(const DenseTensor& b) const; /// \brief Change the shape information in the metadata. If the new size is - /// larger than the original value, the storage area will be reallocated. + /// larger than the original value, the allocation area will be reallocated. /// \param dims The new dims of the dense tensor. /// \param lod The new lod of the dense tensor. // void Resize(const DDim& dims); @@ -147,9 +147,10 @@ class DenseTensor : public TensorBase, /// \param lod The new lod of the dense tensor. void ResetLoD(const LoD& lod); - /// \brief Returns the actual storage size occupied by tensor, may be larger + /// \brief Returns the actual allocation size occupied by tensor, may be + /// larger /// than its shape dims. - /// \return The actual storage size occupied by tensor. + /// \return The actual allocation size occupied by tensor. size_t capacity() const { return holder_->size(); } /// \brief Get the const data pointer value of type T. @@ -162,7 +163,7 @@ class DenseTensor : public TensorBase, const void* data() const; private: - friend class CompatibleDenseTensorUtils; + friend class DenseTensorUtils; protected: DenseTensorMeta meta_; diff --git a/paddle/pten/core/dense_tensor_impl.cc b/paddle/pten/core/dense_tensor_impl.cc index f825d3619b92bcfd8d66ea47d9f176630ccbb525..85714373472edc75c25e360a0aa4ef80da73fad7 100644 --- a/paddle/pten/core/dense_tensor_impl.cc +++ b/paddle/pten/core/dense_tensor_impl.cc @@ -14,13 +14,12 @@ limitations under the License. */ #include "paddle/pten/core/dense_tensor.h" -// See Note [ Why still include the fluid headers? ] #include "paddle/pten/common/bfloat16.h" #include "paddle/pten/common/complex.h" #include "paddle/pten/common/float16.h" #include "paddle/pten/api/lib/utils/storage.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" namespace pten { /* --------------------------- */ diff --git a/paddle/pten/core/enforce.h b/paddle/pten/core/enforce.h index 97433f1a6d5fc3d209528d8c419e9737e85cd4ad..2c52d044d26514197e8a6b29e8010c95a1bb22c3 100644 --- a/paddle/pten/core/enforce.h +++ b/paddle/pten/core/enforce.h @@ -49,7 +49,7 @@ limitations under the License. */ #include "paddle/utils/string/to_string.h" // Note: these headers for simplify demangle type string -#include "paddle/pten/core/type_defs.h" +#include "paddle/pten/core/compat/type_defs.h" namespace pten { class ErrorSummary; diff --git a/paddle/pten/core/infermeta_utils.h b/paddle/pten/core/infermeta_utils.h index 47f55f85ac2a3d2bf55d92ad57a71d98a837b433..0f45185c8340d2001e624db4bdbb5758e02ff6a1 100644 --- a/paddle/pten/core/infermeta_utils.h +++ b/paddle/pten/core/infermeta_utils.h @@ -18,9 +18,9 @@ limitations under the License. */ #include #include "paddle/pten/core/enforce.h" -#include "paddle/pten/core/kernel_def.h" #include "paddle/pten/core/macros.h" #include "paddle/pten/core/meta_tensor.h" +#include "paddle/pten/core/type_defs.h" #include "paddle/utils/flat_hash_map.h" #include "paddle/utils/small_vector.h" diff --git a/paddle/pten/core/kernel_context.h b/paddle/pten/core/kernel_context.h index def1019e204cd85da56f1a45e162f3e9c4251af3..876c98e3bcf6b4dea82dbb9d86b1aa28348a5d1c 100644 --- a/paddle/pten/core/kernel_context.h +++ b/paddle/pten/core/kernel_context.h @@ -17,20 +17,16 @@ #include #include -#include "paddle/pten/core/compat_utils.h" +#include "paddle/pten/core/device_context.h" +#include "paddle/pten/core/enforce.h" #include "paddle/pten/core/tensor_base.h" +#include "paddle/pten/core/tensor_utils.h" #include "paddle/utils/any.h" #include "paddle/utils/small_vector.h" -// See Note [ Why still include the fluid headers? ] -#include "paddle/fluid/platform/device_context.h" -#include "paddle/pten/core/enforce.h" - namespace pten { -using DeviceContext = paddle::platform::DeviceContext; -using DataType = paddle::experimental::DataType; -using DataLayout = paddle::experimental::DataLayout; +using DeviceContext = pten::DeviceContext; /** * Note: KernelContext doesn't manage the life if DeviceContext and Tensor diff --git a/paddle/pten/core/kernel_def.h b/paddle/pten/core/kernel_def.h deleted file mode 100644 index 9b91720d86f1e92c12df0a7836bd51c67f7383b6..0000000000000000000000000000000000000000 --- a/paddle/pten/core/kernel_def.h +++ /dev/null @@ -1,38 +0,0 @@ -// Copyright (c) 2021 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 - -namespace pten { - -class Kernel; -class KernelKey; -class KernelArgsDef; -class KernelContext; -class KernelSignature; -class ArgumentMappingContext; -class InferMetaContext; - -using KernelFn = std::function; -using KernelArgsDefFn = void (*)(Kernel* kernel); -using KernelArgsParseFn = void (*)(const KernelKey& default_key, - KernelArgsDef* args_def); - -using ArgumentMappingFn = - std::function; -using InferMetaFn = void (*)(InferMetaContext* ctx); - -} // namespace pten diff --git a/paddle/pten/core/kernel_factory.h b/paddle/pten/core/kernel_factory.h index b21c71f3fa12c446591160897853ad948503c15a..249b83257c7b619a11b3d6d64e300cf699f886b8 100644 --- a/paddle/pten/core/kernel_factory.h +++ b/paddle/pten/core/kernel_factory.h @@ -23,11 +23,9 @@ #include "paddle/pten/common/backend.h" #include "paddle/pten/common/data_type.h" #include "paddle/pten/common/layout.h" -#include "paddle/pten/core/convert_utils.h" -#include "paddle/pten/core/kernel_def.h" - -// See Note [ Why still include the fluid headers? ] +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/enforce.h" +#include "paddle/pten/core/type_defs.h" #include "paddle/utils/flat_hash_map.h" #include "paddle/utils/small_vector.h" diff --git a/paddle/pten/core/kernel_registry.h b/paddle/pten/core/kernel_registry.h index 210309cad606cbb0ab425a13f65a0f44ac39321a..7d6c079f46481ea35926482e01881f6080ce7002 100644 --- a/paddle/pten/core/kernel_registry.h +++ b/paddle/pten/core/kernel_registry.h @@ -21,10 +21,10 @@ #include #include -#include "paddle/pten/core/kernel_def.h" #include "paddle/pten/core/kernel_factory.h" #include "paddle/pten/core/kernel_utils.h" #include "paddle/pten/core/macros.h" +#include "paddle/pten/core/type_defs.h" #include "paddle/pten/core/enforce.h" diff --git a/paddle/pten/core/kernel_utils.h b/paddle/pten/core/kernel_utils.h index 5d6f5376c77f29d2da96cd6bdc16da6bce73d92c..2ecb3eca6cf5bc776f2827412d91774c7ac9b626 100644 --- a/paddle/pten/core/kernel_utils.h +++ b/paddle/pten/core/kernel_utils.h @@ -18,14 +18,12 @@ #include "paddle/pten/common/scalar.h" #include "paddle/pten/common/scalar_array.h" #include "paddle/pten/core/dense_tensor.h" +#include "paddle/pten/core/enforce.h" #include "paddle/pten/core/kernel_context.h" -#include "paddle/pten/core/kernel_def.h" #include "paddle/pten/core/selected_rows.h" #include "paddle/pten/core/sparse_coo_tensor.h" #include "paddle/pten/core/sparse_csr_tensor.h" - -// See Note [ Why still include the fluid headers? ] -#include "paddle/pten/core/enforce.h" +#include "paddle/pten/core/type_defs.h" namespace pten { diff --git a/paddle/pten/core/lod_utils.cc b/paddle/pten/core/lod_utils.cc index ad5ea6d39d39c9c9ef7dc2b514a3ffdbafc10964..83b90c4305fec8260dcda9672ddb18ef2417ac13 100644 --- a/paddle/pten/core/lod_utils.cc +++ b/paddle/pten/core/lod_utils.cc @@ -14,14 +14,14 @@ #include "paddle/pten/core/lod_utils.h" -#include "paddle/fluid/platform/enforce.h" +#include "paddle/pten/core/enforce.h" namespace pten { void AppendLoD(LoD *lod, const LoD &lod_length) { PADDLE_ENFORCE( lod->empty() || lod->size() == lod_length.size(), - paddle::platform::errors::InvalidArgument( + pten::errors::InvalidArgument( "The input LoD length should be equal to the appended LoD size, but " "received input LoD length is %d, actual LoD size is %d.", lod_length.size(), diff --git a/paddle/pten/core/meta_tensor.cc b/paddle/pten/core/meta_tensor.cc index a8229b568a617160ba4d1870f9c6954fb0697de6..fd558d20a064cef595ef673aca10f95ca20d6534 100644 --- a/paddle/pten/core/meta_tensor.cc +++ b/paddle/pten/core/meta_tensor.cc @@ -14,10 +14,9 @@ limitations under the License. */ #include "paddle/pten/core/meta_tensor.h" -#include "paddle/pten/core/compat_utils.h" #include "paddle/pten/core/dense_tensor.h" - -#include "paddle/fluid/platform/enforce.h" +#include "paddle/pten/core/enforce.h" +#include "paddle/pten/core/tensor_utils.h" namespace pten { @@ -31,9 +30,8 @@ DataLayout MetaTensor::layout() const { return tensor_->layout(); } void MetaTensor::set_dims(const DDim& dims) { if (pten::DenseTensor::classof(tensor_)) { - CompatibleDenseTensorUtils::GetMutableMeta( - static_cast(tensor_)) - ->dims = dims; + DenseTensorUtils::GetMutableMeta(static_cast(tensor_))->dims = + dims; } else { PADDLE_THROW(paddle::platform::errors::Unimplemented( "Unsupported setting dims for `%s`.", tensor_->type_info().name())); @@ -42,8 +40,7 @@ void MetaTensor::set_dims(const DDim& dims) { void MetaTensor::set_dtype(DataType dtype) { if (pten::DenseTensor::classof(tensor_)) { - CompatibleDenseTensorUtils::GetMutableMeta( - static_cast(tensor_)) + DenseTensorUtils::GetMutableMeta(static_cast(tensor_)) ->dtype = dtype; } else { PADDLE_THROW(paddle::platform::errors::Unimplemented( @@ -53,8 +50,7 @@ void MetaTensor::set_dtype(DataType dtype) { void MetaTensor::set_layout(DataLayout layout) { if (pten::DenseTensor::classof(tensor_)) { - CompatibleDenseTensorUtils::GetMutableMeta( - static_cast(tensor_)) + DenseTensorUtils::GetMutableMeta(static_cast(tensor_)) ->layout = layout; } else { PADDLE_THROW(paddle::platform::errors::Unimplemented( @@ -64,9 +60,8 @@ void MetaTensor::set_layout(DataLayout layout) { void MetaTensor::share_lod(const MetaTensor& meta_tensor) { if (pten::DenseTensor::classof(tensor_)) { - CompatibleDenseTensorUtils::GetMutableMeta( - static_cast(tensor_)) - ->lod = meta_tensor.lod(); + DenseTensorUtils::GetMutableMeta(static_cast(tensor_))->lod = + meta_tensor.lod(); } else { PADDLE_THROW(paddle::platform::errors::Unimplemented( "Unsupported share lod inplace for `%s`.", diff --git a/paddle/pten/core/meta_tensor.h b/paddle/pten/core/meta_tensor.h index 1435e1c3912d0cc661beb839c354171272fbfac5..ae2ec606267dc45e18e6b6a102b560d2b91adf2d 100644 --- a/paddle/pten/core/meta_tensor.h +++ b/paddle/pten/core/meta_tensor.h @@ -16,13 +16,11 @@ limitations under the License. */ #include "paddle/pten/common/data_type.h" #include "paddle/pten/common/layout.h" +#include "paddle/pten/core/ddim.h" #include "paddle/pten/core/macros.h" #include "paddle/pten/core/tensor_base.h" #include "paddle/pten/core/tensor_meta.h" -// See Note [ Why still include the fluid headers? ] -#include "paddle/fluid/framework/ddim.h" - namespace pten { class MetaTensor { diff --git a/paddle/pten/core/storage.h b/paddle/pten/core/storage.h index fc8b5dfaab70fb5ea9eb9b3334fbef1d065f88b0..6e7c47c2055950668f3066b39d5db743e46d9c29 100644 --- a/paddle/pten/core/storage.h +++ b/paddle/pten/core/storage.h @@ -17,14 +17,12 @@ limitations under the License. */ #include #include "boost/intrusive_ptr.hpp" +#include "paddle/pten/common/place.h" +#include "paddle/pten/core/allocator.h" #include "paddle/pten/core/utils/intrusive_ptr.h" #include "paddle/pten/core/utils/intrusive_ref_counter.h" #include "paddle/pten/core/utils/type_info.h" -#include "paddle/fluid/memory/memory.h" -#include "paddle/fluid/platform/place.h" -#include "paddle/pten/core/allocator.h" - namespace pten { /// \brief The interface of contiguous storage used for the dense tensor. @@ -32,7 +30,6 @@ namespace pten { /// all default copy operations to ensure the integrity of the package. class Storage : public intrusive_ref_counter { public: - using Place = paddle::platform::Place; Storage() = default; Storage(const Storage&) = delete; @@ -43,11 +40,11 @@ class Storage : public intrusive_ref_counter { /* --------- shared_ptr -------- */ // Initialize a Storage with unique Allocation - explicit Storage(std::shared_ptr&& data) + explicit Storage(std::shared_ptr&& data) : data_(std::move(data)) {} // Initialize a Storage shareing Allocation with another storage - explicit Storage(const std::shared_ptr& data) + explicit Storage(const std::shared_ptr& data) : data_(data) {} void* data() const { @@ -56,17 +53,15 @@ class Storage : public intrusive_ref_counter { : nullptr; } - const std::shared_ptr& data_shared() const { - return data_; - } + const std::shared_ptr& data_shared() const { return data_; } virtual void set_data_shared( - const std::shared_ptr& holder) = 0; + const std::shared_ptr& holder) = 0; - virtual std::shared_ptr&& move_data_shared() = 0; + virtual std::shared_ptr&& move_data_shared() = 0; virtual void ReallocShared(size_t n) { - PADDLE_THROW(paddle::platform::errors::Unimplemented( + PADDLE_THROW(pten::errors::Unimplemented( "ReallocShared has not been overrided by the current Storage")); } /* --------- shared_ptr -------- */ @@ -81,13 +76,11 @@ class Storage : public intrusive_ref_counter { virtual void Realloc(size_t n) = 0; protected: - std::shared_ptr data_; + std::shared_ptr data_; }; class TensorStorage : public Storage { public: - using Place = paddle::platform::Place; - explicit TensorStorage(Allocator* a) : alloc_(a) {} TensorStorage(Allocator* a, size_t size) @@ -110,7 +103,7 @@ class TensorStorage : public Storage { const Place& place() const override { if (!data_) { - PADDLE_THROW(paddle::platform::errors::Unimplemented( + PADDLE_THROW(pten::errors::Unimplemented( "Unable to visit place: either data_ or alloc_ has to be initialized " "first.")); } @@ -120,13 +113,13 @@ class TensorStorage : public Storage { bool OwnsMemory() const noexcept override { return true; } void set_data_shared( - const std::shared_ptr& holder) override { + const std::shared_ptr& holder) override { CHECK(holder); data_ = holder; size_ = holder->size(); } - std::shared_ptr&& move_data_shared() override { + std::shared_ptr&& move_data_shared() override { size_ = 0; return std::move(data_); } diff --git a/paddle/pten/core/tensor_base.h b/paddle/pten/core/tensor_base.h index 7a5e42da4908b2509ab3ce205650d7ec89d5d1f6..5c0f74df492607e5c82e28fc61cacbb0e557952d 100644 --- a/paddle/pten/core/tensor_base.h +++ b/paddle/pten/core/tensor_base.h @@ -14,23 +14,19 @@ limitations under the License. */ #pragma once -#include "paddle/fluid/platform/place.h" #include "paddle/pten/common/backend.h" #include "paddle/pten/common/data_type.h" #include "paddle/pten/common/layout.h" +#include "paddle/pten/common/place.h" #include "paddle/pten/core/allocator.h" #include "paddle/pten/core/ddim.h" -#include "paddle/pten/core/storage.h" #include "paddle/pten/core/utils/type_registry.h" namespace pten { class TensorBase { public: - using DataType = paddle::experimental::DataType; - using DataLayout = paddle::experimental::DataLayout; using DDim = pten::framework::DDim; - using Place = paddle::platform::Place; virtual ~TensorBase() = default; diff --git a/paddle/pten/core/tensor_meta.h b/paddle/pten/core/tensor_meta.h index ac3f17267c4f9425873592570ecc4aa901839158..60b2be3c17584d3ede8b749b58752431ffb3ca1c 100644 --- a/paddle/pten/core/tensor_meta.h +++ b/paddle/pten/core/tensor_meta.h @@ -19,8 +19,6 @@ limitations under the License. */ #include "paddle/pten/common/backend.h" #include "paddle/pten/common/data_type.h" #include "paddle/pten/common/layout.h" - -// See Note [ Why still include the fluid headers? ] #include "paddle/pten/core/ddim.h" // Note: mixed_vector include many header now, LoD will be diff --git a/paddle/pten/core/compat_utils.h b/paddle/pten/core/tensor_utils.h similarity index 81% rename from paddle/pten/core/compat_utils.h rename to paddle/pten/core/tensor_utils.h index 46e53e3997cc1930e2c41c8e6602f7171413718f..00dcdc65b84f13105e2cb2be52490755f51bb270 100644 --- a/paddle/pten/core/compat_utils.h +++ b/paddle/pten/core/tensor_utils.h @@ -14,33 +14,17 @@ limitations under the License. */ #pragma once -#include "paddle/pten/api/lib/utils/storage.h" #include "paddle/pten/core/dense_tensor.h" -#include "paddle/pten/core/storage.h" #include "paddle/pten/core/tensor_meta.h" namespace pten { -/** - * In order to meet some adaptation requirements of the compatible state, - * these class is added to provide some tool functions. - * - * These utility functions may be deleted in the future, It is not recommended - * to be widely used in the framework - */ - -class CompatibleDenseTensorUtils { +class DenseTensorUtils { public: static DenseTensorMeta* GetMutableMeta(DenseTensor* tensor) { return &(tensor->meta_); } - // only can deal with SharedStorage now - static void ClearStorage(DenseTensor* tensor) { - // use static_cast to improve performance, replace by dynamic_cast later - tensor->MoveMemoryHolder(); - } - static DenseTensor Slice(const DenseTensor& tensor, int64_t begin_idx, int64_t end_idx) { diff --git a/paddle/pten/core/type_defs.h b/paddle/pten/core/type_defs.h index eb5459b1b6ea723d7118a2a05addc1988987efcc..9b91720d86f1e92c12df0a7836bd51c67f7383b6 100644 --- a/paddle/pten/core/type_defs.h +++ b/paddle/pten/core/type_defs.h @@ -1,96 +1,38 @@ -/* Copyright (c) 2016 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. */ +// Copyright (c) 2021 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 -#include - -#include - -namespace egr { -class EagerTensor; -} -namespace paddle { -namespace framework { -// The order should be as same as framework.proto -// NOTE(xiongkun): we extract from framework/typedef.h to ensure we can transfer -// enforce.h -class BlockDesc; -using Attribute = boost::variant, - std::vector, - std::vector, - bool, - std::vector, - BlockDesc*, - int64_t, - std::vector, - std::vector, - std::vector>; -using AttributeMap = std::unordered_map; -} // namespace framework - -namespace imperative { - -class VariableWrapper; -class SavedVariableWrapperList; -class VarBase; -class OpBase; -class GradOpNode; -class Tracer; - -using WeakNameVarBaseMap = - std::map>>; - -namespace details { -template -struct NameVarMapTrait {}; - -template <> -struct NameVarMapTrait { - using Type = std::map>>; -}; - -template <> -struct NameVarMapTrait { - using Type = std::map; -}; - -template <> -struct NameVarMapTrait { - using Type = - std::map>>; -}; +#include -} // namespace details +namespace pten { -template -using NameVarMap = typename details::NameVarMapTrait::Type; +class Kernel; +class KernelKey; +class KernelArgsDef; +class KernelContext; +class KernelSignature; +class ArgumentMappingContext; +class InferMetaContext; -using NameVarBaseMap = NameVarMap; -using NameVariableWrapperMap = NameVarMap; -using NameTensorMap = NameVarMap; +using KernelFn = std::function; +using KernelArgsDefFn = void (*)(Kernel* kernel); +using KernelArgsParseFn = void (*)(const KernelKey& default_key, + KernelArgsDef* args_def); -using VariableWrapperList = std::vector>; +using ArgumentMappingFn = + std::function; +using InferMetaFn = void (*)(InferMetaContext* ctx); -} // namespace imperative -} // namespace paddle +} // namespace pten diff --git a/paddle/pten/core/array.h b/paddle/pten/core/utils/array.h similarity index 88% rename from paddle/pten/core/array.h rename to paddle/pten/core/utils/array.h index 86d222d2d57b3e639b9eff07b0ba905d30a7f2f9..cd43dc7b420f5e015cac2a79ca0e64afe86b29c3 100644 --- a/paddle/pten/core/array.h +++ b/paddle/pten/core/utils/array.h @@ -15,12 +15,11 @@ #pragma once #include -#include "paddle/pten/core/unroll_array_ops.h" -// TODO(paddle-dev): Need to modify into pten/core/enforce.h -#include "paddle/fluid/platform/enforce.h" + +#include "paddle/pten/core/enforce.h" +#include "paddle/pten/core/utils/unroll_array_ops.h" namespace pten { -namespace platform = paddle::platform; namespace framework { template @@ -58,7 +57,7 @@ class Array { HOSTDEVICE inline T &at(size_t i) { #if !defined(__CUDA_ARCH__) && !defined(__HIPCC__) PADDLE_ENFORCE_LT( - i, N, platform::errors::OutOfRange("Array index out of bounds.")); + i, N, pten::errors::OutOfRange("Array index out of bounds.")); #endif return (*this)[i]; } @@ -66,7 +65,7 @@ class Array { HOSTDEVICE inline const T &at(size_t i) const { #if !defined(__CUDA_ARCH__) && !defined(__HIPCC__) PADDLE_ENFORCE_LT( - i, N, platform::errors::OutOfRange("Array index out of bounds.")); + i, N, pten::errors::OutOfRange("Array index out of bounds.")); #endif return (*this)[i]; } @@ -114,7 +113,7 @@ class Array { static T obj(); return obj; #else - PADDLE_THROW(platform::errors::Unavailable("Array has no element.")); + PADDLE_THROW(pten::errors::Unavailable("Array has no element.")); #endif } @@ -128,7 +127,7 @@ class Array { static const T obj(); return obj; #else - PADDLE_THROW(platform::errors::Unavailable("Array has no element.")); + PADDLE_THROW(pten::errors::Unavailable("Array has no element.")); #endif } diff --git a/paddle/pten/core/dim.h b/paddle/pten/core/utils/dim.h similarity index 98% rename from paddle/pten/core/dim.h rename to paddle/pten/core/utils/dim.h index 8dd984891a894817b0b59725d3dac754eb8d99d1..a24d6e40dfc953f59f52f1fb50d65f1e81fe20b1 100644 --- a/paddle/pten/core/dim.h +++ b/paddle/pten/core/utils/dim.h @@ -20,8 +20,8 @@ #include #include -#include "paddle/pten/core/array.h" #include "paddle/pten/core/hostdevice.h" +#include "paddle/pten/core/utils/array.h" namespace pten { namespace framework { diff --git a/paddle/pten/core/utils/rw_lock.h b/paddle/pten/core/utils/rw_lock.h index 7bd190c901bc640b657231d937f8b92126b21532..6a2429ef30d7ca1c7d5dcf745e214e129029230a 100644 --- a/paddle/pten/core/utils/rw_lock.h +++ b/paddle/pten/core/utils/rw_lock.h @@ -20,8 +20,7 @@ limitations under the License. */ #include // NOLINT #endif // !_WIN32 -// See Note [ Why still include the fluid headers? ] -#include "paddle/fluid/platform/enforce.h" +#include "paddle/pten/core/enforce.h" namespace pten { @@ -32,24 +31,23 @@ struct RWLock { ~RWLock() { pthread_rwlock_destroy(&lock_); } inline void RDLock() { - PADDLE_ENFORCE_EQ(pthread_rwlock_rdlock(&lock_), - 0, - paddle::platform::errors::External( - "The pthread failed to acquire read lock.")); + PADDLE_ENFORCE_EQ( + pthread_rwlock_rdlock(&lock_), + 0, + pten::errors::External("The pthread failed to acquire read lock.")); } inline void WRLock() { - PADDLE_ENFORCE_EQ(pthread_rwlock_wrlock(&lock_), - 0, - paddle::platform::errors::External( - "The pthread failed to acquire write lock.")); + PADDLE_ENFORCE_EQ( + pthread_rwlock_wrlock(&lock_), + 0, + pten::errors::External("The pthread failed to acquire write lock.")); } inline void UNLock() { - PADDLE_ENFORCE_EQ( - pthread_rwlock_unlock(&lock_), - 0, - paddle::platform::errors::External("The pthread failed to unlock.")); + PADDLE_ENFORCE_EQ(pthread_rwlock_unlock(&lock_), + 0, + pten::errors::External("The pthread failed to unlock.")); } private: diff --git a/paddle/pten/core/unroll_array_ops.h b/paddle/pten/core/utils/unroll_array_ops.h similarity index 100% rename from paddle/pten/core/unroll_array_ops.h rename to paddle/pten/core/utils/unroll_array_ops.h diff --git a/paddle/pten/infermeta/unary.cc b/paddle/pten/infermeta/unary.cc index 3f6b559f5604fa72758f609c14a2a2fda3e8ac88..e1a30d10e160be62e96d5ef70cb64528c8daf043 100644 --- a/paddle/pten/infermeta/unary.cc +++ b/paddle/pten/infermeta/unary.cc @@ -24,6 +24,8 @@ void UnchangedInferMetaNew(MetaConfig config, const MetaTensor& x, MetaTensor* out) { out->set_dims(x.dims()); + out->set_dtype(x.dtype()); + out->set_layout(x.layout()); out->share_lod(x); } diff --git a/paddle/pten/kernels/cpu/copy_kernel.cc b/paddle/pten/kernels/cpu/copy_kernel.cc index 0892e3974febd1bc4c8ac890cd123066b960e382..6a5d33b91aa768762a3b7fc5d34344323a4fde65 100644 --- a/paddle/pten/kernels/cpu/copy_kernel.cc +++ b/paddle/pten/kernels/cpu/copy_kernel.cc @@ -16,7 +16,7 @@ limitations under the License. */ #include "paddle/pten/backends/cpu/cpu_context.h" #include "paddle/pten/common/data_type.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/kernel_registry.h" // See Note [ Why still include the fluid headers? ] diff --git a/paddle/pten/kernels/gpu/copy_kernel.cu b/paddle/pten/kernels/gpu/copy_kernel.cu index d2578723158317f485f0e93a1a5b93477db5df04..6c0e7b1fe65d33c02bcd084408d060f1fba10366 100644 --- a/paddle/pten/kernels/gpu/copy_kernel.cu +++ b/paddle/pten/kernels/gpu/copy_kernel.cu @@ -16,7 +16,7 @@ limitations under the License. */ #include "paddle/pten/backends/gpu/gpu_context.h" #include "paddle/pten/common/data_type.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/kernel_registry.h" // See Note [ Why still include the fluid headers? ] diff --git a/paddle/pten/kernels/gpu/math_kernel.cu b/paddle/pten/kernels/gpu/math_kernel.cu index 37104c46a49427828f75e09c5b8aa544051df530..1a549087e4221b0f74362fe9fe653d5fbe91c738 100644 --- a/paddle/pten/kernels/gpu/math_kernel.cu +++ b/paddle/pten/kernels/gpu/math_kernel.cu @@ -29,7 +29,7 @@ namespace cub = hipcub; #include "paddle/pten/common/complex.h" #include "paddle/pten/common/float16.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/enforce.h" #include "paddle/pten/core/kernel_registry.h" diff --git a/paddle/pten/kernels/gpu/reduce.h b/paddle/pten/kernels/gpu/reduce.h index d864c76ea197408e4d035c816a32d5bb5ccb71c1..ca850d2c8c5eea969f0e86fd541bcaf39abc9ae6 100644 --- a/paddle/pten/kernels/gpu/reduce.h +++ b/paddle/pten/kernels/gpu/reduce.h @@ -38,14 +38,13 @@ namespace cub = hipcub; #include "paddle/fluid/platform/device/gpu/gpu_info.h" #include "paddle/fluid/platform/fast_divmod.h" #include "paddle/fluid/string/string_helper.h" -#include "paddle/pten/core/array.h" -#include "paddle/pten/core/enforce.h" -#include "paddle/pten/kernels/primitive/kernel_primitives.h" - #include "paddle/pten/api/ext/dispatch.h" #include "paddle/pten/backends/gpu/gpu_context.h" #include "paddle/pten/core/dense_tensor.h" +#include "paddle/pten/core/enforce.h" +#include "paddle/pten/core/utils/array.h" #include "paddle/pten/kernels/funcs/elementwise_base.h" +#include "paddle/pten/kernels/primitive/kernel_primitives.h" // Reduce split or not, Whether to use ReduceHigherDim #define REDUCE_SPLIT_BOUNDARY 512 diff --git a/paddle/pten/kernels/impl/digamma_grad_kernel_impl.h b/paddle/pten/kernels/impl/digamma_grad_kernel_impl.h index 44f94608b9e44ebcf469425c5c6d790146940682..f919fe234c3d18680be278afc1055e3f405be24b 100644 --- a/paddle/pten/kernels/impl/digamma_grad_kernel_impl.h +++ b/paddle/pten/kernels/impl/digamma_grad_kernel_impl.h @@ -47,7 +47,7 @@ void DigammaGradKernel(const Context& ctx, auto* x_data = x.data(); auto* dx_data = x_grad->data(); auto numel = out_grad.numel(); - platform::ForRange for_range(ctx, numel); + paddle::platform::ForRange for_range(ctx, numel); DigammaGradFunctor functor(dout_data, x_data, dx_data, numel); for_range(functor); } diff --git a/paddle/pten/kernels/impl/digamma_kernel_impl.h b/paddle/pten/kernels/impl/digamma_kernel_impl.h index a47750ff15a23048a4d843466331fde71cefed60..209b3e95376eb8a4242fa8034ae31ac92c487d28 100644 --- a/paddle/pten/kernels/impl/digamma_kernel_impl.h +++ b/paddle/pten/kernels/impl/digamma_kernel_impl.h @@ -41,7 +41,7 @@ void DigammaKernel(const Context& ctx, const DenseTensor& x, DenseTensor* out) { auto* x_data = x.data(); auto* out_data = out->data(); auto numel = x.numel(); - platform::ForRange for_range(ctx, numel); + paddle::platform::ForRange for_range(ctx, numel); DigammaFunctor functor(x_data, out_data, numel); for_range(functor); } diff --git a/paddle/pten/kernels/math_kernel.h b/paddle/pten/kernels/math_kernel.h index afef58669312ca3d051b161caa39c1ca5d26bf9b..6dcb9dd77adc2d978ba50a581b0a94f614ae1c28 100644 --- a/paddle/pten/kernels/math_kernel.h +++ b/paddle/pten/kernels/math_kernel.h @@ -14,7 +14,6 @@ limitations under the License. */ #pragma once -#include "paddle/pten/api/lib/utils/storage.h" #include "paddle/pten/core/dense_tensor.h" #include "paddle/pten/infermeta/binary.h" #include "paddle/pten/infermeta/unary.h" diff --git a/paddle/pten/kernels/xpu/cast_kernel.cc b/paddle/pten/kernels/xpu/cast_kernel.cc index fc1ba021e22bc0847d25e8c50e5f87dcac2ae41e..027aa4f5b458ab509141f110d3b1a66cd4e22059 100644 --- a/paddle/pten/kernels/xpu/cast_kernel.cc +++ b/paddle/pten/kernels/xpu/cast_kernel.cc @@ -14,11 +14,13 @@ #include "paddle/pten/kernels/cast_kernel.h" -#include "paddle/fluid/platform/device/xpu/xpu_header.h" #include "paddle/pten/backends/xpu/xpu_context.h" +#include "paddle/pten/common/float16.h" +#include "paddle/pten/core/enforce.h" #include "paddle/pten/core/kernel_registry.h" -#include "paddle/pten/core/enforce.h" +// See Note [ Why still include the fluid headers? ] +#include "paddle/fluid/platform/device/xpu/xpu_header.h" namespace pten { @@ -28,7 +30,7 @@ void CastKernel(const Context& dev_ctx, DataType out_dtype, DenseTensor* out) { using XPUInTDType = typename XPUTypeTrait::Type; - using float16 = typename XPUTypeTrait::Type; + using float16 = typename XPUTypeTrait::Type; auto* in_data = x.data(); auto numel = x.numel(); @@ -47,7 +49,7 @@ void CastKernel(const Context& dev_ctx, dev_ctx.x_context(), reinterpret_cast(in_data), reinterpret_cast( - out->mutable_data(dev_ctx.GetPlace())), + out->mutable_data(dev_ctx.GetPlace())), numel); break; case pten::DataType::INT64: @@ -72,7 +74,7 @@ void CastKernel(const Context& dev_ctx, numel); break; default: - PADDLE_THROW(platform::errors::Unavailable( + PADDLE_THROW(pten::errors::Unavailable( "Not supported cast %d -> %d", x.dtype(), out_dtype)); } @@ -90,7 +92,7 @@ PT_REGISTER_KERNEL(cast, pten::CastKernel, int32_t, float, - pten::platform::float16, + pten::dtype::float16, int64_t, bool) { kernel->OutputAt(0).SetDataType(paddle::experimental::DataType::UNDEFINED); diff --git a/paddle/pten/kernels/xpu/copy_kernel.cc b/paddle/pten/kernels/xpu/copy_kernel.cc index 56ad19f0cc3dde250d10614165b52c447fa2b744..f27705ca112b3b1ed84f0ff4d5d41d1d73c77701 100644 --- a/paddle/pten/kernels/xpu/copy_kernel.cc +++ b/paddle/pten/kernels/xpu/copy_kernel.cc @@ -16,7 +16,7 @@ limitations under the License. */ #include "paddle/pten/backends/xpu/xpu_context.h" #include "paddle/pten/common/data_type.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/kernel_registry.h" // See Note [ Why still include the fluid headers? ] diff --git a/paddle/pten/kernels/xpu/full_kernel.cc b/paddle/pten/kernels/xpu/full_kernel.cc index 71d2b8e3adde5a0beb394ebea617041108688b66..cf6befac02367bd0f3419202f01c34571663d73d 100644 --- a/paddle/pten/kernels/xpu/full_kernel.cc +++ b/paddle/pten/kernels/xpu/full_kernel.cc @@ -16,9 +16,15 @@ #include "paddle/pten/api/ext/dispatch.h" #include "paddle/pten/backends/xpu/xpu_context.h" +#include "paddle/pten/common/bfloat16.h" +#include "paddle/pten/common/complex.h" +#include "paddle/pten/common/float16.h" #include "paddle/pten/common/scalar.h" #include "paddle/pten/core/kernel_registry.h" +// See Note [ Why still include the fluid headers? ] +#include "paddle/fluid/memory/memcpy.h" + namespace pten { template @@ -64,7 +70,7 @@ void FullLikeKernel(const Context& dev_ctx, using XPUInTDType = typename XPUTypeTrait::Type; using CommonType = typename std::common_type< float, - typename std::conditional::value, + typename std::conditional::value, float, T>::type>::type; @@ -118,10 +124,10 @@ PT_REGISTER_KERNEL(full, int, int64_t, bool, - pten::platform::float16, - pten::platform::bfloat16, - pten::platform::complex, - pten::platform::complex) {} + pten::dtype::float16, + pten::dtype::bfloat16, + pten::dtype::complex, + pten::dtype::complex) {} PT_REGISTER_KERNEL(full_like, XPU, @@ -130,4 +136,4 @@ PT_REGISTER_KERNEL(full_like, float, int, int64_t, - pten::platform::float16) {} + pten::dtype::float16) {} diff --git a/paddle/pten/kernels/xpu/scale_kernel.cc b/paddle/pten/kernels/xpu/scale_kernel.cc index 116cd63f876207b39bc9b523b9f9e70876cc1b98..25fb086044694e933843d1522a0b7ffd6ace0122 100644 --- a/paddle/pten/kernels/xpu/scale_kernel.cc +++ b/paddle/pten/kernels/xpu/scale_kernel.cc @@ -18,7 +18,7 @@ #include "paddle/pten/backends/xpu/xpu_context.h" #include "paddle/pten/common/data_type.h" #include "paddle/pten/common/float16.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" #include "paddle/pten/core/kernel_registry.h" namespace pten { diff --git a/paddle/pten/tests/api/test_cast_api.cc b/paddle/pten/tests/api/test_cast_api.cc index b87bebacab7d98f70255df407b2494a1e431f708..ad41759e150847abdf76e1051eaa672e8a03bb3f 100644 --- a/paddle/pten/tests/api/test_cast_api.cc +++ b/paddle/pten/tests/api/test_cast_api.cc @@ -35,7 +35,7 @@ TEST(API, cast) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 4}), + pten::framework::make_ddim({3, 4}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x->mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/api/test_concat_api.cc b/paddle/pten/tests/api/test_concat_api.cc index c003e89f6c0097b47156e7a6439c0a0a8d4a1b29..ec56861e80601dab88550fb64d98c821cf4848df 100644 --- a/paddle/pten/tests/api/test_concat_api.cc +++ b/paddle/pten/tests/api/test_concat_api.cc @@ -24,8 +24,7 @@ limitations under the License. */ namespace paddle { namespace tests { -namespace framework = paddle::framework; -using DDim = paddle::framework::DDim; +using DDim = pten::framework::DDim; // TODO(chentianyu03): Remove this test after the API is used in the dygraph TEST(API, concat) { @@ -35,7 +34,7 @@ TEST(API, concat) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 10}), + pten::framework::make_ddim({3, 10}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x->mutable_data(paddle::platform::CPUPlace()); @@ -43,7 +42,7 @@ TEST(API, concat) { auto dense_y = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 10}), + pten::framework::make_ddim({3, 10}), pten::DataLayout::NCHW)); auto* dense_y_data = dense_y->mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/api/test_conj_api.cc b/paddle/pten/tests/api/test_conj_api.cc index 0273737347ec380bb5517e0fb0097ef6a5e1e142..773ada1afccb05cade5fccd97a13ac8a8a2c53d7 100644 --- a/paddle/pten/tests/api/test_conj_api.cc +++ b/paddle/pten/tests/api/test_conj_api.cc @@ -35,7 +35,7 @@ TEST(API, conj) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::COMPLEX64, - framework::make_ddim({3, 10}), + pten::framework::make_ddim({3, 10}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x->mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/api/test_dot_api.cc b/paddle/pten/tests/api/test_dot_api.cc index 6de8943a467666123a9235d5113e43e4e7fffcea..9c35e2511924cf788710425e23a3623dfb7d756c 100644 --- a/paddle/pten/tests/api/test_dot_api.cc +++ b/paddle/pten/tests/api/test_dot_api.cc @@ -35,7 +35,7 @@ TEST(API, dot) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 10}), + pten::framework::make_ddim({3, 10}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x->mutable_data(paddle::platform::CPUPlace()); @@ -43,7 +43,7 @@ TEST(API, dot) { auto dense_y = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 10}), + pten::framework::make_ddim({3, 10}), pten::DataLayout::NCHW)); auto* dense_y_data = dense_y->mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/api/test_elementwise_api.cc b/paddle/pten/tests/api/test_elementwise_api.cc index df1c6278d96fdefa97969723cba785814f8636d3..2a6cf461ee50a2168dfaba5d931190da87b4e901 100644 --- a/paddle/pten/tests/api/test_elementwise_api.cc +++ b/paddle/pten/tests/api/test_elementwise_api.cc @@ -35,7 +35,7 @@ TEST(API, add) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 10}), + pten::framework::make_ddim({3, 10}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x->mutable_data(paddle::platform::CPUPlace()); @@ -43,7 +43,7 @@ TEST(API, add) { auto dense_y = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({10}), + pten::framework::make_ddim({10}), pten::DataLayout::NCHW)); auto* dense_y_data = dense_y->mutable_data(paddle::platform::CPUPlace()); @@ -91,7 +91,7 @@ TEST(API, subtract) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 10}), + pten::framework::make_ddim({3, 10}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x->mutable_data(paddle::platform::CPUPlace()); @@ -99,7 +99,7 @@ TEST(API, subtract) { auto dense_y = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({10}), + pten::framework::make_ddim({10}), pten::DataLayout::NCHW)); auto* dense_y_data = dense_y->mutable_data(paddle::platform::CPUPlace()); @@ -147,7 +147,7 @@ TEST(API, divide) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 10}), + pten::framework::make_ddim({3, 10}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x->mutable_data(paddle::platform::CPUPlace()); @@ -155,7 +155,7 @@ TEST(API, divide) { auto dense_y = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({10}), + pten::framework::make_ddim({10}), pten::DataLayout::NCHW)); auto* dense_y_data = dense_y->mutable_data(paddle::platform::CPUPlace()); @@ -203,7 +203,7 @@ TEST(API, multiply) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 10}), + pten::framework::make_ddim({3, 10}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x->mutable_data(paddle::platform::CPUPlace()); @@ -211,7 +211,7 @@ TEST(API, multiply) { auto dense_y = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({10}), + pten::framework::make_ddim({10}), pten::DataLayout::NCHW)); auto* dense_y_data = dense_y->mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/api/test_empty_api.cc b/paddle/pten/tests/api/test_empty_api.cc index 72f9100f7b3b7166937e59826985bd99d08b9ecb..4ce97d6c3abb463f99da78735ee0c73e601901a7 100644 --- a/paddle/pten/tests/api/test_empty_api.cc +++ b/paddle/pten/tests/api/test_empty_api.cc @@ -35,7 +35,7 @@ TEST(API, empty_like) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 2}), + pten::framework::make_ddim({3, 2}), pten::DataLayout::NCHW)); paddle::experimental::Tensor x(dense_x); @@ -59,7 +59,7 @@ TEST(API, empty1) { auto dense_shape = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::INT64, - framework::make_ddim({2}), + pten::framework::make_ddim({2}), pten::DataLayout::NCHW)); auto* shape_data = dense_shape->mutable_data(paddle::platform::CPUPlace()); @@ -86,7 +86,7 @@ TEST(API, empty2) { auto dense_scalar = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::INT32, - framework::make_ddim({1}), + pten::framework::make_ddim({1}), pten::DataLayout::NCHW)); dense_scalar->mutable_data(paddle::platform::CPUPlace())[0] = 2; diff --git a/paddle/pten/tests/api/test_fill_api.cc b/paddle/pten/tests/api/test_fill_api.cc index 4b78d142aefb2aa60025f10a4a29e02182cac830..dd80b935340e3fed361027a84e7349b80f2c3c8f 100644 --- a/paddle/pten/tests/api/test_fill_api.cc +++ b/paddle/pten/tests/api/test_fill_api.cc @@ -35,7 +35,7 @@ TEST(API, full_like) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 2}), + pten::framework::make_ddim({3, 2}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x->mutable_data(paddle::platform::CPUPlace()); @@ -71,7 +71,7 @@ TEST(API, zeros_like) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 2}), + pten::framework::make_ddim({3, 2}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x->mutable_data(paddle::platform::CPUPlace()); @@ -105,7 +105,7 @@ TEST(API, ones_like) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::INT32, - framework::make_ddim({3, 2}), + pten::framework::make_ddim({3, 2}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x->mutable_data(paddle::platform::CPUPlace()); @@ -140,7 +140,7 @@ TEST(API, full1) { auto dense_shape = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::INT64, - framework::make_ddim({2}), + pten::framework::make_ddim({2}), pten::DataLayout::NCHW)); auto* shape_data = dense_shape->mutable_data(paddle::platform::CPUPlace()); @@ -150,7 +150,7 @@ TEST(API, full1) { auto dense_scalar = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({1}), + pten::framework::make_ddim({1}), pten::DataLayout::NCHW)); dense_scalar->mutable_data(paddle::platform::CPUPlace())[0] = 1.0; @@ -187,7 +187,7 @@ TEST(API, full2) { auto dense_scalar = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::INT32, - framework::make_ddim({1}), + pten::framework::make_ddim({1}), pten::DataLayout::NCHW)); dense_scalar->mutable_data(paddle::platform::CPUPlace())[0] = 2; diff --git a/paddle/pten/tests/api/test_flatten_api.cc b/paddle/pten/tests/api/test_flatten_api.cc index f3b80f7db571553776583379159eeaf57f3cda72..7f04e6f3fc5900d4f12ea5b9433009323245ada4 100644 --- a/paddle/pten/tests/api/test_flatten_api.cc +++ b/paddle/pten/tests/api/test_flatten_api.cc @@ -35,7 +35,7 @@ TEST(API, flatten) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 2, 2, 3}), + pten::framework::make_ddim({3, 2, 2, 3}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x->mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/api/test_matmul_api.cc b/paddle/pten/tests/api/test_matmul_api.cc index 7342916c514ec30620db6928e2a2855f0ff3b61c..48d2374b68b76009f6f2af18b869f374327e9a54 100644 --- a/paddle/pten/tests/api/test_matmul_api.cc +++ b/paddle/pten/tests/api/test_matmul_api.cc @@ -35,7 +35,7 @@ TEST(API, matmul_cpu) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 3}), + pten::framework::make_ddim({3, 3}), pten::DataLayout::NCHW)); auto* dense_x_data = @@ -44,7 +44,7 @@ TEST(API, matmul_cpu) { auto dense_y = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 3}), + pten::framework::make_ddim({3, 3}), pten::DataLayout::NCHW)); auto* dense_y_data = dense_y->mutable_data(paddle::platform::CPUPlace()); @@ -86,7 +86,7 @@ TEST(API, matmul_cuda) { auto ref_x = std::make_shared( alloc_cpu.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 3}), + pten::framework::make_ddim({3, 3}), pten::DataLayout::NCHW)); auto* ref_x_data = ref_x->mutable_data(paddle::platform::CPUPlace()); @@ -94,7 +94,7 @@ TEST(API, matmul_cuda) { auto ref_y = std::make_shared( alloc_cpu.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 3}), + pten::framework::make_ddim({3, 3}), pten::DataLayout::NCHW)); auto* ref_y_data = ref_y->mutable_data(paddle::platform::CPUPlace()); @@ -111,13 +111,13 @@ TEST(API, matmul_cuda) { auto dense_x = std::make_shared( alloc_cuda.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 3}), + pten::framework::make_ddim({3, 3}), pten::DataLayout::NCHW)); auto dense_y = std::make_shared( alloc_cuda.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 3}), + pten::framework::make_ddim({3, 3}), pten::DataLayout::NCHW)); auto& pool = paddle::platform::DeviceContextPool::Instance(); diff --git a/paddle/pten/tests/api/test_mean_api.cc b/paddle/pten/tests/api/test_mean_api.cc index 046db05ca2bbb79abd636014f7d8f50deeb3a099..68b4933c5493aed2d0918f4a4782307db5b51fac 100644 --- a/paddle/pten/tests/api/test_mean_api.cc +++ b/paddle/pten/tests/api/test_mean_api.cc @@ -35,7 +35,7 @@ TEST(API, mean) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 4}), + pten::framework::make_ddim({3, 4}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x->mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/api/test_reshape_api.cc b/paddle/pten/tests/api/test_reshape_api.cc index 1f0d734a7ec6e9095a5efecdbe521c54eccc367e..27e47a9183f514f97785cc3bea8cfd6531722c54 100644 --- a/paddle/pten/tests/api/test_reshape_api.cc +++ b/paddle/pten/tests/api/test_reshape_api.cc @@ -35,7 +35,7 @@ TEST(API, reshape) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 2, 2, 3}), + pten::framework::make_ddim({3, 2, 2, 3}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x->mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/api/test_sum_api.cc b/paddle/pten/tests/api/test_sum_api.cc index 385d18aa784440db5ea5df4a248b7a175ee1921d..33be9e54eeb89e2e5c4570c97b9a8fbfefdfa4ce 100644 --- a/paddle/pten/tests/api/test_sum_api.cc +++ b/paddle/pten/tests/api/test_sum_api.cc @@ -35,7 +35,7 @@ TEST(API, sum) { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 4}), + pten::framework::make_ddim({3, 4}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x->mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/api/test_to_api.cc b/paddle/pten/tests/api/test_to_api.cc index 11636e1c0147c18a5c8d5ff00e43e6b0aa89a2cb..3a1692603ba1054d4332b246348ff00f3f090b82 100644 --- a/paddle/pten/tests/api/test_to_api.cc +++ b/paddle/pten/tests/api/test_to_api.cc @@ -33,7 +33,7 @@ paddle::experimental::Tensor CreateInputTensor() { auto dense_x = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::INT64, - framework::make_ddim({3, 4}), + pten::framework::make_ddim({3, 4}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x->mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/core/CMakeLists.txt b/paddle/pten/tests/core/CMakeLists.txt index 1404b9921f3dab2f3981cfdf7fcf5324dae1de69..d9c8c86a240880401c32afc5bbd76d22402ed105 100644 --- a/paddle/pten/tests/core/CMakeLists.txt +++ b/paddle/pten/tests/core/CMakeLists.txt @@ -23,3 +23,5 @@ endif() if (NOT WIN32) cc_test(test_rw_lock SRCS test_rw_lock.cc) endif (NOT WIN32) + +cc_test(unroll_array_ops_test SRCS unroll_array_ops_test.cc) diff --git a/paddle/pten/tests/core/test_convert_utils.cc b/paddle/pten/tests/core/test_convert_utils.cc index 51fba7cbe0658bc761562e47e4f5c0988d6c9d56..cc7ac6e7e59cac474efedea4ced694c1bef2326d 100644 --- a/paddle/pten/tests/core/test_convert_utils.cc +++ b/paddle/pten/tests/core/test_convert_utils.cc @@ -13,7 +13,7 @@ See the License for the specific language governing permissions and limitations under the License. */ #include "gtest/gtest.h" -#include "paddle/pten/core/convert_utils.h" +#include "paddle/pten/core/compat/convert_utils.h" namespace pten { namespace tests { diff --git a/paddle/pten/tests/core/test_device_context.cc b/paddle/pten/tests/core/test_device_context.cc index a44d0d32156197b4f9249a9c5facf6ac4055c3c7..c84c4a41a02bfc5aa5f6607b07b8955656b17aaf 100644 --- a/paddle/pten/tests/core/test_device_context.cc +++ b/paddle/pten/tests/core/test_device_context.cc @@ -29,7 +29,7 @@ TEST(DeviceContext, cpu_context) { std::cout << "test training scenarios" << std::endl; { pten::CPUContext ctx; - CHECK(ctx.eigen_device() != nullptr); + EXPECT_TRUE(ctx.eigen_device() != nullptr); } std::cout << "test inference scenarios" << std::endl; @@ -37,13 +37,13 @@ TEST(DeviceContext, cpu_context) { { pten::CPUContextResource ctx_res{device}; pten::CPUContext ctx(ctx_res); - CHECK(ctx.eigen_device() != nullptr); + EXPECT_TRUE(ctx.eigen_device() != nullptr); } { pten::CPUContextResource ctx_res{nullptr}; pten::CPUContext ctx(ctx_res); ctx.SetEigenDevice(device); - CHECK(ctx.eigen_device() != nullptr); + EXPECT_TRUE(ctx.eigen_device() != nullptr); } delete device; @@ -51,7 +51,7 @@ TEST(DeviceContext, cpu_context) { { pten::CPUContext ctx1; pten::CPUContext ctx2(ctx1); - CHECK_EQ(ctx1.eigen_device(), ctx2.eigen_device()); + EXPECT_EQ(ctx1.eigen_device(), ctx2.eigen_device()); } std::cout << "test move constructor" << std::endl; @@ -60,7 +60,7 @@ TEST(DeviceContext, cpu_context) { auto* eigen_device1 = ctx1.eigen_device(); pten::CPUContext ctx2(std::move(ctx1)); auto* eigen_device2 = ctx2.eigen_device(); - CHECK_EQ(eigen_device1, eigen_device2); + EXPECT_EQ(eigen_device1, eigen_device2); } } diff --git a/paddle/pten/tests/core/test_dim.cu b/paddle/pten/tests/core/test_dim.cu index 1c4a9c163f9434d06bc01e8976728651c156e233..fec1029814e7d3f3c4ef8da1dccd7c5798fa27fc 100644 --- a/paddle/pten/tests/core/test_dim.cu +++ b/paddle/pten/tests/core/test_dim.cu @@ -16,7 +16,7 @@ #include #include "gtest/gtest.h" -#include "paddle/pten/core/dim.h" +#include "paddle/pten/core/utils/dim.h" namespace pten { namespace tests { @@ -100,4 +100,4 @@ TEST(Dim, Print) { } } // namespace tests -} // namespace pten \ No newline at end of file +} // namespace pten diff --git a/paddle/pten/core/unroll_array_ops_test.cc b/paddle/pten/tests/core/unroll_array_ops_test.cc similarity index 96% rename from paddle/pten/core/unroll_array_ops_test.cc rename to paddle/pten/tests/core/unroll_array_ops_test.cc index f32d94be759beabe1c0fcf1f145601c074c3b62f..aee6cc6f40471acb01c03a54797a2257692ea238 100644 --- a/paddle/pten/core/unroll_array_ops_test.cc +++ b/paddle/pten/tests/core/unroll_array_ops_test.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "paddle/pten/core/unroll_array_ops.h" +#include "paddle/pten/core/utils/unroll_array_ops.h" #include #include @@ -79,4 +79,4 @@ TEST(unroll_ops, product) { } } // namespace framework -} // namespace pten \ No newline at end of file +} // namespace pten diff --git a/paddle/pten/tests/kernels/test_cast_dev_api.cc b/paddle/pten/tests/kernels/test_cast_dev_api.cc index 33d27ca5b1c9a91c577252e7f1596f4c163692d3..2f9dab0fbef048f7ce5fed8a0d9b1849ac532643 100644 --- a/paddle/pten/tests/kernels/test_cast_dev_api.cc +++ b/paddle/pten/tests/kernels/test_cast_dev_api.cc @@ -35,10 +35,11 @@ TEST(DEV_API, cast) { // 1. create tensor const auto alloc = std::make_unique( paddle::platform::CPUPlace()); - pten::DenseTensor dense_x(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 4}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_x( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({3, 4}), + pten::DataLayout::NCHW)); auto* dense_x_data = dense_x.mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/kernels/test_concat_dev_api.cc b/paddle/pten/tests/kernels/test_concat_dev_api.cc index eb546e992e953840fc43daf0e40178f06abe108b..ad2cf8c220e49e629a4083ca8fdda43f0bba104b 100644 --- a/paddle/pten/tests/kernels/test_concat_dev_api.cc +++ b/paddle/pten/tests/kernels/test_concat_dev_api.cc @@ -32,17 +32,19 @@ TEST(DEV_API, concat) { // 1. create tensor const auto alloc = std::make_unique( paddle::platform::CPUPlace()); - pten::DenseTensor dense_x(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 10}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_x( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({3, 10}), + pten::DataLayout::NCHW)); auto* dense_x_data = dense_x.mutable_data(paddle::platform::CPUPlace()); - pten::DenseTensor dense_y(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 10}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_y( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({3, 10}), + pten::DataLayout::NCHW)); auto* dense_y_data = dense_y.mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/kernels/test_conj_dev_api.cc b/paddle/pten/tests/kernels/test_conj_dev_api.cc index e43769dfb2b01116796e3d289f9d0d2dd9f772b0..27332d99be6a1c46a050346c663d4b3bb557caf0 100644 --- a/paddle/pten/tests/kernels/test_conj_dev_api.cc +++ b/paddle/pten/tests/kernels/test_conj_dev_api.cc @@ -33,10 +33,11 @@ TEST(DEV_API, conj) { // 1. create tensor const auto alloc = std::make_unique( paddle::platform::CPUPlace()); - pten::DenseTensor dense_x(alloc.get(), - pten::DenseTensorMeta(pten::DataType::COMPLEX64, - framework::make_ddim({3, 4}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_x( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::COMPLEX64, + pten::framework::make_ddim({3, 4}), + pten::DataLayout::NCHW)); auto* dense_x_data = dense_x.mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/kernels/test_copy_dev_api.cc b/paddle/pten/tests/kernels/test_copy_dev_api.cc index 29f68513fa77e71993ba37d5ca94ccda67b1dcd5..76891028c43993fadb00dedea391d77d0cf2d791 100644 --- a/paddle/pten/tests/kernels/test_copy_dev_api.cc +++ b/paddle/pten/tests/kernels/test_copy_dev_api.cc @@ -38,7 +38,7 @@ TEST(DEV_API, copy) { auto dense_src = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({2, 3}), + pten::framework::make_ddim({2, 3}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_src->mutable_data(paddle::platform::CPUPlace()); @@ -46,7 +46,7 @@ TEST(DEV_API, copy) { auto dense_dst = std::make_shared( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({2, 3}), + pten::framework::make_ddim({2, 3}), pten::DataLayout::NCHW)); for (size_t i = 0; i < 2; ++i) { diff --git a/paddle/pten/tests/kernels/test_creation_dev_api.cc b/paddle/pten/tests/kernels/test_creation_dev_api.cc index 8b37c41d0b55b2b6bd6375301563fcb46790f783..14f323399cc1ff1db37238f266bac17c0511fbe3 100644 --- a/paddle/pten/tests/kernels/test_creation_dev_api.cc +++ b/paddle/pten/tests/kernels/test_creation_dev_api.cc @@ -53,10 +53,11 @@ TEST(DEV_API, empty_like) { // 1. create tensor const auto alloc = std::make_unique( paddle::platform::CPUPlace()); - pten::DenseTensor dense_x(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 2}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_x( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({3, 2}), + pten::DataLayout::NCHW)); auto* dense_x_data = dense_x.mutable_data(paddle::platform::CPUPlace()); dense_x_data[0] = 0; @@ -106,10 +107,11 @@ TEST(DEV_API, full_like) { // 1. create tensor const auto alloc = std::make_unique( paddle::platform::CPUPlace()); - pten::DenseTensor dense_x(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 2}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_x( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({3, 2}), + pten::DataLayout::NCHW)); auto* dense_x_data = dense_x.mutable_data(paddle::platform::CPUPlace()); dense_x_data[0] = 0; diff --git a/paddle/pten/tests/kernels/test_dot_dev_api.cc b/paddle/pten/tests/kernels/test_dot_dev_api.cc index c1f7d6aaba39b91e0820c88850a223c6221f60d4..3343ab1d4283ae6a2a08462f1a92156c825e8595 100644 --- a/paddle/pten/tests/kernels/test_dot_dev_api.cc +++ b/paddle/pten/tests/kernels/test_dot_dev_api.cc @@ -33,17 +33,19 @@ TEST(DEV_API, dot) { // 1. create tensor const auto alloc = std::make_unique( paddle::platform::CPUPlace()); - pten::DenseTensor dense_x(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 10}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_x( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({3, 10}), + pten::DataLayout::NCHW)); auto* dense_x_data = dense_x.mutable_data(paddle::platform::CPUPlace()); - pten::DenseTensor dense_y(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 10}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_y( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({3, 10}), + pten::DataLayout::NCHW)); auto* dense_y_data = dense_y.mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/kernels/test_elementwise_dev_api.cc b/paddle/pten/tests/kernels/test_elementwise_dev_api.cc index 9d4c86f02679db03da14e26e52d65e37fdad21ab..5a44fb6dae8700fc90f561a974ebf9ecc34fd07b 100644 --- a/paddle/pten/tests/kernels/test_elementwise_dev_api.cc +++ b/paddle/pten/tests/kernels/test_elementwise_dev_api.cc @@ -33,17 +33,19 @@ TEST(DEV_API, add) { // 1. create tensor const auto alloc = std::make_unique( paddle::platform::CPUPlace()); - pten::DenseTensor dense_x(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 10}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_x( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({3, 10}), + pten::DataLayout::NCHW)); auto* dense_x_data = dense_x.mutable_data(paddle::platform::CPUPlace()); - pten::DenseTensor dense_y(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({10}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_y( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({10}), + pten::DataLayout::NCHW)); auto* dense_y_data = dense_y.mutable_data(paddle::platform::CPUPlace()); @@ -85,17 +87,19 @@ TEST(DEV_API, subtract) { // 1. create tensor const auto alloc = std::make_unique( paddle::platform::CPUPlace()); - pten::DenseTensor dense_x(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 10}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_x( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({3, 10}), + pten::DataLayout::NCHW)); auto* dense_x_data = dense_x.mutable_data(paddle::platform::CPUPlace()); - pten::DenseTensor dense_y(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({10}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_y( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({10}), + pten::DataLayout::NCHW)); auto* dense_y_data = dense_y.mutable_data(paddle::platform::CPUPlace()); @@ -137,17 +141,19 @@ TEST(DEV_API, divide) { // 1. create tensor const auto alloc = std::make_unique( paddle::platform::CPUPlace()); - pten::DenseTensor dense_x(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 10}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_x( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({3, 10}), + pten::DataLayout::NCHW)); auto* dense_x_data = dense_x.mutable_data(paddle::platform::CPUPlace()); - pten::DenseTensor dense_y(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({10}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_y( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({10}), + pten::DataLayout::NCHW)); auto* dense_y_data = dense_y.mutable_data(paddle::platform::CPUPlace()); @@ -189,17 +195,19 @@ TEST(DEV_API, multiply) { // 1. create tensor const auto alloc = std::make_unique( paddle::platform::CPUPlace()); - pten::DenseTensor dense_x(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 10}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_x( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({3, 10}), + pten::DataLayout::NCHW)); auto* dense_x_data = dense_x.mutable_data(paddle::platform::CPUPlace()); - pten::DenseTensor dense_y(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({10}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_y( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({10}), + pten::DataLayout::NCHW)); auto* dense_y_data = dense_y.mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/kernels/test_flatten_dev_api.cc b/paddle/pten/tests/kernels/test_flatten_dev_api.cc index 2ebf10916becc257a4352c454248a1e659a26309..749004f3d71e9b745bf39fba57d752bd6f284d2f 100644 --- a/paddle/pten/tests/kernels/test_flatten_dev_api.cc +++ b/paddle/pten/tests/kernels/test_flatten_dev_api.cc @@ -46,7 +46,7 @@ TEST(DEV_API, flatten) { pten::DenseTensor dense_x( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 2, 2, 3}), + pten::framework::make_ddim({3, 2, 2, 3}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x.mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/kernels/test_matmul_dev_api.cc b/paddle/pten/tests/kernels/test_matmul_dev_api.cc index 87c91b10081b985d85d079f144c257185329715a..0dfbb54a496ae17086ca196583455e9157eb4016 100644 --- a/paddle/pten/tests/kernels/test_matmul_dev_api.cc +++ b/paddle/pten/tests/kernels/test_matmul_dev_api.cc @@ -34,7 +34,7 @@ TEST(DEV_API, dot) { paddle::platform::CPUPlace()); DenseTensor dense_x(alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 3}), + pten::framework::make_ddim({3, 3}), pten::DataLayout::NCHW)); auto* dense_x_data = @@ -42,7 +42,7 @@ TEST(DEV_API, dot) { DenseTensor dense_y(alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 3}), + pten::framework::make_ddim({3, 3}), pten::DataLayout::NCHW)); auto* dense_y_data = dense_y.mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/kernels/test_mean_dev_api.cc b/paddle/pten/tests/kernels/test_mean_dev_api.cc index 3abf54d26af31ccd315eb63b231202fba83ea1fa..5360c711d0a7c8a9be8bd68d90b1130736d10ec0 100644 --- a/paddle/pten/tests/kernels/test_mean_dev_api.cc +++ b/paddle/pten/tests/kernels/test_mean_dev_api.cc @@ -32,10 +32,11 @@ TEST(DEV_API, mean) { // 1. create tensor const auto alloc = std::make_unique( paddle::platform::CPUPlace()); - pten::DenseTensor dense_x(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 4}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_x( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({3, 4}), + pten::DataLayout::NCHW)); auto* dense_x_data = dense_x.mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/kernels/test_reshape_dev_api.cc b/paddle/pten/tests/kernels/test_reshape_dev_api.cc index fe9b09c25557c30b8995f3d8ffd8be03e0fe2cdb..95eda3ef2d49fb2c22e5063d575b1f3e430fbce7 100644 --- a/paddle/pten/tests/kernels/test_reshape_dev_api.cc +++ b/paddle/pten/tests/kernels/test_reshape_dev_api.cc @@ -36,7 +36,7 @@ TEST(DEV_API, reshape) { pten::DenseTensor dense_x( alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 2, 2, 3}), + pten::framework::make_ddim({3, 2, 2, 3}), pten::DataLayout::NCHW)); auto* dense_x_data = dense_x.mutable_data(paddle::platform::CPUPlace()); diff --git a/paddle/pten/tests/kernels/test_scale_dev_api.cc b/paddle/pten/tests/kernels/test_scale_dev_api.cc index 80f12950094b794485e577e1e6920e00b136b55a..f27e1037d0471f2386f615b7b2b2394e64a56e85 100644 --- a/paddle/pten/tests/kernels/test_scale_dev_api.cc +++ b/paddle/pten/tests/kernels/test_scale_dev_api.cc @@ -32,10 +32,11 @@ TEST(DEV_API, scale) { // 1. create tensor const auto alloc = std::make_unique( paddle::platform::CPUPlace()); - pten::DenseTensor dense_x(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 4}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_x( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({3, 4}), + pten::DataLayout::NCHW)); auto* dense_x_data = dense_x.mutable_data(paddle::platform::CPUPlace()); @@ -70,10 +71,11 @@ TEST(DEV_API, scale_host) { // 1. create tensor const auto alloc = std::make_unique( paddle::platform::CPUPlace()); - pten::DenseTensor dense_x(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 4}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_x( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({3, 4}), + pten::DataLayout::NCHW)); auto* dense_x_data = dense_x.mutable_data(paddle::platform::CPUPlace()); for (size_t i = 0; i < 12; ++i) { @@ -82,7 +84,7 @@ TEST(DEV_API, scale_host) { pten::DenseTensor scale(alloc.get(), pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({1}), + pten::framework::make_ddim({1}), pten::DataLayout::NCHW)); scale.data()[0] = 2; float bias = 1; diff --git a/paddle/pten/tests/kernels/test_sum_dev_api.cc b/paddle/pten/tests/kernels/test_sum_dev_api.cc index 9b48d8908ff2306fa9466874d0edcde8864e9379..023d62c7ed9ff0d1e16092ab3afddddf56ada6d8 100644 --- a/paddle/pten/tests/kernels/test_sum_dev_api.cc +++ b/paddle/pten/tests/kernels/test_sum_dev_api.cc @@ -31,10 +31,11 @@ TEST(DEV_API, sum) { // 1. create tensor const auto alloc = std::make_unique( paddle::platform::CPUPlace()); - pten::DenseTensor dense_x(alloc.get(), - pten::DenseTensorMeta(pten::DataType::FLOAT32, - framework::make_ddim({3, 4}), - pten::DataLayout::NCHW)); + pten::DenseTensor dense_x( + alloc.get(), + pten::DenseTensorMeta(pten::DataType::FLOAT32, + pten::framework::make_ddim({3, 4}), + pten::DataLayout::NCHW)); auto* dense_x_data = dense_x.mutable_data(paddle::platform::CPUPlace()); diff --git a/python/setup.py.in b/python/setup.py.in index 4fe4704ae1b78de5526631ecf86ce816fc671766..d5b237d2a3f0eccc8363519dd04533b2c9cebd27 100644 --- a/python/setup.py.in +++ b/python/setup.py.in @@ -567,13 +567,15 @@ def find_files(pattern, root, recursive=False): break headers = ( + # paddle level api headers list(find_files('*.h', '@PADDLE_SOURCE_DIR@/paddle')) + list(find_files('*.h', '@PADDLE_SOURCE_DIR@/paddle/pten/api')) + # pten unify api header list(find_files('*.h', '@PADDLE_SOURCE_DIR@/paddle/pten/api/ext')) + # custom op api list(find_files('*.h', '@PADDLE_SOURCE_DIR@/paddle/pten/api/include')) + # pten api list(find_files('*.h', '@PADDLE_SOURCE_DIR@/paddle/pten/common')) + # pten common headers - # For paddle uew custom op, only copy data type headers from `paddle/fluid/platform` - # to `paddle/pten/api/ext`, + # pten level api headers (low level api) + list(find_files('*.h', '@PADDLE_SOURCE_DIR@/paddle/pten/core', recursive=True)) + # pten core headers + # utila api headers ['@PADDLE_SOURCE_DIR@/paddle/utils/any.h'] + ['@PADDLE_SOURCE_DIR@/paddle/utils/small_vector.h']) @@ -620,8 +622,6 @@ class InstallHeaders(Command): elif 'third_party' not in header: # paddle headers install_dir = re.sub('@PADDLE_SOURCE_DIR@/', '', header) - if 'fluid' in install_dir: - install_dir = "paddle/pten/common/" else: # third_party install_dir = re.sub('${THIRD_PARTY_PATH}', 'third_party', header)