Skip to content

do not use global ctor/dtor for test params #1055

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Jan 24, 2025
+442 −286
Merged

do not use global ctor/dtor for test params #1055

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
7 changes: 4 additions & 3 deletions test/ipcAPI.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
// Copyright (C) 2023-2024 Intel Corporation
// Copyright (C) 2023-2025 Intel Corporation
// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// This file contains tests for UMF pool API
Expand Down Expand Up @@ -115,5 +115,6 @@ HostMemoryAccessor hostMemoryAccessor;

INSTANTIATE_TEST_SUITE_P(umfIpcTestSuite, umfIpcTest,
::testing::Values(ipcTestParams{
umfProxyPoolOps(), nullptr, &IPC_MOCK_PROVIDER_OPS,
nullptr, &hostMemoryAccessor}));
umfProxyPoolOps(), nullptr, nullptr,
&IPC_MOCK_PROVIDER_OPS, nullptr, nullptr,
&hostMemoryAccessor}));
53 changes: 44 additions & 9 deletions test/ipcFixtures.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
// Copyright (C) 2024 Intel Corporation
// Copyright (C) 2024-2025 Intel Corporation
// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

Expand Down Expand Up @@ -46,23 +46,36 @@ class HostMemoryAccessor : public MemoryAccessor {
}
};

typedef void *(*pfnPoolParamsCreate)();
typedef umf_result_t (*pfnPoolParamsDestroy)(void *);

typedef void *(*pfnProviderParamsCreate)();
typedef umf_result_t (*pfnProviderParamsDestroy)(void *);

// ipcTestParams:
// pool_ops, pool_params, provider_ops, provider_params, memoryAccessor
// pool_ops, pfnPoolParamsCreate,pfnPoolParamsDestroy,
// provider_ops, pfnProviderParamsCreate, pfnProviderParamsDestroy,
// memoryAccessor
using ipcTestParams =
std::tuple<umf_memory_pool_ops_t *, void *, umf_memory_provider_ops_t *,
void *, MemoryAccessor *>;
std::tuple<umf_memory_pool_ops_t *, pfnPoolParamsCreate,
pfnPoolParamsDestroy, umf_memory_provider_ops_t *,
pfnProviderParamsCreate, pfnProviderParamsDestroy,
MemoryAccessor *>;

struct umfIpcTest : umf_test::test,
::testing::WithParamInterface<ipcTestParams> {
umfIpcTest() {}
void SetUp() override {
test::SetUp();
auto [pool_ops, pool_params, provider_ops, provider_params, accessor] =
auto [pool_ops, pool_params_create, pool_params_destroy, provider_ops,
provider_params_create, provider_params_destroy, accessor] =
this->GetParam();
poolOps = pool_ops;
poolParams = pool_params;
poolParamsCreate = pool_params_create;
poolParamsDestroy = pool_params_destroy;
providerOps = provider_ops;
providerParams = provider_params;
providerParamsCreate = provider_params_create;
providerParamsDestroy = provider_params_destroy;
memAccessor = accessor;
}

Expand All @@ -74,10 +87,19 @@ struct umfIpcTest : umf_test::test,
umf_memory_provider_handle_t hProvider = NULL;
umf_memory_pool_handle_t hPool = NULL;

void *providerParams = nullptr;
if (providerParamsCreate) {
providerParams = providerParamsCreate();
}

auto ret =
umfMemoryProviderCreate(providerOps, providerParams, &hProvider);
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);

if (providerParamsDestroy) {
providerParamsDestroy(providerParams);
}

auto trace = [](void *trace_context, const char *name) {
stats_type *stat = static_cast<stats_type *>(trace_context);
if (std::strcmp(name, "alloc") == 0) {
Expand All @@ -96,10 +118,19 @@ struct umfIpcTest : umf_test::test,
umf_memory_provider_handle_t hTraceProvider =
traceProviderCreate(hProvider, true, (void *)&stat, trace);

void *poolParams = nullptr;
if (poolParamsCreate) {
poolParams = poolParamsCreate();
}

ret = umfPoolCreate(poolOps, hTraceProvider, poolParams,
UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &hPool);
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);

if (poolParamsDestroy) {
poolParamsDestroy(poolParams);
}

return umf::pool_unique_handle_t(hPool, &umfPoolDestroy);
}

