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