1 /*
2 * Copyright (C) 2019-2021 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "shared/source/command_stream/command_stream_receiver.h"
9 #include "shared/test/common/helpers/debug_manager_state_restore.h"
10 #include "shared/test/common/helpers/unit_test_helper.h"
11 #include "shared/test/common/test_macros/test.h"
12
13 #include "opencl/source/api/api.h"
14 #include "opencl/source/mem_obj/buffer.h"
15 #include "opencl/test/unit_test/aub_tests/command_queue/command_enqueue_fixture.h"
16 #include "opencl/test/unit_test/mocks/mock_context.h"
17
18 using namespace NEO;
19
20 struct VerifyMemoryBufferHw
21 : public CommandEnqueueAUBFixture,
22 public ::testing::TestWithParam<std::tuple<size_t, uint64_t>> {
23
SetUpVerifyMemoryBufferHw24 void SetUp() override {
25 CommandEnqueueAUBFixture::SetUp();
26 }
27
TearDownVerifyMemoryBufferHw28 void TearDown() override {
29 CommandEnqueueAUBFixture::TearDown();
30 }
31 };
32
33 size_t testDataSizeTable[] = {
34 16,
35 MemoryConstants::megaByte};
36
37 cl_mem_flags testFlagsTable[] = {
38 0,
39 CL_MEM_COPY_HOST_PTR};
40
HWTEST_P(VerifyMemoryBufferHw,givenDifferentBuffersWhenValidatingMemoryThenSuccessIsReturned)41 HWTEST_P(VerifyMemoryBufferHw, givenDifferentBuffersWhenValidatingMemoryThenSuccessIsReturned) {
42 cl_uint testItem = 5;
43 cl_uint testItemWrong1 = 4;
44 cl_uint testItemWrong2 = 6;
45 auto testItemSize = sizeof(testItem);
46
47 const auto testDataSize = std::get<0>(GetParam());
48 EXPECT_FALSE(testDataSize < testItemSize);
49 const auto flags = std::get<1>(GetParam());
50 const auto usesHostPointer = ((flags & CL_MEM_USE_HOST_PTR) ||
51 (flags & CL_MEM_COPY_HOST_PTR));
52
53 DebugManagerStateRestore restore;
54 DebugManager.flags.DisableZeroCopyForBuffers.set(true);
55
56 std::unique_ptr<uint8_t[]> bufferContent(new uint8_t[testDataSize]);
57 std::unique_ptr<uint8_t[]> validContent(new uint8_t[testDataSize]);
58 std::unique_ptr<uint8_t[]> invalidContent1(new uint8_t[testDataSize]);
59 std::unique_ptr<uint8_t[]> invalidContent2(new uint8_t[testDataSize]);
60
61 auto pTestItem = reinterpret_cast<uint8_t *>(&testItem);
62 for (size_t offset = 0; offset < testDataSize; offset += testItemSize) {
63 for (size_t itemOffset = 0; itemOffset < testItemSize; itemOffset++) {
64 bufferContent.get()[offset + itemOffset] = pTestItem[itemOffset];
65 validContent.get()[offset + itemOffset] = pTestItem[itemOffset];
66 invalidContent1.get()[offset + itemOffset] = pTestItem[itemOffset];
67 invalidContent2.get()[offset + itemOffset] = pTestItem[itemOffset];
68 }
69 }
70
71 // set last item for invalid contents
72 auto pTestItemWrong1 = reinterpret_cast<uint8_t *>(&testItemWrong1);
73 auto pTestItemWrong2 = reinterpret_cast<uint8_t *>(&testItemWrong2);
74 size_t offset = testDataSize - testItemSize;
75 for (size_t itemOffset = 0; itemOffset < testItemSize; itemOffset++) {
76 invalidContent1.get()[offset + itemOffset] = pTestItemWrong1[itemOffset];
77 invalidContent2.get()[offset + itemOffset] = pTestItemWrong2[itemOffset];
78 }
79
80 MockContext context(this->pCmdQ->getDevice().getSpecializedDevice<ClDevice>());
81 cl_int retVal = CL_INVALID_VALUE;
82
83 std::unique_ptr<Buffer> buffer(Buffer::create(
84 &context,
85 flags,
86 testDataSize,
87 (usesHostPointer ? bufferContent.get() : nullptr),
88 retVal));
89 EXPECT_NE(nullptr, buffer);
90
91 if (!usesHostPointer) {
92 retVal = pCmdQ->enqueueFillBuffer(
93 buffer.get(),
94 &testItem,
95 testItemSize,
96 0,
97 testDataSize,
98 0,
99 nullptr,
100 nullptr);
101 EXPECT_EQ(CL_SUCCESS, retVal);
102 }
103
104 auto mappedAddress = clEnqueueMapBuffer(pCmdQ, buffer.get(), CL_FALSE, CL_MAP_READ, 0, testDataSize, 0, nullptr, nullptr, nullptr);
105 clFlush(pCmdQ);
106
107 retVal = clEnqueueVerifyMemoryINTEL(pCmdQ, mappedAddress, validContent.get(), testDataSize, CL_MEM_COMPARE_EQUAL);
108 EXPECT_EQ(CL_SUCCESS, retVal);
109
110 if (UnitTestHelper<FamilyType>::isExpectMemoryNotEqualSupported()) {
111 retVal = clEnqueueVerifyMemoryINTEL(pCmdQ, mappedAddress, invalidContent1.get(), testDataSize, CL_MEM_COMPARE_NOT_EQUAL);
112 EXPECT_EQ(CL_SUCCESS, retVal);
113 retVal = clEnqueueVerifyMemoryINTEL(pCmdQ, mappedAddress, invalidContent2.get(), testDataSize, CL_MEM_COMPARE_NOT_EQUAL);
114 EXPECT_EQ(CL_SUCCESS, retVal);
115 }
116
117 clFinish(pCmdQ);
118 }
119
120 INSTANTIATE_TEST_CASE_P(VerifyMemoryBuffer,
121 VerifyMemoryBufferHw,
122 ::testing::Combine(
123 ::testing::ValuesIn(testDataSizeTable),
124 ::testing::ValuesIn(testFlagsTable)));
125