From a81b63beef16c19e545bb1469d49f895e35c3036 Mon Sep 17 00:00:00 2001 From: Krzysztof Swiecicki Date: Wed, 6 Sep 2023 14:43:05 +0200 Subject: [PATCH] Add pool manager tests --- test/usm/CMakeLists.txt | 6 ++- test/usm/pool.hpp | 79 +++++++++++++++++++++++++++++++++++++ test/usm/usmPoolManager.cpp | 47 ++++++++++++++++++++-- 3 files changed, 127 insertions(+), 5 deletions(-) create mode 100644 test/usm/pool.hpp diff --git a/test/usm/CMakeLists.txt b/test/usm/CMakeLists.txt index b673b6d1b9..3496328ce9 100644 --- a/test/usm/CMakeLists.txt +++ b/test/usm/CMakeLists.txt @@ -17,10 +17,12 @@ function(add_usm_test name) ${PROJECT_NAME}::loader ur_testing GTest::gtest_main) - add_test(NAME usm-${name} + add_test(NAME usm-${name} COMMAND ${TEST_TARGET_NAME} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) - set_tests_properties(usm-${name} PROPERTIES LABELS "usm") + set_tests_properties(usm-${name} PROPERTIES + LABELS "usm" + ENVIRONMENT "UR_ADAPTERS_FORCE_LOAD=\"$\"") target_compile_definitions("usm_test-${name}" PRIVATE DEVICES_ENVIRONMENT) endfunction() diff --git a/test/usm/pool.hpp b/test/usm/pool.hpp new file mode 100644 index 0000000000..6f1b50b646 --- /dev/null +++ b/test/usm/pool.hpp @@ -0,0 +1,79 @@ +/* + * + * Copyright (C) 2023 Intel Corporation + * + * Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions. + * See LICENSE.TXT + * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + * + */ + +#ifndef USM_TEST_POOL_HPP +#define USM_TEST_POOL_HPP 1 + +#include + +#include +#include + +#include "umf_helpers.hpp" + +namespace usm_test { + +struct null_provider { + umf_result_t initialize() noexcept { return UMF_RESULT_SUCCESS; }; + enum umf_result_t alloc(size_t, size_t, void **) noexcept { + return UMF_RESULT_SUCCESS; + } + enum umf_result_t free(void *, size_t) noexcept { + return UMF_RESULT_SUCCESS; + } + enum umf_result_t get_recommended_page_size(size_t, size_t *) noexcept { + return UMF_RESULT_SUCCESS; + } + enum umf_result_t get_min_page_size(void *, size_t *) noexcept { + return UMF_RESULT_SUCCESS; + } + enum umf_result_t purge_lazy(void *, size_t) noexcept { + return UMF_RESULT_SUCCESS; + } + enum umf_result_t purge_force(void *, size_t) noexcept { + return UMF_RESULT_SUCCESS; + } + void get_last_native_error(const char **, int32_t *) noexcept {} + const char *get_name() noexcept { return "null"; } +}; + +umf::provider_unique_handle_t nullProviderCreate() { + auto [ret, provider] = umf::memoryProviderMakeUnique(); + EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + + return std::move(provider); +} + +struct null_pool { + umf_result_t initialize(umf_memory_provider_handle_t *, size_t) noexcept { + return UMF_RESULT_SUCCESS; + }; + void *malloc(size_t) noexcept { return nullptr; } + void *calloc(size_t, size_t) noexcept { return nullptr; } + void *realloc(void *, size_t) noexcept { return nullptr; } + void *aligned_malloc(size_t, size_t) noexcept { return nullptr; } + enum umf_result_t free(void *) noexcept { return UMF_RESULT_SUCCESS; } + size_t malloc_usable_size(void *) noexcept { return 0; } + enum umf_result_t get_last_allocation_error() noexcept { + return UMF_RESULT_SUCCESS; + } +}; + +umf::pool_unique_handle_t +nullPoolCreate(umf_memory_provider_handle_t *provider) { + auto [ret, pool] = umf::poolMakeUnique(provider, 1); + EXPECT_EQ(ret, UMF_RESULT_SUCCESS); + + return std::move(pool); +} + +} // namespace usm_test + +#endif /* USM_TEST_POOL_HPP */ diff --git a/test/usm/usmPoolManager.cpp b/test/usm/usmPoolManager.cpp index eaf44e119d..39aa0b6767 100644 --- a/test/usm/usmPoolManager.cpp +++ b/test/usm/usmPoolManager.cpp @@ -5,17 +5,20 @@ #include "../unified_malloc_framework/common/pool.hpp" #include "../unified_malloc_framework/common/provider.hpp" +#include "pool.hpp" + #include "ur_pool_manager.hpp" #include +#include #include -struct urUsmPoolManagerTest +struct urUsmPoolDescriptorTest : public uur::urMultiDeviceContextTest, ::testing::WithParamInterface {}; -TEST_P(urUsmPoolManagerTest, poolIsPerContextTypeAndDevice) { +TEST_P(urUsmPoolDescriptorTest, poolIsPerContextTypeAndDevice) { auto &devices = uur::DevicesEnvironment::instance->devices; auto poolHandle = this->GetParam(); @@ -49,7 +52,45 @@ TEST_P(urUsmPoolManagerTest, poolIsPerContextTypeAndDevice) { ASSERT_EQ(sharedPools, devices.size() * 2); } -INSTANTIATE_TEST_SUITE_P(urUsmPoolManagerTest, urUsmPoolManagerTest, +INSTANTIATE_TEST_SUITE_P(urUsmPoolDescriptorTest, urUsmPoolDescriptorTest, ::testing::Values(nullptr)); // TODO: add test with sub-devices + +struct urUsmPoolManagerTest : public uur::urContextTest { + void SetUp() override { + UUR_RETURN_ON_FATAL_FAILURE(urContextTest::SetUp()); + auto [ret, descs] = usm::pool_descriptor::create(nullptr, context); + ASSERT_EQ(ret, UR_RESULT_SUCCESS); + poolDescriptors = descs; + } + + std::vector poolDescriptors; +}; + +TEST_P(urUsmPoolManagerTest, poolManagerPopulate) { + constexpr size_t seed = 0xC0FFEE; + srand(seed); + + auto [ret, manager] = usm::pool_manager::create(); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + + for (auto &desc : poolDescriptors) { + // Populate the pool manager + auto providerUnique = usm_test::nullProviderCreate(); + auto provider = providerUnique.get(); + auto poolUnique = usm_test::nullPoolCreate(&provider); + ASSERT_NE(poolUnique, nullptr); + ret = manager.addPool(desc, poolUnique); + ASSERT_EQ(ret, UMF_RESULT_SUCCESS); + } + + for (auto &desc : poolDescriptors) { + // Confirm that there is a pool for each descriptor + auto hPoolOpt = manager.getPool(desc); + ASSERT_TRUE(hPoolOpt.has_value()); + ASSERT_NE(hPoolOpt.value(), nullptr); + } +} + +UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urUsmPoolManagerTest);