chore: import upstream snapshot with attribution
This commit is contained in:
wehub-resource-sync
@@ -0,0 +1,4 @@
|
||||
paddle_test(enforce_xpu_test SRCS enforce_xpu_test.cc)
|
||||
paddle_test(overload_xpu_alloc_test SRCS overload_xpu_alloc_test.cc)
|
||||
paddle_test(beam_search_decode_op_xpu_test SRCS
|
||||
beam_search_decode_op_xpu_test.cc)
|
||||
@@ -0,0 +1,228 @@
|
||||
/* 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. */
|
||||
|
||||
#include "paddle/phi/backends/xpu/xpu_info.h"
|
||||
#include "paddle/phi/common/memory_utils.h"
|
||||
#include "paddle/phi/kernels/funcs/beam_search_decode_xpu.h"
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
using CPUPlace = phi::CPUPlace;
|
||||
using XPUPlace = phi::XPUPlace;
|
||||
using LegacyLoD = phi::LegacyLoD;
|
||||
using DenseTensorArray = phi::TensorArray;
|
||||
|
||||
template <typename T>
|
||||
using BeamSearchDecoder = phi::funcs::BeamSearchDecoder<T>;
|
||||
template <typename T>
|
||||
using Sentence = phi::funcs::Sentence<T>;
|
||||
template <typename T>
|
||||
using SentenceVector = phi::funcs::SentenceVector<T>;
|
||||
|
||||
namespace paddle {
|
||||
namespace test {
|
||||
|
||||
template <typename T>
|
||||
void GenerateXPUExample(const std::vector<size_t>& level_0,
|
||||
const std::vector<size_t>& level_1,
|
||||
const std::vector<int>& data,
|
||||
DenseTensorArray* ids,
|
||||
DenseTensorArray* scores) {
|
||||
PADDLE_ENFORCE_EQ(level_0.back(),
|
||||
level_1.size() - 1,
|
||||
common::errors::InvalidArgument(
|
||||
"source level is used to describe candidate set"
|
||||
", so it's element should less than level_1 length. "
|
||||
"And the value of source "
|
||||
"level is %d. ",
|
||||
level_1.size() - 1));
|
||||
PADDLE_ENFORCE_EQ(level_1.back(),
|
||||
data.size(),
|
||||
common::errors::InvalidArgument(
|
||||
"the lowest level is used to describe data"
|
||||
", so it's last element should be data length %d. ",
|
||||
data.size()));
|
||||
|
||||
CPUPlace place;
|
||||
int XPU_PlaceNo = phi::backends::xpu::GetXPUCurrentDeviceId();
|
||||
|
||||
XPUPlace xpu_place(XPU_PlaceNo);
|
||||
|
||||
LegacyLoD lod;
|
||||
lod.push_back(level_0);
|
||||
lod.push_back(level_1);
|
||||
|
||||
// Ids
|
||||
phi::DenseTensor tensor_id_cpu;
|
||||
tensor_id_cpu.set_lod(lod);
|
||||
tensor_id_cpu.Resize({static_cast<int64_t>(data.size())});
|
||||
// malloc memory
|
||||
int64_t* id_cpu_ptr = tensor_id_cpu.mutable_data<int64_t>(place);
|
||||
for (size_t i = 0; i < data.size(); ++i) {
|
||||
id_cpu_ptr[i] = static_cast<int64_t>(data.at(i));
|
||||
}
|
||||
|
||||
phi::DenseTensor tensor_id;
|
||||
const phi::DenseTensorMeta meta_data_id(phi::DataType::INT64,
|
||||
tensor_id_cpu.dims());
|
||||
tensor_id.set_meta(meta_data_id);
|
||||
tensor_id.set_lod(lod);
|
||||
|
||||
int64_t* id_ptr = tensor_id.mutable_data<int64_t>(xpu_place);
|
||||
phi::memory_utils::Copy(phi::XPUPlace(XPU_PlaceNo),
|
||||
id_ptr,
|
||||
phi::CPUPlace(),
|
||||
id_cpu_ptr,
|
||||
tensor_id_cpu.numel() * sizeof(int64_t));
|
||||
|
||||
// Scores
|
||||
phi::DenseTensor tensor_score_cpu;
|
||||
tensor_score_cpu.set_lod(lod);
|
||||
tensor_score_cpu.Resize({static_cast<int64_t>(data.size())});
|
||||
// malloc memory
|
||||
T* score_cpu_ptr = tensor_score_cpu.mutable_data<T>(place);
|
||||
for (size_t i = 0; i < data.size(); ++i) {
|
||||
score_cpu_ptr[i] = static_cast<T>(data.at(i));
|
||||
}
|
||||
|
||||
phi::DenseTensor tensor_score;
|
||||
|
||||
if (std::is_same<float, T>::value) {
|
||||
const phi::DenseTensorMeta meta_data_score(phi::DataType::FLOAT32,
|
||||
tensor_score_cpu.dims());
|
||||
tensor_score.set_meta(meta_data_score);
|
||||
} else if (std::is_same<double, T>::value) {
|
||||
const phi::DenseTensorMeta meta_data_score(phi::DataType::FLOAT64,
|
||||
tensor_score_cpu.dims());
|
||||
tensor_score.set_meta(meta_data_score);
|
||||
} else if (std::is_same<phi::dtype::float16, T>::value) {
|
||||
const phi::DenseTensorMeta meta_data_score(phi::DataType::FLOAT16,
|
||||
tensor_score_cpu.dims());
|
||||
tensor_score.set_meta(meta_data_score);
|
||||
} else if (std::is_same<int, T>::value) {
|
||||
const phi::DenseTensorMeta meta_data_score(phi::DataType::INT32,
|
||||
tensor_score_cpu.dims());
|
||||
tensor_score.set_meta(meta_data_score);
|
||||
} else if (std::is_same<int64_t, T>::value) {
|
||||
const phi::DenseTensorMeta meta_data_score(phi::DataType::INT64,
|
||||
tensor_score_cpu.dims());
|
||||
tensor_score.set_meta(meta_data_score);
|
||||
}
|
||||
|
||||
tensor_score.set_lod(lod);
|
||||
|
||||
T* score_ptr = tensor_score.mutable_data<T>(xpu_place);
|
||||
|
||||
phi::memory_utils::Copy(phi::XPUPlace(XPU_PlaceNo),
|
||||
score_ptr,
|
||||
phi::CPUPlace(),
|
||||
score_cpu_ptr,
|
||||
tensor_score_cpu.numel() * sizeof(T));
|
||||
|
||||
ids->push_back(tensor_id);
|
||||
scores->push_back(tensor_score);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void BeamSearchDecodeTestByXPUFrame() {
|
||||
CPUPlace place;
|
||||
|
||||
// Construct sample data with 5 steps and 2 source sentences
|
||||
// beam_size = 2, start_id = 0, end_id = 1
|
||||
|
||||
DenseTensorArray ids;
|
||||
DenseTensorArray scores;
|
||||
|
||||
GenerateXPUExample<T>(std::vector<size_t>{0, 1, 2},
|
||||
std::vector<size_t>{0, 1, 2},
|
||||
std::vector<int>{0, 0},
|
||||
&ids,
|
||||
&scores); // start with start_id
|
||||
GenerateXPUExample<T>(std::vector<size_t>{0, 1, 2},
|
||||
std::vector<size_t>{0, 2, 4},
|
||||
std::vector<int>{2, 3, 4, 5},
|
||||
&ids,
|
||||
&scores);
|
||||
GenerateXPUExample<T>(std::vector<size_t>{0, 2, 4},
|
||||
std::vector<size_t>{0, 2, 2, 4, 4},
|
||||
std::vector<int>{3, 1, 5, 4},
|
||||
&ids,
|
||||
&scores);
|
||||
GenerateXPUExample<T>(std::vector<size_t>{0, 2, 4},
|
||||
std::vector<size_t>{0, 1, 2, 3, 4},
|
||||
std::vector<int>{1, 1, 3, 5},
|
||||
&ids,
|
||||
&scores);
|
||||
GenerateXPUExample<T>(
|
||||
std::vector<size_t>{0, 2, 4},
|
||||
std::vector<size_t>{0, 0, 0, 2, 2}, // the branches of the first source
|
||||
// sentence are pruned since finished
|
||||
std::vector<int>{5, 1},
|
||||
&ids,
|
||||
&scores);
|
||||
|
||||
ASSERT_EQ(ids.size(), 5UL);
|
||||
ASSERT_EQ(scores.size(), 5UL);
|
||||
|
||||
phi::DenseTensor id_tensor_cpu;
|
||||
phi::DenseTensor score_tensor_cpu;
|
||||
|
||||
phi::funcs::BeamSearchDecodeXPUFunctor bs_xpu(
|
||||
ids, scores, &id_tensor_cpu, &score_tensor_cpu, 2, 1);
|
||||
bs_xpu.apply_xpu<T>();
|
||||
|
||||
LegacyLoD lod = id_tensor_cpu.lod();
|
||||
std::vector<size_t> expect_source_lod = {0, 2, 4};
|
||||
ASSERT_EQ(lod[0], expect_source_lod);
|
||||
|
||||
std::vector<size_t> expect_sentence_lod = {0, 4, 7, 12, 17};
|
||||
ASSERT_EQ(lod[1], expect_sentence_lod);
|
||||
|
||||
std::vector<int> expect_data = {
|
||||
0, 2, 3, 1, 0, 2, 1, 0, 4, 5, 3, 5, 0, 4, 5, 3, 1};
|
||||
ASSERT_EQ(id_tensor_cpu.dims()[0], static_cast<int64_t>(expect_data.size()));
|
||||
|
||||
for (size_t i = 0; i < expect_data.size(); ++i) {
|
||||
ASSERT_EQ(id_tensor_cpu.data<int64_t>()[i],
|
||||
static_cast<int64_t>(expect_data[i]));
|
||||
}
|
||||
|
||||
for (int64_t i = 0; i < id_tensor_cpu.dims()[0]; ++i) {
|
||||
ASSERT_EQ(score_tensor_cpu.data<T>()[i],
|
||||
static_cast<T>(id_tensor_cpu.data<int64_t>()[i]));
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace test
|
||||
} // namespace paddle
|
||||
|
||||
TEST(BeamSearchDecodeOpXPU, Backtrace_XPU_Float) {
|
||||
paddle::test::BeamSearchDecodeTestByXPUFrame<float>();
|
||||
}
|
||||
|
||||
TEST(BeamSearchDecodeOpXPU, Backtrace_XPU_Float16) {
|
||||
paddle::test::BeamSearchDecodeTestByXPUFrame<phi::dtype::float16>();
|
||||
}
|
||||
|
||||
TEST(BeamSearchDecodeOpXPU, Backtrace_XPU_Int) {
|
||||
paddle::test::BeamSearchDecodeTestByXPUFrame<int>();
|
||||
}
|
||||
|
||||
TEST(BeamSearchDecodeOpXPU, Backtrace_XPU_Int64) {
|
||||
paddle::test::BeamSearchDecodeTestByXPUFrame<int64_t>();
|
||||
}
|
||||
|
||||
TEST(BeamSearchDecodeOpXPU, Backtrace_XPU_Double) {
|
||||
paddle::test::BeamSearchDecodeTestByXPUFrame<double>();
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
/* 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. */
|
||||
|
||||
#include "paddle/phi/backends/xpu/enforce_xpu.h"
|
||||
|
||||
#include "glog/logging.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
template <typename T>
|
||||
bool CheckXPUStatusSuccess(T value, const std::string& msg = "success") {
|
||||
PADDLE_ENFORCE_XPU_SUCCESS(value);
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
bool CheckXPUStatusFailure(T value, const std::string& msg) {
|
||||
try {
|
||||
PADDLE_ENFORCE_XPU_SUCCESS(value);
|
||||
return false;
|
||||
} catch (common::enforce::EnforceNotMet& error) {
|
||||
std::string ex_msg = error.what();
|
||||
VLOG(0) << ex_msg << std::endl;
|
||||
return ex_msg.find(msg) != std::string::npos;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef PADDLE_WITH_XPU_BKCL
|
||||
template <typename T>
|
||||
bool CheckBKCLStatusSuccess(T value, const std::string& msg = "success") {
|
||||
PADDLE_ENFORCE_BKCL_SUCCESS(value);
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
bool CheckBKCLStatusFailure(T value, const std::string& msg) {
|
||||
try {
|
||||
PADDLE_ENFORCE_BKCL_SUCCESS(value);
|
||||
return false;
|
||||
} catch (common::enforce::EnforceNotMet& error) {
|
||||
std::string ex_msg = error.what();
|
||||
VLOG(0) << ex_msg << std::endl;
|
||||
return ex_msg.find(msg) != std::string::npos;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
template <typename T>
|
||||
bool CheckXDNNStatusSuccess(T value, const std::string& msg = "success") {
|
||||
PADDLE_ENFORCE_XDNN_SUCCESS(value, "XDNN Error Test");
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
bool CheckXDNNStatusFailure(T value, const std::string& msg) {
|
||||
try {
|
||||
PADDLE_ENFORCE_XDNN_SUCCESS(value, "XDNN Error Test");
|
||||
return false;
|
||||
} catch (common::enforce::EnforceNotMet& error) {
|
||||
std::string ex_msg = error.what();
|
||||
VLOG(0) << ex_msg << std::endl;
|
||||
return ex_msg.find(msg) != std::string::npos;
|
||||
}
|
||||
}
|
||||
|
||||
TEST(enforce, xpu_status) {
|
||||
EXPECT_TRUE(CheckXPUStatusSuccess(static_cast<int>(XPU_SUCCESS)));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_INVALID_DEVICE),
|
||||
"Invalid XPU device"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_UNINIT),
|
||||
"XPU runtime not properly inited"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_NOMEM),
|
||||
"Device memory not enough"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_NOCPUMEM),
|
||||
"CPU memory not enough"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_INVALID_PARAM),
|
||||
"Invalid parameter"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_NOXPUFUNC),
|
||||
"Cannot get XPU Func"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_LDSO),
|
||||
"Error loading dynamic library"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_LDSYM),
|
||||
"Error loading func from dynamic library"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_SIMULATOR),
|
||||
"Error from XPU Simulator"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_NOSUPPORT),
|
||||
"Operation not supported"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_ABNORMAL),
|
||||
"Device abnormal due to previous error"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_KEXCEPTION),
|
||||
"Exception in kernel execution"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_TIMEOUT),
|
||||
"Kernel execution timed out"));
|
||||
EXPECT_TRUE(
|
||||
CheckXPUStatusFailure(static_cast<int>(XPUERR_BUSY), "Resource busy"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_USEAFCLOSE),
|
||||
"Use a stream after closed"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_UCECC),
|
||||
"Uncorrectable ECC"));
|
||||
EXPECT_TRUE(
|
||||
CheckXPUStatusFailure(static_cast<int>(XPUERR_OVERHEAT), "Overheat"));
|
||||
EXPECT_TRUE(
|
||||
CheckXPUStatusFailure(static_cast<int>(XPUERR_UNEXPECT),
|
||||
"Execution error, reach unexpected control flow"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_DEVRESET),
|
||||
"Device is being reset, try again later"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_HWEXCEPTION),
|
||||
"Hardware module exception"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_HBM_INIT),
|
||||
"Error init HBM"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_DEVINIT),
|
||||
"Error init device"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_PEERRESET),
|
||||
"Device is being reset, try again later"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_MAXDEV),
|
||||
"Device count exceed limit"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_NOIOC),
|
||||
"Unknown IOCTL command"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_DMATIMEOUT),
|
||||
"DMA timed out, a reboot maybe needed"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(
|
||||
static_cast<int>(XPUERR_DMAABORT),
|
||||
"DMA aborted due to error, possibly wrong address or hardware state"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_MCUUNINIT),
|
||||
"Firmware not initialized"));
|
||||
EXPECT_TRUE(
|
||||
CheckXPUStatusFailure(static_cast<int>(XPUERR_OLDFW),
|
||||
"Firmware version too old (<15), please update."));
|
||||
EXPECT_TRUE(
|
||||
CheckXPUStatusFailure(static_cast<int>(XPUERR_PCIE), "Error in PCIE"));
|
||||
EXPECT_TRUE(
|
||||
CheckXPUStatusFailure(static_cast<int>(XPUERR_FAULT),
|
||||
"Error copy between kernel and user space"));
|
||||
EXPECT_TRUE(CheckXPUStatusFailure(static_cast<int>(XPUERR_INTERRUPTED),
|
||||
"Execution interrupted by user"));
|
||||
}
|
||||
|
||||
#ifdef PADDLE_WITH_XPU_BKCL
|
||||
TEST(enforce, bkcl_status) {
|
||||
EXPECT_TRUE(CheckBKCLStatusSuccess(BKCL_SUCCESS));
|
||||
EXPECT_TRUE(
|
||||
CheckBKCLStatusFailure(BKCL_INVALID_ARGUMENT, "BKCL_INVALID_ARGUMENT"));
|
||||
EXPECT_TRUE(CheckBKCLStatusFailure(BKCL_RUNTIME_ERROR, "BKCL_RUNTIME_ERROR"));
|
||||
EXPECT_TRUE(CheckBKCLStatusFailure(BKCL_SYSTEM_ERROR, "BKCL_SYSTEM_ERROR"));
|
||||
EXPECT_TRUE(
|
||||
CheckBKCLStatusFailure(BKCL_INTERNAL_ERROR, "BKCL_INTERNAL_ERROR"));
|
||||
}
|
||||
#endif
|
||||
|
||||
TEST(enforce, xdnn_status) {
|
||||
EXPECT_TRUE(CheckXDNNStatusSuccess(xpu::Error_t::SUCCESS));
|
||||
EXPECT_TRUE(CheckXDNNStatusFailure(xpu::Error_t::INVALID_PARAM,
|
||||
"XDNN_INVALID_PARAM"));
|
||||
EXPECT_TRUE(CheckXDNNStatusFailure(xpu::Error_t::RUNTIME_ERROR,
|
||||
"XDNN_RUNTIME_ERROR"));
|
||||
EXPECT_TRUE(CheckXDNNStatusFailure(xpu::Error_t::NO_ENOUGH_WORKSPACE,
|
||||
"XDNN_NO_ENOUGH_WORKSPACE"));
|
||||
EXPECT_TRUE(CheckXDNNStatusFailure(xpu::Error_t::NOT_IMPLEMENT,
|
||||
"XDNN_NOT_IMPLEMENT"));
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
// Copyright (c) 2024 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 "paddle/phi/backends/xpu/enforce_xpu.h"
|
||||
#include "paddle/phi/backends/xpu/xpu_context.h"
|
||||
#include "paddle/phi/core/memory/allocation/allocator.h"
|
||||
#include "paddle/phi/core/memory/stats.h"
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace memory {
|
||||
TEST(XPUOverloadAllocTest, EnvTest) {
|
||||
setenv("XPUAPI_DEFAULT_SIZE", "4096", 1);
|
||||
// use alloc overload
|
||||
unsetenv("XPU_PADDLE_DISABLE_ALLOC_OVERLOAD");
|
||||
phi::XPUContext dev_ctx_overload(
|
||||
phi::XPUPlace(phi::backends::xpu::GetXPUCurrentDeviceId()));
|
||||
EXPECT_STREQ(dev_ctx_overload.x_context()->get_option("XPUAPI_DEFAULT_SIZE"),
|
||||
"1");
|
||||
EXPECT_NE(dev_ctx_overload.x_context()->overload_alloc_gm, nullptr);
|
||||
// do not use alloc overload
|
||||
setenv("XPU_PADDLE_DISABLE_ALLOC_OVERLOAD", "1", 1);
|
||||
phi::XPUContext dev_ctx_origin(
|
||||
phi::XPUPlace(phi::backends::xpu::GetXPUCurrentDeviceId()));
|
||||
EXPECT_STREQ(dev_ctx_origin.x_context()->get_option("XPUAPI_DEFAULT_SIZE"),
|
||||
"4096");
|
||||
EXPECT_EQ(dev_ctx_origin.x_context()->overload_alloc_gm, nullptr);
|
||||
unsetenv("XPU_PADDLE_DISABLE_ALLOC_OVERLOAD");
|
||||
unsetenv("XPUAPI_DEFAULT_SIZE");
|
||||
}
|
||||
|
||||
TEST(XPUOverloadAllocTest, BasicTest) {
|
||||
phi::XPUContext dev_ctx(
|
||||
phi::XPUPlace(phi::backends::xpu::GetXPUCurrentDeviceId()));
|
||||
int numel = 64;
|
||||
int alignment = phi::backends::xpu::XPUMinChunkSize();
|
||||
int expected_alloc_size =
|
||||
allocation::AlignedSize(numel * sizeof(int), alignment);
|
||||
xpu::ctx_guard RAII_GUARD(dev_ctx.x_context());
|
||||
int pre_alloc_value = DEVICE_MEMORY_STAT_CURRENT_VALUE(
|
||||
Allocated, dev_ctx.GetPlace().GetDeviceId());
|
||||
int* buffer = RAII_GUARD.alloc<int>(numel);
|
||||
int after_alloc_value = DEVICE_MEMORY_STAT_CURRENT_VALUE(
|
||||
Allocated, dev_ctx.GetPlace().GetDeviceId());
|
||||
EXPECT_NE(buffer, nullptr);
|
||||
EXPECT_EQ(after_alloc_value - pre_alloc_value, expected_alloc_size);
|
||||
}
|
||||
|
||||
TEST(XPUOverloadAllocTest, NestedScopeTest) {
|
||||
phi::XPUContext dev_ctx(
|
||||
phi::XPUPlace(phi::backends::xpu::GetXPUCurrentDeviceId()));
|
||||
xpu::ctx_guard RAII_GUARD1(dev_ctx.x_context());
|
||||
int pre_alloc_value = DEVICE_MEMORY_STAT_CURRENT_VALUE(
|
||||
Allocated, dev_ctx.GetPlace().GetDeviceId());
|
||||
int* buffer_outer = RAII_GUARD1.alloc<int>(64);
|
||||
EXPECT_NE(buffer_outer, nullptr);
|
||||
{
|
||||
// The destruction of inner guard should not free the memory allocated from
|
||||
// outer guard.
|
||||
xpu::ctx_guard RAII_GUARD2(dev_ctx.x_context());
|
||||
int* buffer_inner = RAII_GUARD2.alloc<int>(64);
|
||||
EXPECT_NE(buffer_inner, nullptr);
|
||||
}
|
||||
int post_alloc_value = DEVICE_MEMORY_STAT_CURRENT_VALUE(
|
||||
Allocated, dev_ctx.GetPlace().GetDeviceId());
|
||||
EXPECT_NE(post_alloc_value, pre_alloc_value);
|
||||
}
|
||||
|
||||
TEST(XPUOverloadAllocTest, MultiStreamTest) {
|
||||
// Test whether stream 1 use the memory poll of stream 0.
|
||||
int size = 64;
|
||||
setenv("XPU_CDNN_CLUSTER_PARALLEL", "1", 1);
|
||||
phi::XPUContext dev_ctx(
|
||||
phi::XPUPlace(phi::backends::xpu::GetXPUCurrentDeviceId()));
|
||||
xpu::ctx_guard RAII_GUARD0(dev_ctx.x_context(0));
|
||||
xpu::ctx_guard RAII_GUARD1(dev_ctx.x_context(1));
|
||||
int pre_alloc_value = DEVICE_MEMORY_STAT_CURRENT_VALUE(
|
||||
Allocated, dev_ctx.GetPlace().GetDeviceId());
|
||||
int* buffer0 = RAII_GUARD1.alloc<int>(size);
|
||||
EXPECT_NE(buffer0, nullptr);
|
||||
{
|
||||
int* buffer1 = RAII_GUARD0.alloc<int>(size);
|
||||
EXPECT_NE(buffer1, nullptr);
|
||||
}
|
||||
int post_alloc_value = DEVICE_MEMORY_STAT_CURRENT_VALUE(
|
||||
Allocated, dev_ctx.GetPlace().GetDeviceId());
|
||||
|
||||
EXPECT_NE(pre_alloc_value, post_alloc_value);
|
||||
unsetenv("XPU_CDNN_CLUSTER_PARALLEL");
|
||||
}
|
||||
} // namespace memory
|
||||
} // namespace paddle
|
||||
Reference in New Issue
Block a user