Debian Codegraph @

offload/unittests/OffloadAPI/memory/olGetMemInfo.cpp

raw
1 //===------- Offload API tests - olGetMemInfo -----------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "../common/Fixtures.hpp"
10 #include <OffloadAPI.h>
11 #include <gtest/gtest.h>
12
13 constexpr size_t SIZE = 1024;
14
15 struct olGetMemInfoBaseTest : OffloadDeviceTest {
16 void *OffsetPtr() { return &reinterpret_cast<char *>(Ptr)[123]; }
17
18 void *Ptr;
19 };
20
21 template <ol_alloc_type_t AllocType>
22 struct olGetMemInfoTest : olGetMemInfoBaseTest {
23 void SetUp() override {
24 RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::SetUp());
25 ASSERT_SUCCESS(olMemAlloc(Device, AllocType, SIZE, &Ptr));
26 }
27
28 void TearDown() override {
29 ASSERT_SUCCESS(olMemFree(Ptr));
30 RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::TearDown());
31 }
32 };
33 using olGetMemInfoDeviceTest = olGetMemInfoTest<OL_ALLOC_TYPE_DEVICE>;
34 OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetMemInfoDeviceTest);
35 using olGetMemInfoManagedTest = olGetMemInfoTest<OL_ALLOC_TYPE_MANAGED>;
36 OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetMemInfoManagedTest);
37 using olGetMemInfoHostTest = olGetMemInfoTest<OL_ALLOC_TYPE_HOST>;
38 OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetMemInfoHostTest);
39
40 #define PER_ALLOC_TEST(FUNCTION) \
41 TEST_P(olGetMemInfoDeviceTest, FUNCTION) { \
42 FUNCTION(this, Ptr, OL_ALLOC_TYPE_DEVICE); \
43 } \
44 TEST_P(olGetMemInfoManagedTest, FUNCTION) { \
45 FUNCTION(this, Ptr, OL_ALLOC_TYPE_MANAGED); \
46 } \
47 TEST_P(olGetMemInfoHostTest, FUNCTION) { \
48 FUNCTION(this, OffsetPtr(), OL_ALLOC_TYPE_HOST); \
49 } \
50 TEST_P(olGetMemInfoDeviceTest, FUNCTION##Offset) { \
51 FUNCTION(this, Ptr, OL_ALLOC_TYPE_DEVICE); \
52 } \
53 TEST_P(olGetMemInfoManagedTest, FUNCTION##Offset) { \
54 FUNCTION(this, OffsetPtr(), OL_ALLOC_TYPE_MANAGED); \
55 } \
56 TEST_P(olGetMemInfoHostTest, FUNCTION##Offset) { \
57 FUNCTION(this, OffsetPtr(), OL_ALLOC_TYPE_HOST); \
58 }
59
60 void SuccessDevice(olGetMemInfoBaseTest *Fixture, void *Ptr,
61 ol_alloc_type_t Type) {
62 ol_device_handle_t RetrievedDevice;
63 ASSERT_SUCCESS(olGetMemInfo(Fixture->Ptr, OL_MEM_INFO_DEVICE,
64 sizeof(RetrievedDevice), &RetrievedDevice));
65 ASSERT_EQ(RetrievedDevice, Fixture->Device);
66 }
67 PER_ALLOC_TEST(SuccessDevice);
68
69 void SuccessBase(olGetMemInfoBaseTest *Fixture, void *Ptr,
70 ol_alloc_type_t Type) {
71 void *RetrievedBase;
72 ASSERT_SUCCESS(olGetMemInfo(Fixture->Ptr, OL_MEM_INFO_BASE,
73 sizeof(RetrievedBase), &RetrievedBase));
74 ASSERT_EQ(RetrievedBase, Fixture->Ptr);
75 }
76 PER_ALLOC_TEST(SuccessBase);
77
78 void SuccessSize(olGetMemInfoBaseTest *Fixture, void *Ptr,
79 ol_alloc_type_t Type) {
80 size_t RetrievedSize;
81 ASSERT_SUCCESS(olGetMemInfo(Fixture->Ptr, OL_MEM_INFO_SIZE,
82 sizeof(RetrievedSize), &RetrievedSize));
83 ASSERT_EQ(RetrievedSize, SIZE);
84 }
85 PER_ALLOC_TEST(SuccessSize);
86
87 void SuccessType(olGetMemInfoBaseTest *Fixture, void *Ptr,
88 ol_alloc_type_t Type) {
89 ol_alloc_type_t RetrievedType;
90 ASSERT_SUCCESS(olGetMemInfo(Fixture->Ptr, OL_MEM_INFO_TYPE,
91 sizeof(RetrievedType), &RetrievedType));
92 ASSERT_EQ(RetrievedType, Type);
93 }
94 PER_ALLOC_TEST(SuccessType);
95
96 TEST_P(olGetMemInfoDeviceTest, InvalidNotFound) {
97 // Assuming that we aren't unlucky and happen to get 0x1234 as a random
98 // pointer
99 void *RetrievedBase;
100 ASSERT_ERROR(OL_ERRC_NOT_FOUND,
101 olGetMemInfo(reinterpret_cast<void *>(0x1234), OL_MEM_INFO_BASE,
102 sizeof(RetrievedBase), &RetrievedBase));
103 }
104
105 TEST_P(olGetMemInfoDeviceTest, InvalidNullPtr) {
106 ol_device_handle_t RetrievedDevice;
107 ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER,
108 olGetMemInfo(nullptr, OL_MEM_INFO_DEVICE,
109 sizeof(RetrievedDevice), &RetrievedDevice));
110 }
111
112 TEST_P(olGetMemInfoDeviceTest, InvalidSizeZero) {
113 ol_device_handle_t RetrievedDevice;
114 ASSERT_ERROR(OL_ERRC_INVALID_SIZE,
115 olGetMemInfo(Ptr, OL_MEM_INFO_DEVICE, 0, &RetrievedDevice));
116 }
117
118 TEST_P(olGetMemInfoDeviceTest, InvalidSizeSmall) {
119 ol_device_handle_t RetrievedDevice;
120 ASSERT_ERROR(OL_ERRC_INVALID_SIZE,
121 olGetMemInfo(Ptr, OL_MEM_INFO_DEVICE,
122 sizeof(RetrievedDevice) - 1, &RetrievedDevice));
123 }
124
125 TEST_P(olGetMemInfoDeviceTest, InvalidNullPointerPropValue) {
126 ol_device_handle_t RetrievedDevice;
127 ASSERT_ERROR(
128 OL_ERRC_INVALID_NULL_POINTER,
129 olGetMemInfo(Ptr, OL_MEM_INFO_DEVICE, sizeof(RetrievedDevice), nullptr));
130 }