Expand All @@ -118,10 +149,14 @@ struct umfIpcTest : umf_test::test,
static constexpr int NTHREADS = 10;
stats_type stat;
MemoryAccessor *memAccessor = nullptr;

umf_memory_pool_ops_t *poolOps = nullptr;
void *poolParams = nullptr;
pfnPoolParamsCreate poolParamsCreate = nullptr;
pfnPoolParamsDestroy poolParamsDestroy = nullptr;

umf_memory_provider_ops_t *providerOps = nullptr;
void *providerParams = nullptr;
pfnProviderParamsCreate providerParamsCreate = nullptr;
pfnProviderParamsDestroy providerParamsDestroy = nullptr;
};

TEST_P(umfIpcTest, GetIPCHandleSize) {
Expand Down
16 changes: 9 additions & 7 deletions test/memoryPoolAPI.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
// Copyright (C) 2023-2024 Intel Corporation
// Copyright (C) 2023-2025 Intel Corporation
// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// This file contains tests for UMF pool API
Expand Down Expand Up @@ -295,15 +295,17 @@ TEST_F(tagTest, SetAndGetInvalidPool) {

INSTANTIATE_TEST_SUITE_P(
mallocPoolTest, umfPoolTest,
::testing::Values(poolCreateExtParams{&MALLOC_POOL_OPS, nullptr,
&UMF_NULL_PROVIDER_OPS, nullptr},
poolCreateExtParams{umfProxyPoolOps(), nullptr,
&BA_GLOBAL_PROVIDER_OPS, nullptr}));
::testing::Values(poolCreateExtParams{&MALLOC_POOL_OPS, nullptr, nullptr,
&UMF_NULL_PROVIDER_OPS, nullptr,
nullptr},
poolCreateExtParams{umfProxyPoolOps(), nullptr, nullptr,
&BA_GLOBAL_PROVIDER_OPS, nullptr,
nullptr}));

INSTANTIATE_TEST_SUITE_P(mallocMultiPoolTest, umfMultiPoolTest,
::testing::Values(poolCreateExtParams{
umfProxyPoolOps(), nullptr,
&BA_GLOBAL_PROVIDER_OPS, nullptr}));
umfProxyPoolOps(), nullptr, nullptr,
&BA_GLOBAL_PROVIDER_OPS, nullptr, nullptr}));

