1 /*
2  * Copyright (C) 2018-2021 Intel Corporation
3  *
4  * SPDX-License-Identifier: MIT
5  *
6  */
7 
8 #pragma once
9 #include "shared/source/execution_environment/root_device_environment.h"
10 #include "shared/source/os_interface/device_factory.h"
11 #include "shared/test/common/helpers/debug_manager_state_restore.h"
12 #include "shared/test/common/helpers/default_hw_info.h"
13 #include "shared/test/common/mocks/mock_device.h"
14 #include "shared/test/common/test_macros/test.h"
15 
16 #include "opencl/source/api/api.h"
17 #include "opencl/source/command_queue/command_queue.h"
18 #include "opencl/source/execution_environment/cl_execution_environment.h"
19 #include "opencl/source/tracing/tracing_api.h"
20 #include "opencl/test/unit_test/helpers/ult_limits.h"
21 #include "opencl/test/unit_test/mocks/mock_cl_device.h"
22 #include "opencl/test/unit_test/mocks/mock_command_queue.h"
23 #include "opencl/test/unit_test/mocks/mock_kernel.h"
24 
25 #include <memory>
26 
27 namespace NEO {
28 
29 template <uint32_t rootDeviceIndex = 1u>
30 struct ApiFixture {
31 
SetUpApiFixture32     virtual void SetUp() {
33         DebugManager.flags.CreateMultipleRootDevices.set(numRootDevices);
34         executionEnvironment = new ClExecutionEnvironment();
35         prepareDeviceEnvironments(*executionEnvironment);
36         auto rootDevice = MockDevice::createWithExecutionEnvironment<MockDevice>(defaultHwInfo.get(), executionEnvironment, rootDeviceIndex);
37         if (rootDeviceIndex != 0u) {
38             rootDeviceEnvironmentBackup.swap(executionEnvironment->rootDeviceEnvironments[0]);
39         }
40 
41         pDevice = new MockClDevice(rootDevice);
42         ASSERT_NE(nullptr, pDevice);
43 
44         testedClDevice = pDevice;
45         pContext = Context::create<MockContext>(nullptr, ClDeviceVector(&testedClDevice, 1), nullptr, nullptr, retVal);
46         EXPECT_EQ(retVal, CL_SUCCESS);
47 
48         pCommandQueue = new MockCommandQueue(pContext, pDevice, nullptr, false);
49 
50         pProgram = new MockProgram(pContext, false, toClDeviceVector(*pDevice));
51 
52         pMultiDeviceKernel = MockMultiDeviceKernel::create<MockKernel>(pProgram, MockKernel::toKernelInfoContainer(pProgram->mockKernelInfo, testedRootDeviceIndex));
53         pKernel = static_cast<MockKernel *>(pMultiDeviceKernel->getKernel(testedRootDeviceIndex));
54         ASSERT_NE(nullptr, pKernel);
55     }
56 
TearDownApiFixture57     virtual void TearDown() {
58         pMultiDeviceKernel->release();
59         pCommandQueue->release();
60         pContext->release();
61         pProgram->release();
62         if (rootDeviceIndex != 0u) {
63             rootDeviceEnvironmentBackup.swap(executionEnvironment->rootDeviceEnvironments[0]);
64         }
65         pDevice->decRefInternal();
66     }
67 
disableQueueCapabilitiesApiFixture68     void disableQueueCapabilities(cl_command_queue_capabilities_intel capabilities) {
69         if (pCommandQueue->queueCapabilities == CL_QUEUE_DEFAULT_CAPABILITIES_INTEL) {
70             pCommandQueue->queueCapabilities = pDevice->getQueueFamilyCapabilitiesAll();
71         }
72 
73         pCommandQueue->queueCapabilities &= ~capabilities;
74     }
75 
76     DebugManagerStateRestore restorer;
77     cl_int retVal = CL_SUCCESS;
78     size_t retSize = 0;
79 
80     MockCommandQueue *pCommandQueue = nullptr;
81     Context *pContext = nullptr;
82     MultiDeviceKernel *pMultiDeviceKernel = nullptr;
83     MockKernel *pKernel = nullptr;
84     MockProgram *pProgram = nullptr;
85     constexpr static uint32_t numRootDevices = maxRootDeviceCount;
86     constexpr static uint32_t testedRootDeviceIndex = rootDeviceIndex;
87     cl_device_id testedClDevice = nullptr;
88     MockClDevice *pDevice = nullptr;
89     ClExecutionEnvironment *executionEnvironment = nullptr;
90     std::unique_ptr<RootDeviceEnvironment> rootDeviceEnvironmentBackup;
91 };
92 
93 struct api_tests : public ApiFixture<>,
94                    public ::testing::Test {
SetUpapi_tests95     void SetUp() override {
96         ApiFixture::SetUp();
97     }
TearDownapi_tests98     void TearDown() override {
99         ApiFixture::TearDown();
100     }
101 };
102 
103 struct api_fixture_using_aligned_memory_manager {
104   public:
105     virtual void SetUp();
106     virtual void TearDown();
107 
108     cl_int retVal;
109     size_t retSize;
110 
111     CommandQueue *commandQueue;
112     Context *context;
113     MockKernel *kernel;
114     MockProgram *program;
115     MockClDevice *device;
116 };
117 
118 using api_test_using_aligned_memory_manager = Test<api_fixture_using_aligned_memory_manager>;
119 
120 void CL_CALLBACK notifyFuncProgram(
121     cl_program program,
122     void *userData);
123 } // namespace NEO
124