1/*
2 * Copyright (C) 2018-2021 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8#include "shared/source/device/device.h"
9#include "shared/test/common/mocks/mock_device.h"
10
11#include "opencl/source/command_queue/command_queue.h"
12#include "opencl/source/context/context.h"
13#include "opencl/test/unit_test/mocks/mock_cl_device.h"
14#include "opencl/test/unit_test/test_macros/test_checks_ocl.h"
15
16#include "cl_api_tests.h"
17
18using namespace NEO;
19
20typedef api_tests clEnqueueSVMUnmapTests;
21
22namespace ULT {
23
24TEST_F(clEnqueueSVMUnmapTests, GivenInvalidCommandQueueWhenUnmappingSvmThenInvalidCommandQueueErrorIsReturned) {
25    auto retVal = clEnqueueSVMUnmap(
26        nullptr, // cl_command_queue  command_queue
27        nullptr, // void *svm_ptr
28        0,       // cl_uint num_events_in_wait_list
29        nullptr, // const cl_event *event_wait_list
30        nullptr  // cl_event *event
31    );
32    EXPECT_EQ(CL_INVALID_COMMAND_QUEUE, retVal);
33}
34
35TEST_F(clEnqueueSVMUnmapTests, GivenNullSvmPtrWhenUnmappingSvmThenInvalidValueErrorIsReturned) {
36    auto retVal = clEnqueueSVMUnmap(
37        pCommandQueue, // cl_command_queue  command_queue
38        nullptr,       // void *svm_ptr
39        0,             // cl_uint num_events_in_wait_list
40        nullptr,       // const cl_event *event_wait_list
41        nullptr        // cl_event *event
42    );
43    EXPECT_EQ(CL_INVALID_VALUE, retVal);
44}
45
46TEST_F(clEnqueueSVMUnmapTests, GivenNullEventListAndNonZeroEventsWhenUnmappingSvmThenInvalidEventWaitListErrorIsReturned) {
47    auto retVal = clEnqueueSVMUnmap(
48        pCommandQueue, // cl_command_queue  command_queue
49        nullptr,       // void *svm_ptr
50        1,             // cl_uint num_events_in_wait_list
51        nullptr,       // const cl_event *event_wait_list
52        nullptr        // cl_event *event
53    );
54    EXPECT_EQ(CL_INVALID_EVENT_WAIT_LIST, retVal);
55}
56
57TEST_F(clEnqueueSVMUnmapTests, GivenNonNullEventListAndZeroEventsWhenUnmappingSvmThenInvalidEventWaitListErrorIsReturned) {
58    UserEvent uEvent(pContext);
59    cl_event eventWaitList[] = {&uEvent};
60    auto retVal = clEnqueueSVMUnmap(
61        pCommandQueue, // cl_command_queue  command_queue
62        nullptr,       // void *svm_ptr
63        0,             // cl_uint num_events_in_wait_list
64        eventWaitList, // const cl_event *event_wait_list
65        nullptr        // cl_event *event
66    );
67    EXPECT_EQ(CL_INVALID_EVENT_WAIT_LIST, retVal);
68}
69
70TEST_F(clEnqueueSVMUnmapTests, GivenValidParametersWhenUnmappingSvmThenSuccessIsReturned) {
71    const ClDeviceInfo &devInfo = pDevice->getDeviceInfo();
72    if (devInfo.svmCapabilities != 0) {
73        void *ptrSvm = clSVMAlloc(pContext, CL_MEM_READ_WRITE, 256, 4);
74        EXPECT_NE(nullptr, ptrSvm);
75
76        auto retVal = clEnqueueSVMMap(
77            pCommandQueue, // cl_command_queue command_queue
78            CL_FALSE,      // cl_bool blocking_map
79            CL_MAP_READ,   // cl_map_flags map_flags
80            ptrSvm,        // void *svm_ptr
81            256,           // size_t size
82            0,             // cl_uint num_events_in_wait_list
83            nullptr,       // const cL_event *event_wait_list
84            nullptr        // cl_event *event
85        );
86        EXPECT_EQ(CL_SUCCESS, retVal);
87
88        retVal = clEnqueueSVMUnmap(
89            pCommandQueue, // cl_command_queue command_queue
90            ptrSvm,        // void *svm_ptr
91            0,             // cl_uint num_events_in_wait_list
92            nullptr,       // const cL_event *event_wait_list
93            nullptr        // cl_event *event
94        );
95        EXPECT_EQ(CL_SUCCESS, retVal);
96
97        clSVMFree(pContext, ptrSvm);
98    }
99}
100
101TEST_F(clEnqueueSVMUnmapTests, GivenQueueIncapableWhenUnmappingSvmBufferThenInvalidOperationIsReturned) {
102    REQUIRE_SVM_OR_SKIP(pDevice);
103
104    void *ptrSvm = clSVMAlloc(pContext, CL_MEM_READ_WRITE, 256, 4);
105    EXPECT_NE(nullptr, ptrSvm);
106
107    auto retVal = clEnqueueSVMMap(
108        pCommandQueue, // cl_command_queue command_queue
109        CL_FALSE,      // cl_bool blocking_map
110        CL_MAP_READ,   // cl_map_flags map_flags
111        ptrSvm,        // void *svm_ptr
112        256,           // size_t size
113        0,             // cl_uint num_events_in_wait_list
114        nullptr,       // const cL_event *event_wait_list
115        nullptr        // cl_event *event
116    );
117    EXPECT_EQ(CL_SUCCESS, retVal);
118
119    disableQueueCapabilities(CL_QUEUE_CAPABILITY_MAP_BUFFER_INTEL);
120
121    retVal = clEnqueueSVMUnmap(
122        pCommandQueue, // cl_command_queue command_queue
123        ptrSvm,        // void *svm_ptr
124        0,             // cl_uint num_events_in_wait_list
125        nullptr,       // const cL_event *event_wait_list
126        nullptr        // cl_event *event
127    );
128    EXPECT_EQ(CL_INVALID_OPERATION, retVal);
129
130    clSVMFree(pContext, ptrSvm);
131}
132
133TEST_F(clEnqueueSVMUnmapTests, GivenDeviceNotSupportingSvmWhenEnqueuingSVMUnmapThenInvalidOperationErrorIsReturned) {
134    auto hwInfo = *defaultHwInfo;
135    hwInfo.capabilityTable.ftrSvm = false;
136
137    auto pDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0));
138    cl_device_id deviceId = pDevice.get();
139    auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
140    auto pCommandQueue = std::make_unique<MockCommandQueue>(pContext.get(), pDevice.get(), nullptr, false);
141
142    retVal = clEnqueueSVMUnmap(
143        pCommandQueue.get(),              // cl_command_queue command_queue
144        reinterpret_cast<void *>(0x1234), // void *svm_ptr
145        0,                                // cl_uint num_events_in_wait_list
146        nullptr,                          // const cL_event *event_wait_list
147        nullptr                           // cl_event *event
148    );
149    EXPECT_EQ(CL_INVALID_OPERATION, retVal);
150}
151
152} // namespace ULT
153