INSTANTIATE_TEST_SUITE_P(umfPoolWithCreateFlagsTest, umfPoolWithCreateFlagsTest,
::testing::Values(0,
Expand Down
35 changes: 32 additions & 3 deletions test/poolFixtures.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,29 +19,58 @@

#include "../malloc_compliance_tests.hpp"

using poolCreateExtParams = std::tuple<umf_memory_pool_ops_t *, void *,
umf_memory_provider_ops_t *, void *>;
typedef void *(*pfnPoolParamsCreate)();
typedef umf_result_t (*pfnPoolParamsDestroy)(void *);

typedef void *(*pfnProviderParamsCreate)();
typedef umf_result_t (*pfnProviderParamsDestroy)(void *);

using poolCreateExtParams =
std::tuple<umf_memory_pool_ops_t *, pfnPoolParamsCreate,
pfnPoolParamsDestroy, umf_memory_provider_ops_t *,
pfnProviderParamsCreate, pfnProviderParamsDestroy>;

umf::pool_unique_handle_t poolCreateExtUnique(poolCreateExtParams params) {
auto [pool_ops, pool_params, provider_ops, provider_params] = params;
auto [pool_ops, poolParamsCreate, poolParamsDestroy, provider_ops,
providerParamsCreate, providerParamsDestroy] = params;

umf_memory_provider_handle_t upstream_provider = nullptr;
umf_memory_provider_handle_t provider = nullptr;
umf_memory_pool_handle_t hPool = nullptr;
umf_result_t ret;

void *provider_params = NULL;
if (providerParamsCreate) {
provider_params = providerParamsCreate();
}
ret = umfMemoryProviderCreate(provider_ops, provider_params,
&upstream_provider);
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
EXPECT_NE(upstream_provider, nullptr);

provider = upstream_provider;

void *pool_params = NULL;
if (poolParamsCreate) {
pool_params = poolParamsCreate();
}

// NOTE: we set the UMF_POOL_CREATE_FLAG_OWN_PROVIDER flag here so the pool
// will destroy the provider when it is destroyed
ret = umfPoolCreate(pool_ops, provider, pool_params,
UMF_POOL_CREATE_FLAG_OWN_PROVIDER, &hPool);
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
EXPECT_NE(hPool, nullptr);

// we do not need params anymore
if (poolParamsDestroy) {
poolParamsDestroy(pool_params);
}

if (providerParamsDestroy) {
providerParamsDestroy(provider_params);
}

return umf::pool_unique_handle_t(hPool, &umfPoolDestroy);
}

Expand Down
74 changes: 41 additions & 33 deletions test/pools/disjoint_pool.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
// Copyright (C) 2023-2024 Intel Corporation
// Copyright (C) 2023-2025 Intel Corporation
// Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

Expand All @@ -11,16 +11,12 @@
#include "provider_null.h"
#include "provider_trace.h"

using disjoint_params_unique_handle_t =
std::unique_ptr<umf_disjoint_pool_params_t,
decltype(&umfDisjointPoolParamsDestroy)>;

static constexpr size_t DEFAULT_DISJOINT_SLAB_MIN_SIZE = 4096;
static constexpr size_t DEFAULT_DISJOINT_MAX_POOLABLE_SIZE = 4096;
static constexpr size_t DEFAULT_DISJOINT_CAPACITY = 4;
static constexpr size_t DEFAULT_DISJOINT_MIN_BUCKET_SIZE = 64;

disjoint_params_unique_handle_t poolConfig() {
void *defaultPoolConfig() {
umf_disjoint_pool_params_handle_t config = nullptr;
umf_result_t res = umfDisjointPoolParamsCreate(&config);
if (res != UMF_RESULT_SUCCESS) {
Expand Down Expand Up @@ -50,8 +46,12 @@ disjoint_params_unique_handle_t poolConfig() {
throw std::runtime_error("Failed to set min bucket size");
}

return disjoint_params_unique_handle_t(config,
&umfDisjointPoolParamsDestroy);
return config;
}

umf_result_t poolConfigDestroy(void *config) {
return umfDisjointPoolParamsDestroy(
static_cast<umf_disjoint_pool_params_handle_t>(config));
}

using umf_test::test;
Expand Down Expand Up @@ -83,17 +83,21 @@ TEST_F(test, freeErrorPropagation) {
provider_handle = providerUnique.get();

// force all allocations to go to memory provider
disjoint_params_unique_handle_t params = poolConfig();
umf_result_t retp =
umfDisjointPoolParamsSetMaxPoolableSize(params.get(), 0);
umf_disjoint_pool_params_handle_t params;
umf_result_t retp = umfDisjointPoolParamsCreate(&params);
EXPECT_EQ(retp, UMF_RESULT_SUCCESS);
retp = umfDisjointPoolParamsSetMaxPoolableSize(params, 0);
EXPECT_EQ(retp, UMF_RESULT_SUCCESS);

umf_memory_pool_handle_t pool = NULL;
retp = umfPoolCreate(umfDisjointPoolOps(), provider_handle, params.get(), 0,
&pool);
retp =
umfPoolCreate(umfDisjointPoolOps(), provider_handle, params, 0, &pool);
EXPECT_EQ(retp, UMF_RESULT_SUCCESS);
auto poolHandle = umf_test::wrapPoolUnique(pool);

retp = umfDisjointPoolParamsDestroy(params);
EXPECT_EQ(retp, UMF_RESULT_SUCCESS);

static constexpr size_t size = 1024;
void *ptr = umfPoolMalloc(pool, size);

Expand All @@ -114,12 +118,12 @@ TEST_F(test, sharedLimits) {

struct memory_provider : public umf_test::provider_base_t {
umf_result_t alloc(size_t size, size_t, void **ptr) noexcept {
*ptr = malloc(size);
*ptr = umf_ba_global_alloc(size);
numAllocs++;
return UMF_RESULT_SUCCESS;
}
umf_result_t free(void *ptr, [[maybe_unused]] size_t size) noexcept {
::free(ptr);
umf_ba_global_free(ptr);
numFrees++;
return UMF_RESULT_SUCCESS;
}
Expand All @@ -130,9 +134,9 @@ TEST_F(test, sharedLimits) {
static constexpr size_t SlabMinSize = 1024;
static constexpr size_t MaxSize = 4 * SlabMinSize;

disjoint_params_unique_handle_t config = poolConfig();
umf_result_t ret =
umfDisjointPoolParamsSetSlabMinSize(config.get(), SlabMinSize);
umf_disjoint_pool_params_handle_t params =
(umf_disjoint_pool_params_handle_t)defaultPoolConfig();
umf_result_t ret = umfDisjointPoolParamsSetSlabMinSize(params, SlabMinSize);
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);

auto limits =
Expand All @@ -141,24 +145,27 @@ TEST_F(test, sharedLimits) {
umfDisjointPoolSharedLimitsCreate(MaxSize),
&umfDisjointPoolSharedLimitsDestroy);

ret = umfDisjointPoolParamsSetSharedLimits(config.get(), limits.get());
ret = umfDisjointPoolParamsSetSharedLimits(params, limits.get());
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);

auto provider =
wrapProviderUnique(createProviderChecked(&provider_ops, nullptr));

umf_memory_pool_handle_t pool1 = NULL;
umf_memory_pool_handle_t pool2 = NULL;
ret = umfPoolCreate(umfDisjointPoolOps(), provider.get(),
(void *)config.get(), 0, &pool1);
ret =
umfPoolCreate(umfDisjointPoolOps(), provider.get(), params, 0, &pool1);
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
auto poolHandle1 = umf_test::wrapPoolUnique(pool1);

ret = umfPoolCreate(umfDisjointPoolOps(), provider.get(),
(void *)config.get(), 0, &pool2);
ret =
umfPoolCreate(umfDisjointPoolOps(), provider.get(), params, 0, &pool2);
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
auto poolHandle2 = umf_test::wrapPoolUnique(pool2);

ret = umfDisjointPoolParamsDestroy(params);
EXPECT_EQ(ret, UMF_RESULT_SUCCESS);

EXPECT_EQ(0, numAllocs);
EXPECT_EQ(0, numFrees);

Expand Down Expand Up @@ -243,23 +250,24 @@ TEST_F(test, disjointPoolInvalidBucketSize) {
umfDisjointPoolParamsDestroy(params);
}

disjoint_params_unique_handle_t defaultPoolConfig = poolConfig();
INSTANTIATE_TEST_SUITE_P(disjointPoolTests, umfPoolTest,
::testing::Values(poolCreateExtParams{
umfDisjointPoolOps(),
(void *)defaultPoolConfig.get(),
&BA_GLOBAL_PROVIDER_OPS, nullptr}));
umfDisjointPoolOps(), defaultPoolConfig,
poolConfigDestroy, &BA_GLOBAL_PROVIDER_OPS,
nullptr, nullptr}));

void *memProviderParams() { return (void *)&DEFAULT_DISJOINT_CAPACITY; }

INSTANTIATE_TEST_SUITE_P(
disjointPoolTests, umfMemTest,
::testing::Values(std::make_tuple(
poolCreateExtParams{
umfDisjointPoolOps(), (void *)defaultPoolConfig.get(),
&MOCK_OUT_OF_MEM_PROVIDER_OPS, (void *)&DEFAULT_DISJOINT_CAPACITY},
poolCreateExtParams{umfDisjointPoolOps(), defaultPoolConfig,
poolConfigDestroy, &MOCK_OUT_OF_MEM_PROVIDER_OPS,
memProviderParams, nullptr},
static_cast<int>(DEFAULT_DISJOINT_CAPACITY) / 2)));

INSTANTIATE_TEST_SUITE_P(disjointMultiPoolTests, umfMultiPoolTest,
::testing::Values(poolCreateExtParams{
umfDisjointPoolOps(),
(void *)defaultPoolConfig.get(),
&BA_GLOBAL_PROVIDER_OPS, nullptr}));
umfDisjointPoolOps(), defaultPoolConfig,
poolConfigDestroy, &BA_GLOBAL_PROVIDER_OPS,
nullptr, nullptr}));
Loading
Loading