wehub-resource-sync
540 lines
16 KiB
C++
540 lines
16 KiB
C++
// Copyright (c) 2018 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.
|
|
|
|
#include <gtest/gtest.h>
|
|
#include <array>
|
|
#include <cmath>
|
|
|
|
#include "paddle/fluid/framework/tensor_util.h"
|
|
#include "paddle/fluid/operators/isfinite_op.h"
|
|
namespace paddle {
|
|
namespace framework {
|
|
|
|
TEST(TensorCopy, Tensor) {
|
|
phi::DenseTensor src_tensor;
|
|
phi::DenseTensor dst_tensor;
|
|
phi::CPUContext cpu_ctx((phi::CPUPlace()));
|
|
|
|
int* src_ptr =
|
|
src_tensor.mutable_data<int>(common::make_ddim({3, 3}), phi::CPUPlace());
|
|
|
|
std::array<int, 9> arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
|
|
memcpy(src_ptr, arr.data(), 9 * sizeof(int));
|
|
src_tensor.set_layout(DataLayout::kAnyLayout);
|
|
|
|
auto cpu_place = new phi::CPUPlace();
|
|
TensorCopy(src_tensor, *cpu_place, &dst_tensor);
|
|
|
|
const int* dst_ptr = dst_tensor.data<int>();
|
|
EXPECT_NE(src_ptr, dst_ptr);
|
|
for (size_t i = 0; i < 9; ++i) {
|
|
EXPECT_EQ(src_ptr[i], dst_ptr[i]);
|
|
}
|
|
|
|
TensorCopy(dst_tensor, *cpu_place, &dst_tensor);
|
|
for (size_t i = 0; i < 9; ++i) {
|
|
EXPECT_EQ(src_ptr[i], dst_ptr[i]);
|
|
}
|
|
|
|
EXPECT_TRUE(dst_tensor.layout() == src_tensor.layout());
|
|
|
|
phi::DenseTensor slice_tensor = src_tensor.Slice(1, 2);
|
|
TensorCopy(slice_tensor, *cpu_place, &dst_tensor);
|
|
const int* slice_ptr = slice_tensor.data<int>();
|
|
dst_ptr = dst_tensor.data<int>();
|
|
EXPECT_NE(dst_ptr, slice_ptr);
|
|
for (size_t i = 0; i < 3; ++i) {
|
|
EXPECT_EQ(dst_ptr[i], slice_ptr[i]);
|
|
}
|
|
EXPECT_TRUE(dst_tensor.layout() == src_tensor.layout());
|
|
|
|
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
|
|
{
|
|
phi::DenseTensor src_tensor;
|
|
phi::DenseTensor gpu_tensor;
|
|
phi::DenseTensor dst_tensor;
|
|
|
|
int* src_ptr = src_tensor.mutable_data<int>(common::make_ddim({3, 3}),
|
|
phi::CPUPlace());
|
|
|
|
std::array<int, 9> arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
|
|
memcpy(src_ptr, arr.data(), 9 * sizeof(int));
|
|
|
|
// CPU phi::DenseTensor to GPU phi::DenseTensor
|
|
auto gpu_place = new phi::GPUPlace(0);
|
|
phi::GPUContext gpu_ctx(*gpu_place);
|
|
gpu_ctx.SetAllocator(paddle::memory::allocation::AllocatorFacade::Instance()
|
|
.GetAllocator(*gpu_place, gpu_ctx.stream())
|
|
.get());
|
|
gpu_ctx.PartialInitWithAllocator();
|
|
TensorCopy(src_tensor, *gpu_place, gpu_ctx, &gpu_tensor);
|
|
|
|
// GPU phi::DenseTensor to CPU phi::DenseTensor
|
|
auto cpu_place = new phi::CPUPlace();
|
|
TensorCopy(gpu_tensor, *cpu_place, gpu_ctx, &dst_tensor);
|
|
|
|
// Sync before Compare Tensors
|
|
gpu_ctx.Wait();
|
|
const int* dst_ptr = dst_tensor.data<int>();
|
|
EXPECT_NE(src_ptr, dst_ptr);
|
|
for (size_t i = 0; i < 9; ++i) {
|
|
EXPECT_EQ(src_ptr[i], dst_ptr[i]);
|
|
}
|
|
|
|
// Copy the same tensor
|
|
TensorCopy(gpu_tensor, *gpu_place, gpu_ctx, &gpu_tensor);
|
|
gpu_ctx.Wait();
|
|
const int* dst_ptr_tmp = dst_tensor.data<int>();
|
|
EXPECT_NE(src_ptr, dst_ptr_tmp);
|
|
for (size_t i = 0; i < 9; ++i) {
|
|
EXPECT_EQ(src_ptr[i], dst_ptr_tmp[i]);
|
|
}
|
|
|
|
phi::DenseTensor slice_tensor = src_tensor.Slice(1, 2);
|
|
|
|
// CPU Slice phi::DenseTensor to GPU phi::DenseTensor
|
|
TensorCopy(slice_tensor, *gpu_place, gpu_ctx, &gpu_tensor);
|
|
|
|
// GPU phi::DenseTensor to CPU phi::DenseTensor
|
|
TensorCopy(gpu_tensor, *cpu_place, gpu_ctx, &dst_tensor);
|
|
|
|
// Sync before Compare Slice Tensors
|
|
gpu_ctx.Wait();
|
|
const int* slice_ptr = slice_tensor.data<int>();
|
|
dst_ptr = dst_tensor.data<int>();
|
|
EXPECT_NE(dst_ptr, slice_ptr);
|
|
for (size_t i = 0; i < 3; ++i) {
|
|
EXPECT_EQ(dst_ptr[i], slice_ptr[i]);
|
|
}
|
|
|
|
EXPECT_TRUE(dst_tensor.layout() == src_tensor.layout());
|
|
}
|
|
#endif
|
|
}
|
|
|
|
TEST(TensorFromVector, Tensor) {
|
|
{
|
|
std::vector<int> src_vec = {1, 2, 3, 4, 5, 6, 7, 8, 9};
|
|
phi::DenseTensor cpu_tensor;
|
|
|
|
// Copy to CPU phi::DenseTensor
|
|
cpu_tensor.Resize(common::make_ddim({3, 3}));
|
|
auto cpu_place = new phi::CPUPlace();
|
|
paddle::framework::TensorFromVector<int>(src_vec, &cpu_tensor);
|
|
|
|
// Compare Tensors
|
|
const int* cpu_ptr = cpu_tensor.data<int>();
|
|
const int* src_ptr = src_vec.data();
|
|
EXPECT_NE(src_ptr, cpu_ptr);
|
|
for (size_t i = 0; i < 9; ++i) {
|
|
EXPECT_EQ(src_ptr[i], cpu_ptr[i]);
|
|
}
|
|
|
|
src_vec.erase(src_vec.begin(), src_vec.begin() + 5);
|
|
cpu_tensor.Resize(common::make_ddim({2, 2}));
|
|
paddle::framework::TensorFromVector<int>(src_vec, &cpu_tensor);
|
|
cpu_ptr = cpu_tensor.data<int>();
|
|
src_ptr = src_vec.data();
|
|
EXPECT_NE(src_ptr, cpu_ptr);
|
|
for (size_t i = 0; i < 5; ++i) {
|
|
EXPECT_EQ(src_ptr[i], cpu_ptr[i]);
|
|
}
|
|
|
|
delete cpu_place;
|
|
}
|
|
|
|
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
|
|
{
|
|
std::vector<int> src_vec = {1, 2, 3, 4, 5, 6, 7, 8, 9};
|
|
phi::DenseTensor cpu_tensor;
|
|
phi::DenseTensor gpu_tensor;
|
|
phi::DenseTensor dst_tensor;
|
|
|
|
// Copy to CPU phi::DenseTensor
|
|
cpu_tensor.Resize(common::make_ddim({3, 3}));
|
|
auto cpu_place = new phi::CPUPlace();
|
|
phi::CPUContext cpu_ctx(*cpu_place);
|
|
paddle::framework::TensorFromVector<int>(src_vec, cpu_ctx, &cpu_tensor);
|
|
|
|
// Copy to GPUTensor
|
|
gpu_tensor.Resize(common::make_ddim({3, 3}));
|
|
auto gpu_place = new phi::GPUPlace();
|
|
phi::GPUContext gpu_ctx(*gpu_place);
|
|
gpu_ctx.SetAllocator(paddle::memory::allocation::AllocatorFacade::Instance()
|
|
.GetAllocator(*gpu_place, gpu_ctx.stream())
|
|
.get());
|
|
gpu_ctx.PartialInitWithAllocator();
|
|
paddle::framework::TensorFromVector<int>(src_vec, gpu_ctx, &gpu_tensor);
|
|
// Copy from GPU to CPU tensor for comparison
|
|
paddle::framework::TensorCopy(gpu_tensor, *cpu_place, gpu_ctx, &dst_tensor);
|
|
|
|
// Sync before Compare Tensors
|
|
gpu_ctx.Wait();
|
|
const int* src_ptr = src_vec.data();
|
|
const int* cpu_ptr = cpu_tensor.data<int>();
|
|
const int* dst_ptr = dst_tensor.data<int>();
|
|
EXPECT_NE(src_ptr, cpu_ptr);
|
|
EXPECT_NE(src_ptr, dst_ptr);
|
|
for (size_t i = 0; i < 9; ++i) {
|
|
EXPECT_EQ(src_ptr[i], cpu_ptr[i]);
|
|
EXPECT_EQ(src_ptr[i], dst_ptr[i]);
|
|
}
|
|
|
|
src_vec.erase(src_vec.begin(), src_vec.begin() + 5);
|
|
|
|
cpu_tensor.Resize(common::make_ddim({2, 2}));
|
|
paddle::framework::TensorFromVector<int>(src_vec, cpu_ctx, &cpu_tensor);
|
|
gpu_tensor.Resize(common::make_ddim({2, 2}));
|
|
paddle::framework::TensorFromVector<int>(src_vec, gpu_ctx, &gpu_tensor);
|
|
paddle::framework::TensorCopy(gpu_tensor, *cpu_place, gpu_ctx, &dst_tensor);
|
|
|
|
// Sync before Compare Tensors
|
|
gpu_ctx.Wait();
|
|
src_ptr = src_vec.data();
|
|
cpu_ptr = cpu_tensor.data<int>();
|
|
dst_ptr = dst_tensor.data<int>();
|
|
EXPECT_NE(src_ptr, cpu_ptr);
|
|
EXPECT_NE(src_ptr, dst_ptr);
|
|
for (size_t i = 0; i < 5; ++i) {
|
|
EXPECT_EQ(src_ptr[i], cpu_ptr[i]);
|
|
EXPECT_EQ(src_ptr[i], dst_ptr[i]);
|
|
}
|
|
|
|
delete cpu_place;
|
|
delete gpu_place;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
TEST(TensorToVector, Tensor) {
|
|
{
|
|
phi::DenseTensor src;
|
|
int* src_ptr = src.mutable_data<int>({3, 3}, phi::CPUPlace());
|
|
for (int i = 0; i < 3 * 3; ++i) {
|
|
src_ptr[i] = i;
|
|
}
|
|
|
|
phi::CPUPlace place;
|
|
std::vector<int> dst;
|
|
paddle::framework::TensorToVector<int>(src, &dst);
|
|
|
|
for (int i = 0; i < 3 * 3; ++i) {
|
|
EXPECT_EQ(src_ptr[i], dst[i]);
|
|
}
|
|
}
|
|
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
|
|
{
|
|
std::vector<int> src_vec = {1, 2, 3, 4, 5, 6, 7, 8, 9};
|
|
phi::DenseTensor gpu_tensor;
|
|
phi::GPUPlace place;
|
|
phi::GPUContext gpu_ctx(place);
|
|
gpu_ctx.SetAllocator(paddle::memory::allocation::AllocatorFacade::Instance()
|
|
.GetAllocator(place, gpu_ctx.stream())
|
|
.get());
|
|
gpu_ctx.PartialInitWithAllocator();
|
|
paddle::framework::TensorFromVector<int>(src_vec, gpu_ctx, &gpu_tensor);
|
|
|
|
std::vector<int> dst;
|
|
paddle::framework::TensorToVector<int>(gpu_tensor, gpu_ctx, &dst);
|
|
|
|
for (int i = 0; i < 3 * 3; ++i) {
|
|
EXPECT_EQ(src_vec[i], dst[i]);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
TEST(TensorToVector, Tensor_bool) {
|
|
phi::DenseTensor src;
|
|
bool* src_ptr = src.mutable_data<bool>({3, 3}, phi::CPUPlace());
|
|
for (int i = 0; i < 3 * 3; ++i) {
|
|
src_ptr[i] = static_cast<bool>(i % 2);
|
|
}
|
|
|
|
phi::CPUPlace place;
|
|
std::vector<bool> dst;
|
|
paddle::framework::TensorToVector<bool>(src, &dst);
|
|
|
|
for (int i = 0; i < 3 * 3; ++i) {
|
|
EXPECT_EQ(src_ptr[i], dst[i]);
|
|
}
|
|
|
|
#ifdef PADDLE_WITH_CUDA
|
|
{
|
|
std::vector<bool> src_vec = {
|
|
false,
|
|
true,
|
|
false,
|
|
true,
|
|
false,
|
|
true,
|
|
false,
|
|
true,
|
|
false,
|
|
};
|
|
phi::DenseTensor gpu_tensor;
|
|
phi::GPUPlace place;
|
|
phi::GPUContext gpu_ctx(place);
|
|
gpu_ctx.SetAllocator(paddle::memory::allocation::AllocatorFacade::Instance()
|
|
.GetAllocator(place, gpu_ctx.stream())
|
|
.get());
|
|
gpu_ctx.PartialInitWithAllocator();
|
|
paddle::framework::TensorFromVector<bool>(src_vec, gpu_ctx, &gpu_tensor);
|
|
|
|
std::vector<bool> dst;
|
|
paddle::framework::TensorToVector<bool>(gpu_tensor, gpu_ctx, &dst);
|
|
|
|
for (int i = 0; i < 3 * 3; ++i) {
|
|
EXPECT_EQ(src_vec[i], dst[i]);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
TEST(TensorFromDLPack, Tensor) {
|
|
{
|
|
std::vector<int> src_vec = {1, 2, 3, 4, 5, 6, 7, 8, 9};
|
|
phi::DenseTensor cpu_tensor;
|
|
|
|
cpu_tensor.Resize(common::make_ddim({3, 3}));
|
|
phi::CPUPlace cpu_place;
|
|
phi::CPUContext cpu_ctx(cpu_place);
|
|
paddle::framework::TensorFromVector<int>(src_vec, cpu_ctx, &cpu_tensor);
|
|
::DLManagedTensor* dlpack_tensor = paddle::framework::ToDLPack(cpu_tensor);
|
|
|
|
phi::DenseTensor dst_tensor = paddle::framework::FromDLPack(dlpack_tensor);
|
|
|
|
auto cpu_ptr = cpu_tensor.data<int>();
|
|
auto src_ptr = dst_tensor.data<int>();
|
|
EXPECT_EQ(src_ptr, cpu_ptr);
|
|
for (size_t i = 0; i < 9; ++i) {
|
|
EXPECT_EQ(src_ptr[i], cpu_ptr[i]);
|
|
}
|
|
}
|
|
|
|
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
|
|
{
|
|
std::vector<int> src_vec = {1, 2, 3, 4, 5, 6, 7, 8, 9};
|
|
phi::DenseTensor cpu_tensor;
|
|
phi::DenseTensor gpu_tensor;
|
|
phi::DenseTensor dst_tensor;
|
|
phi::DenseTensor gpu_tensor_from_dlpack;
|
|
|
|
// Copy to CPU phi::DenseTensor
|
|
cpu_tensor.Resize(common::make_ddim({3, 3}));
|
|
phi::CPUPlace cpu_place;
|
|
phi::CPUContext cpu_ctx(cpu_place);
|
|
paddle::framework::TensorFromVector<int>(src_vec, cpu_ctx, &cpu_tensor);
|
|
|
|
// Copy to GPUTensor
|
|
gpu_tensor.Resize(common::make_ddim({3, 3}));
|
|
phi::GPUPlace gpu_place;
|
|
auto& gpu_ctx = *phi::DeviceContextPool::Instance().GetByPlace(gpu_place);
|
|
paddle::framework::TensorFromVector<int>(src_vec, gpu_ctx, &gpu_tensor);
|
|
gpu_ctx.Wait();
|
|
|
|
::DLManagedTensor* dl_managed_tensor =
|
|
paddle::framework::ToDLPack(gpu_tensor);
|
|
gpu_tensor_from_dlpack =
|
|
paddle::framework::TensorFromDLPack(dl_managed_tensor);
|
|
gpu_ctx.Wait();
|
|
|
|
// Copy from GPU to CPU tensor for comparison
|
|
paddle::framework::TensorCopy(
|
|
gpu_tensor_from_dlpack, cpu_place, gpu_ctx, &dst_tensor);
|
|
// Sync before Compare Tensors
|
|
gpu_ctx.Wait();
|
|
const int* src_ptr = src_vec.data();
|
|
const int* cpu_ptr = cpu_tensor.data<int>();
|
|
const int* dst_ptr = dst_tensor.data<int>();
|
|
EXPECT_NE(src_ptr, cpu_ptr);
|
|
EXPECT_NE(src_ptr, dst_ptr);
|
|
for (size_t i = 0; i < 9; ++i) {
|
|
EXPECT_EQ(src_ptr[i], cpu_ptr[i]);
|
|
EXPECT_EQ(src_ptr[i], dst_ptr[i]);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
TEST(TensorContainsNAN, CPU) {
|
|
{
|
|
phi::DenseTensor src;
|
|
float* buf = src.mutable_data<float>({3}, phi::CPUPlace());
|
|
buf[0] = 0.0;
|
|
buf[1] = NAN;
|
|
buf[2] = 0.0;
|
|
EXPECT_TRUE(paddle::framework::TensorContainsNAN(src));
|
|
buf[1] = 0.0;
|
|
EXPECT_FALSE(paddle::framework::TensorContainsNAN(src));
|
|
}
|
|
|
|
{
|
|
phi::DenseTensor src;
|
|
phi::dtype::float16* buf =
|
|
src.mutable_data<phi::dtype::float16>({3}, phi::CPUPlace());
|
|
buf[0] = 0.0;
|
|
buf[1].x = 0x7fff;
|
|
buf[2] = 0.0;
|
|
EXPECT_TRUE(paddle::framework::TensorContainsNAN(src));
|
|
buf[1] = 0.0;
|
|
EXPECT_FALSE(paddle::framework::TensorContainsNAN(src));
|
|
}
|
|
}
|
|
|
|
TEST(TensorContainsInf, CPU) {
|
|
{
|
|
phi::DenseTensor src;
|
|
double* buf = src.mutable_data<double>({3}, phi::CPUPlace());
|
|
buf[0] = 1.0;
|
|
buf[1] = INFINITY;
|
|
buf[2] = 0.0;
|
|
EXPECT_TRUE(paddle::framework::TensorContainsInf(src));
|
|
buf[1] = 1.0;
|
|
EXPECT_FALSE(paddle::framework::TensorContainsInf(src));
|
|
}
|
|
|
|
{
|
|
phi::DenseTensor src;
|
|
phi::dtype::float16* buf =
|
|
src.mutable_data<phi::dtype::float16>({3}, phi::CPUPlace());
|
|
buf[0] = 1.0;
|
|
buf[1].x = 0x7c00;
|
|
buf[2] = 0.0;
|
|
EXPECT_TRUE(paddle::framework::TensorContainsInf(src));
|
|
buf[1] = 1.0;
|
|
EXPECT_FALSE(paddle::framework::TensorContainsInf(src));
|
|
}
|
|
}
|
|
|
|
TEST(TensorIsfinite, CPU) {
|
|
{
|
|
phi::DenseTensor src, out;
|
|
double* buf = src.mutable_data<double>({3}, phi::CPUPlace());
|
|
buf[0] = 1.0;
|
|
buf[1] = INFINITY;
|
|
buf[2] = 0.0;
|
|
paddle::framework::TensorIsfinite(src, &out);
|
|
EXPECT_EQ(out.data<bool>()[0], false);
|
|
buf[1] = 1.0;
|
|
paddle::framework::TensorIsfinite(src, &out);
|
|
EXPECT_EQ(out.data<bool>()[0], true);
|
|
}
|
|
|
|
{
|
|
phi::DenseTensor src, out;
|
|
double* buf = src.mutable_data<double>({3}, phi::CPUPlace());
|
|
buf[0] = 1.0;
|
|
buf[1] = NAN;
|
|
buf[2] = 0.0;
|
|
paddle::framework::TensorIsfinite(src, &out);
|
|
EXPECT_EQ(out.data<bool>()[0], false);
|
|
buf[1] = 1.0;
|
|
paddle::framework::TensorIsfinite(src, &out);
|
|
EXPECT_EQ(out.data<bool>()[0], true);
|
|
}
|
|
|
|
{
|
|
phi::DenseTensor src, out;
|
|
phi::dtype::float16* buf =
|
|
src.mutable_data<phi::dtype::float16>({3}, phi::CPUPlace());
|
|
buf[0] = 1.0;
|
|
buf[1].x = 0x7c00;
|
|
buf[2] = 0.0;
|
|
paddle::framework::TensorIsfinite(src, &out);
|
|
EXPECT_EQ(out.data<bool>()[0], false);
|
|
buf[1] = 1.0;
|
|
paddle::framework::TensorIsfinite(src, &out);
|
|
EXPECT_EQ(out.data<bool>()[0], true);
|
|
buf[1].x = 0x7fff;
|
|
paddle::framework::TensorIsfinite(src, &out);
|
|
EXPECT_EQ(out.data<bool>()[0], false);
|
|
}
|
|
}
|
|
|
|
TEST(Tensor, FromAndToStream) {
|
|
phi::DenseTensor src_tensor;
|
|
std::array<int, 6> array = {1, 2, 3, 4, 5, 6};
|
|
src_tensor.Resize({2, 3});
|
|
int* src_ptr = src_tensor.mutable_data<int>(phi::CPUPlace());
|
|
for (int i = 0; i < 6; ++i) {
|
|
src_ptr[i] = array[i];
|
|
}
|
|
{
|
|
phi::DenseTensor dst_tensor;
|
|
auto place = new phi::CPUPlace();
|
|
phi::CPUContext cpu_ctx(*place);
|
|
std::ostringstream oss;
|
|
phi::TensorToStream(oss, src_tensor, cpu_ctx);
|
|
|
|
std::istringstream iss(oss.str());
|
|
phi::TensorFromStream(iss, &dst_tensor, cpu_ctx);
|
|
int* dst_ptr = dst_tensor.mutable_data<int>(phi::CPUPlace());
|
|
for (int i = 0; i < 5; ++i) {
|
|
EXPECT_EQ(dst_ptr[i], array[i]);
|
|
}
|
|
EXPECT_EQ(dst_tensor.dims(), src_tensor.dims());
|
|
delete place;
|
|
}
|
|
{
|
|
phi::DenseTensor dst_tensor;
|
|
phi::CPUPlace place;
|
|
phi::CPUContext cpu_ctx(place);
|
|
std::ostringstream oss;
|
|
paddle::framework::TensorToStream(oss, src_tensor, cpu_ctx);
|
|
|
|
std::istringstream iss(oss.str());
|
|
paddle::framework::TensorFromStream(iss, &dst_tensor, cpu_ctx);
|
|
int* dst_ptr = dst_tensor.mutable_data<int>(phi::CPUPlace());
|
|
for (int i = 0; i < 6; ++i) {
|
|
EXPECT_EQ(dst_ptr[i], array[i]);
|
|
}
|
|
EXPECT_EQ(dst_tensor.dims(), src_tensor.dims());
|
|
}
|
|
#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
|
|
{
|
|
phi::DenseTensor gpu_tensor;
|
|
gpu_tensor.Resize({2, 3});
|
|
phi::DenseTensor dst_tensor;
|
|
|
|
auto gpu_place = new phi::GPUPlace();
|
|
phi::GPUContext gpu_ctx(*gpu_place);
|
|
gpu_ctx.SetAllocator(paddle::memory::allocation::AllocatorFacade::Instance()
|
|
.GetAllocator(*gpu_place, gpu_ctx.stream())
|
|
.get());
|
|
gpu_ctx.PartialInitWithAllocator();
|
|
|
|
TensorCopy(src_tensor, *gpu_place, gpu_ctx, &gpu_tensor);
|
|
|
|
std::ostringstream oss;
|
|
phi::TensorToStream(oss, gpu_tensor, gpu_ctx);
|
|
|
|
std::istringstream iss(oss.str());
|
|
phi::TensorFromStream(
|
|
iss,
|
|
&dst_tensor,
|
|
*phi::DeviceContextPool::Instance().Get(phi::CPUPlace()));
|
|
|
|
int* dst_ptr = dst_tensor.mutable_data<int>(phi::CPUPlace());
|
|
for (int i = 0; i < 6; ++i) {
|
|
EXPECT_EQ(dst_ptr[i], array[i]);
|
|
}
|
|
delete gpu_place;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
} // namespace framework
|
|
} // namespace paddle
|