1 /*
2 * Copyright (C) 2019-2021 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "shared/source/memory_manager/os_agnostic_memory_manager.h"
9 #include "shared/source/os_interface/os_interface.h"
10 #include "shared/source/utilities/arrayref.h"
11 #include "shared/test/common/helpers/debug_manager_state_restore.h"
12 #include "shared/test/common/mocks/mock_wddm.h"
13
14 #include "opencl/source/api/api.h"
15 #include "opencl/source/mem_obj/image.h"
16 #include "opencl/source/platform/platform.h"
17 #include "opencl/source/sharings/d3d/cl_d3d_api.h"
18 #include "opencl/source/sharings/d3d/d3d_buffer.h"
19 #include "opencl/source/sharings/d3d/d3d_sharing.h"
20 #include "opencl/source/sharings/d3d/d3d_surface.h"
21 #include "opencl/source/sharings/d3d/d3d_texture.h"
22 #include "opencl/test/unit_test/fixtures/d3d_test_fixture.h"
23
24 #include "gmock/gmock.h"
25 #include "gtest/gtest.h"
26
27 namespace NEO {
28 TYPED_TEST_CASE_P(D3DTests);
29
TYPED_TEST_P(D3DTests,givenSharedResourceBufferAndInteropUserSyncEnabledWhenReleaseIsCalledThenDontDoExplicitFinish)30 TYPED_TEST_P(D3DTests, givenSharedResourceBufferAndInteropUserSyncEnabledWhenReleaseIsCalledThenDontDoExplicitFinish) {
31 this->context->setInteropUserSyncEnabled(true);
32 this->mockSharingFcns->mockBufferDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
33
34 EXPECT_CALL(*this->mockSharingFcns, getBufferDesc(_, _))
35 .Times(1)
36 .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockBufferDesc));
37
38 class MockCmdQ : public MockCommandQueue {
39 public:
40 MockCmdQ(Context *context, ClDevice *device, const cl_queue_properties *properties) : MockCommandQueue(context, device, properties, false){};
41 cl_int finish() override {
42 finishCalled++;
43 return CL_SUCCESS;
44 }
45 uint32_t finishCalled = 0;
46 };
47
48 auto mockCmdQ = std::unique_ptr<MockCmdQ>(new MockCmdQ(this->context, this->context->getDevice(0), 0));
49
50 auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr));
51 ASSERT_NE(nullptr, buffer.get());
52 cl_mem bufferMem = (cl_mem)buffer.get();
53
54 auto retVal = this->enqueueAcquireD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
55 EXPECT_EQ(CL_SUCCESS, retVal);
56 EXPECT_EQ(0u, mockCmdQ->finishCalled);
57
58 retVal = this->enqueueReleaseD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
59 EXPECT_EQ(CL_SUCCESS, retVal);
60 EXPECT_EQ(0u, mockCmdQ->finishCalled);
61 }
62
TYPED_TEST_P(D3DTests,givenNonSharedResourceBufferAndInteropUserSyncDisabledWhenReleaseIsCalledThenDoExplicitFinishTwice)63 TYPED_TEST_P(D3DTests, givenNonSharedResourceBufferAndInteropUserSyncDisabledWhenReleaseIsCalledThenDoExplicitFinishTwice) {
64 this->context->setInteropUserSyncEnabled(false);
65
66 class MockCmdQ : public MockCommandQueue {
67 public:
68 MockCmdQ(Context *context, ClDevice *device, const cl_queue_properties *properties) : MockCommandQueue(context, device, properties, false){};
69 cl_int finish() override {
70 finishCalled++;
71 return CL_SUCCESS;
72 }
73 uint32_t finishCalled = 0;
74 };
75
76 auto mockCmdQ = std::unique_ptr<MockCmdQ>(new MockCmdQ(this->context, this->context->getDevice(0), 0));
77
78 auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr));
79 ASSERT_NE(nullptr, buffer.get());
80 cl_mem bufferMem = (cl_mem)buffer.get();
81
82 auto retVal = this->enqueueAcquireD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
83 EXPECT_EQ(CL_SUCCESS, retVal);
84 EXPECT_EQ(0u, mockCmdQ->finishCalled);
85
86 retVal = this->enqueueReleaseD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
87 EXPECT_EQ(CL_SUCCESS, retVal);
88 EXPECT_EQ(2u, mockCmdQ->finishCalled);
89 }
90
TYPED_TEST_P(D3DTests,givenSharedResourceBufferAndInteropUserSyncDisabledWhenReleaseIsCalledThenDoExplicitFinishOnce)91 TYPED_TEST_P(D3DTests, givenSharedResourceBufferAndInteropUserSyncDisabledWhenReleaseIsCalledThenDoExplicitFinishOnce) {
92 this->context->setInteropUserSyncEnabled(false);
93 this->mockSharingFcns->mockBufferDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
94
95 EXPECT_CALL(*this->mockSharingFcns, getBufferDesc(_, _))
96 .Times(1)
97 .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockBufferDesc));
98
99 class MockCmdQ : public MockCommandQueue {
100 public:
101 MockCmdQ(Context *context, ClDevice *device, const cl_queue_properties *properties) : MockCommandQueue(context, device, properties, false){};
102 cl_int finish() override {
103 finishCalled++;
104 return CL_SUCCESS;
105 }
106 uint32_t finishCalled = 0;
107 };
108
109 auto mockCmdQ = std::unique_ptr<MockCmdQ>(new MockCmdQ(this->context, this->context->getDevice(0), 0));
110
111 auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr));
112 ASSERT_NE(nullptr, buffer.get());
113 cl_mem bufferMem = (cl_mem)buffer.get();
114
115 auto retVal = this->enqueueAcquireD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
116 EXPECT_EQ(CL_SUCCESS, retVal);
117 EXPECT_EQ(0u, mockCmdQ->finishCalled);
118
119 retVal = this->enqueueReleaseD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
120 EXPECT_EQ(CL_SUCCESS, retVal);
121 EXPECT_EQ(1u, mockCmdQ->finishCalled);
122 }
123
TYPED_TEST_P(D3DTests,givenNonSharedResourceBufferAndInteropUserSyncEnabledWhenReleaseIsCalledThenDoExplicitFinishOnce)124 TYPED_TEST_P(D3DTests, givenNonSharedResourceBufferAndInteropUserSyncEnabledWhenReleaseIsCalledThenDoExplicitFinishOnce) {
125 this->context->setInteropUserSyncEnabled(true);
126
127 class MockCmdQ : public MockCommandQueue {
128 public:
129 MockCmdQ(Context *context, ClDevice *device, const cl_queue_properties *properties) : MockCommandQueue(context, device, properties, false){};
130 cl_int finish() override {
131 finishCalled++;
132 return CL_SUCCESS;
133 }
134 uint32_t finishCalled = 0;
135 };
136
137 auto mockCmdQ = std::unique_ptr<MockCmdQ>(new MockCmdQ(this->context, this->context->getDevice(0), 0));
138
139 auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr));
140 ASSERT_NE(nullptr, buffer.get());
141 cl_mem bufferMem = (cl_mem)buffer.get();
142
143 auto retVal = this->enqueueAcquireD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
144 EXPECT_EQ(CL_SUCCESS, retVal);
145 EXPECT_EQ(0u, mockCmdQ->finishCalled);
146
147 retVal = this->enqueueReleaseD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
148 EXPECT_EQ(CL_SUCCESS, retVal);
149 EXPECT_EQ(1u, mockCmdQ->finishCalled);
150 }
151
TYPED_TEST_P(D3DTests,givenSharedResourceFlagWhenCreate2dTextureThenStagingTextureEqualsPassedTexture)152 TYPED_TEST_P(D3DTests, givenSharedResourceFlagWhenCreate2dTextureThenStagingTextureEqualsPassedTexture) {
153 this->mockSharingFcns->mockTexture2dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
154 this->mockSharingFcns->mockTexture2dDesc.ArraySize = 4;
155 this->mockSharingFcns->mockTexture2dDesc.MipLevels = 4;
156
157 ::testing::InSequence is;
158 EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
159 .Times(1)
160 .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
161 EXPECT_CALL(*this->mockSharingFcns, createTexture2d(_, _, _))
162 .Times(0);
163 EXPECT_CALL(*this->mockSharingFcns, getSharedHandle((D3DTexture2d *)&this->dummyD3DTexture, _))
164 .Times(1);
165 EXPECT_CALL(*this->mockSharingFcns, addRef((D3DTexture2d *)&this->dummyD3DTexture))
166 .Times(1);
167
168 auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 4, nullptr));
169 ASSERT_NE(nullptr, image.get());
170 auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
171 ASSERT_NE(nullptr, d3dTexture);
172
173 EXPECT_TRUE(d3dTexture->isSharedResource());
174 EXPECT_EQ(&this->dummyD3DTexture, d3dTexture->getResourceStaging());
175
176 EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTexture))
177 .Times(1);
178 EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dTexture->getQuery()))
179 .Times(1);
180 }
181
TYPED_TEST_P(D3DTests,givenNonSharedResourceFlagWhenCreate2dTextureThenCreateStagingTexture)182 TYPED_TEST_P(D3DTests, givenNonSharedResourceFlagWhenCreate2dTextureThenCreateStagingTexture) {
183 this->mockSharingFcns->mockTexture2dDesc.MiscFlags = 0;
184
185 ::testing::InSequence is;
186 EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
187 .Times(1)
188 .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
189 EXPECT_CALL(*this->mockSharingFcns, createTexture2d(_, _, _))
190 .Times(1)
191 .WillOnce(SetArgPointee<0>((D3DTexture2d *)&this->dummyD3DTextureStaging));
192 EXPECT_CALL(*this->mockSharingFcns, getSharedHandle((D3DTexture2d *)&this->dummyD3DTextureStaging, _))
193 .Times(1);
194 EXPECT_CALL(*this->mockSharingFcns, addRef((D3DTexture2d *)&this->dummyD3DTexture))
195 .Times(1);
196
197 auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
198 ASSERT_NE(nullptr, image.get());
199 auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
200 ASSERT_NE(nullptr, d3dTexture);
201
202 EXPECT_FALSE(d3dTexture->isSharedResource());
203 EXPECT_EQ(&this->dummyD3DTextureStaging, d3dTexture->getResourceStaging());
204
205 EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTextureStaging))
206 .Times(1);
207 EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTexture))
208 .Times(1);
209 EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dTexture->getQuery()))
210 .Times(1);
211 }
212
TYPED_TEST_P(D3DTests,givenSharedResourceFlagWhenCreate3dTextureThenStagingTextureEqualsPassedTexture)213 TYPED_TEST_P(D3DTests, givenSharedResourceFlagWhenCreate3dTextureThenStagingTextureEqualsPassedTexture) {
214 this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
215 this->mockSharingFcns->mockTexture3dDesc.MipLevels = 4;
216
217 EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
218 .Times(1)
219 .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
220 EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
221 .Times(0);
222 EXPECT_CALL(*this->mockSharingFcns, getSharedHandle((D3DTexture2d *)&this->dummyD3DTexture, _))
223 .Times(1);
224 EXPECT_CALL(*this->mockSharingFcns, addRef((D3DTexture3d *)&this->dummyD3DTexture))
225 .Times(1);
226
227 auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 0, nullptr));
228 ASSERT_NE(nullptr, image.get());
229 auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
230 ASSERT_NE(nullptr, d3dTexture);
231
232 EXPECT_TRUE(d3dTexture->isSharedResource());
233 EXPECT_EQ(&this->dummyD3DTexture, d3dTexture->getResourceStaging());
234
235 EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTexture))
236 .Times(1);
237 EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dTexture->getQuery()))
238 .Times(1);
239 }
240
TYPED_TEST_P(D3DTests,givenNonSharedResourceFlagWhenCreate3dTextureThenCreateStagingTexture)241 TYPED_TEST_P(D3DTests, givenNonSharedResourceFlagWhenCreate3dTextureThenCreateStagingTexture) {
242 this->mockSharingFcns->mockTexture3dDesc.MiscFlags = 0;
243
244 EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
245 .Times(1)
246 .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
247 EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
248 .Times(1)
249 .WillOnce(SetArgPointee<0>((D3DTexture3d *)&this->dummyD3DTextureStaging));
250 EXPECT_CALL(*this->mockSharingFcns, getSharedHandle((D3DTexture2d *)&this->dummyD3DTextureStaging, _))
251 .Times(1);
252 EXPECT_CALL(*this->mockSharingFcns, addRef((D3DTexture3d *)&this->dummyD3DTexture))
253 .Times(1);
254
255 auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
256 ASSERT_NE(nullptr, image.get());
257 auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
258 ASSERT_NE(nullptr, d3dTexture);
259
260 EXPECT_FALSE(d3dTexture->isSharedResource());
261 EXPECT_EQ(&this->dummyD3DTextureStaging, d3dTexture->getResourceStaging());
262
263 EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTextureStaging))
264 .Times(1);
265 EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTexture))
266 .Times(1);
267 EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dTexture->getQuery()))
268 .Times(1);
269 }
270
TYPED_TEST_P(D3DTests,givenD3DDeviceParamWhenContextCreationThenSetProperValues)271 TYPED_TEST_P(D3DTests, givenD3DDeviceParamWhenContextCreationThenSetProperValues) {
272 cl_device_id deviceID = this->context->getDevice(0);
273 cl_platform_id pid[1] = {this->pPlatform};
274 auto param = this->pickParam(CL_CONTEXT_D3D10_DEVICE_KHR, CL_CONTEXT_D3D11_DEVICE_KHR);
275
276 cl_context_properties validProperties[5] = {CL_CONTEXT_PLATFORM, (cl_context_properties)pid[0], param, 0, 0};
277 cl_int retVal = CL_SUCCESS;
278 auto ctx = std::unique_ptr<MockContext>(Context::create<MockContext>(validProperties, ClDeviceVector(&deviceID, 1), nullptr, nullptr, retVal));
279
280 EXPECT_EQ(CL_SUCCESS, retVal);
281 ASSERT_NE(nullptr, ctx.get());
282 EXPECT_EQ(1u, ctx->preferD3dSharedResources);
283 EXPECT_NE(nullptr, ctx->getSharing<D3DSharingFunctions<TypeParam>>());
284 }
285
TYPED_TEST_P(D3DTests,givenSharedNtHandleFlagWhenCreate2dTextureThenGetNtHandle)286 TYPED_TEST_P(D3DTests, givenSharedNtHandleFlagWhenCreate2dTextureThenGetNtHandle) {
287 this->mockSharingFcns->mockTexture2dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED_NTHANDLE;
288
289 EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
290 .Times(1)
291 .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
292 EXPECT_CALL(*this->mockSharingFcns, createTexture2d(_, _, _))
293 .Times(1)
294 .WillOnce(SetArgPointee<0>((D3DTexture2d *)&this->dummyD3DTextureStaging));
295 EXPECT_CALL(*this->mockSharingFcns, getSharedHandle(_, _))
296 .Times(0);
297 EXPECT_CALL(*this->mockSharingFcns, getSharedNTHandle(_, _))
298 .Times(1);
299
300 auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
301 ASSERT_NE(nullptr, image.get());
302 auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
303 ASSERT_NE(nullptr, d3dTexture);
304 }
305
TYPED_TEST_P(D3DTests,givenSharedNtHandleFlagWhenCreate3dTextureThenGetNtHandle)306 TYPED_TEST_P(D3DTests, givenSharedNtHandleFlagWhenCreate3dTextureThenGetNtHandle) {
307 this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED_NTHANDLE;
308
309 EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
310 .Times(1)
311 .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
312 EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
313 .Times(1)
314 .WillOnce(SetArgPointee<0>((D3DTexture3d *)&this->dummyD3DTextureStaging));
315 EXPECT_CALL(*this->mockSharingFcns, getSharedHandle(_, _))
316 .Times(0);
317 EXPECT_CALL(*this->mockSharingFcns, getSharedNTHandle(_, _))
318 .Times(1);
319
320 auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
321 ASSERT_NE(nullptr, image.get());
322 auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
323 ASSERT_NE(nullptr, d3dTexture);
324 }
325
TYPED_TEST_P(D3DTests,WhenFillingBufferDescThenBufferContentIsCorrect)326 TYPED_TEST_P(D3DTests, WhenFillingBufferDescThenBufferContentIsCorrect) {
327 D3DBufferDesc requestedDesc = {};
328 D3DBufferDesc expectedDesc = {};
329 expectedDesc.ByteWidth = 10;
330 expectedDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
331
332 this->mockSharingFcns->fillCreateBufferDesc(requestedDesc, 10);
333 EXPECT_TRUE(memcmp(&requestedDesc, &expectedDesc, sizeof(D3DBufferDesc)) == 0);
334 }
335
TYPED_TEST_P(D3DTests,WhenFillingTexture2dDescThenImageContentIsCorrect)336 TYPED_TEST_P(D3DTests, WhenFillingTexture2dDescThenImageContentIsCorrect) {
337 D3DTexture2dDesc requestedDesc = {};
338 D3DTexture2dDesc expectedDesc = {};
339 D3DTexture2dDesc srcDesc = {};
340 cl_uint subresource = 4;
341
342 srcDesc.Width = 10;
343 srcDesc.Height = 20;
344 srcDesc.MipLevels = 9;
345 srcDesc.ArraySize = 5;
346 srcDesc.Format = DXGI_FORMAT::DXGI_FORMAT_A8_UNORM;
347 srcDesc.SampleDesc = {8, 9};
348 srcDesc.BindFlags = 123;
349 srcDesc.CPUAccessFlags = 456;
350 srcDesc.MiscFlags = 789;
351
352 expectedDesc.Width = srcDesc.Width;
353 expectedDesc.Height = srcDesc.Height;
354 expectedDesc.MipLevels = 1;
355 expectedDesc.ArraySize = 1;
356 expectedDesc.Format = srcDesc.Format;
357 expectedDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
358 expectedDesc.SampleDesc = srcDesc.SampleDesc;
359
360 for (uint32_t i = 0u; i < (subresource % srcDesc.MipLevels); i++) {
361 expectedDesc.Width /= 2;
362 expectedDesc.Height /= 2;
363 }
364
365 this->mockSharingFcns->fillCreateTexture2dDesc(requestedDesc, &srcDesc, subresource);
366 EXPECT_TRUE(memcmp(&requestedDesc, &expectedDesc, sizeof(D3DTexture2dDesc)) == 0);
367 }
368
TYPED_TEST_P(D3DTests,WhenFillingTexture3dDescThenImageContentIsCorrect)369 TYPED_TEST_P(D3DTests, WhenFillingTexture3dDescThenImageContentIsCorrect) {
370 D3DTexture3dDesc requestedDesc = {};
371 D3DTexture3dDesc expectedDesc = {};
372 D3DTexture3dDesc srcDesc = {};
373 cl_uint subresource = 4;
374
375 srcDesc.Width = 10;
376 srcDesc.Height = 20;
377 srcDesc.Depth = 30;
378 srcDesc.MipLevels = 9;
379 srcDesc.Format = DXGI_FORMAT::DXGI_FORMAT_A8_UNORM;
380 srcDesc.BindFlags = 123;
381 srcDesc.CPUAccessFlags = 456;
382 srcDesc.MiscFlags = 789;
383
384 expectedDesc.Width = srcDesc.Width;
385 expectedDesc.Height = srcDesc.Height;
386 expectedDesc.Depth = srcDesc.Depth;
387 expectedDesc.MipLevels = 1;
388 expectedDesc.Format = srcDesc.Format;
389 expectedDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
390
391 for (uint32_t i = 0u; i < (subresource % srcDesc.MipLevels); i++) {
392 expectedDesc.Width /= 2;
393 expectedDesc.Height /= 2;
394 expectedDesc.Depth /= 2;
395 }
396
397 this->mockSharingFcns->fillCreateTexture3dDesc(requestedDesc, &srcDesc, subresource);
398 EXPECT_TRUE(memcmp(&requestedDesc, &expectedDesc, sizeof(D3DTexture3dDesc)) == 0);
399 }
400
TYPED_TEST_P(D3DTests,givenPlaneWhenFindYuvSurfaceCalledThenReturnValidImgFormat)401 TYPED_TEST_P(D3DTests, givenPlaneWhenFindYuvSurfaceCalledThenReturnValidImgFormat) {
402 const ClSurfaceFormatInfo *surfaceFormat;
403 DXGI_FORMAT testFormat[] = {DXGI_FORMAT::DXGI_FORMAT_NV12, DXGI_FORMAT::DXGI_FORMAT_P010, DXGI_FORMAT::DXGI_FORMAT_P016};
404 int channelDataType[] = {CL_UNORM_INT8, CL_UNORM_INT16, CL_UNORM_INT16};
405 for (int n = 0; n < 3; n++) {
406 surfaceFormat = D3DTexture<TypeParam>::findYuvSurfaceFormatInfo(testFormat[n], ImagePlane::NO_PLANE, CL_MEM_READ_WRITE);
407 EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_order == CL_RG);
408 EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_data_type == channelDataType[n]);
409
410 surfaceFormat = D3DTexture<TypeParam>::findYuvSurfaceFormatInfo(testFormat[n], ImagePlane::PLANE_U, CL_MEM_READ_WRITE);
411 EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_order == CL_RG);
412 EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_data_type == channelDataType[n]);
413
414 surfaceFormat = D3DTexture<TypeParam>::findYuvSurfaceFormatInfo(testFormat[n], ImagePlane::PLANE_UV, CL_MEM_READ_WRITE);
415 EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_order == CL_RG);
416 EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_data_type == channelDataType[n]);
417
418 surfaceFormat = D3DTexture<TypeParam>::findYuvSurfaceFormatInfo(testFormat[n], ImagePlane::PLANE_V, CL_MEM_READ_WRITE);
419 EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_order == CL_RG);
420 EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_data_type == channelDataType[n]);
421
422 surfaceFormat = D3DTexture<TypeParam>::findYuvSurfaceFormatInfo(testFormat[n], ImagePlane::PLANE_Y, CL_MEM_READ_WRITE);
423 EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_order == CL_R);
424 EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_data_type == channelDataType[n]);
425 }
426 }
427
TYPED_TEST_P(D3DTests,GivenForced32BitAddressingWhenCreatingBufferThenBufferHas32BitAllocation)428 TYPED_TEST_P(D3DTests, GivenForced32BitAddressingWhenCreatingBufferThenBufferHas32BitAllocation) {
429
430 auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr));
431 ASSERT_NE(nullptr, buffer.get());
432
433 auto *allocation = buffer->getGraphicsAllocation(rootDeviceIndex);
434 EXPECT_NE(nullptr, allocation);
435
436 EXPECT_TRUE(allocation->is32BitAllocation());
437 }
438
TYPED_TEST_P(D3DTests,givenD3DTexture2dWhenOclImageIsCreatedThenSharedImageAllocationTypeIsSet)439 TYPED_TEST_P(D3DTests, givenD3DTexture2dWhenOclImageIsCreatedThenSharedImageAllocationTypeIsSet) {
440 this->mockSharingFcns->mockTexture2dDesc.Format = DXGI_FORMAT_P016;
441 EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
442 .Times(1)
443 .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
444
445 auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 7, nullptr));
446 ASSERT_NE(nullptr, image.get());
447 ASSERT_NE(nullptr, image->getGraphicsAllocation(rootDeviceIndex));
448 EXPECT_EQ(GraphicsAllocation::AllocationType::SHARED_IMAGE, image->getGraphicsAllocation(rootDeviceIndex)->getAllocationType());
449 }
450
TYPED_TEST_P(D3DTests,givenD3DTexture3dWhenOclImageIsCreatedThenSharedImageAllocationTypeIsSet)451 TYPED_TEST_P(D3DTests, givenD3DTexture3dWhenOclImageIsCreatedThenSharedImageAllocationTypeIsSet) {
452 this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
453
454 EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
455 .Times(1)
456 .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
457 EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
458 .Times(1)
459 .WillOnce(SetArgPointee<0>(reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging)));
460
461 auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, nullptr));
462 ASSERT_NE(nullptr, image.get());
463 ASSERT_NE(nullptr, image->getGraphicsAllocation(rootDeviceIndex));
464 EXPECT_EQ(GraphicsAllocation::AllocationType::SHARED_IMAGE, image->getGraphicsAllocation(rootDeviceIndex)->getAllocationType());
465 }
466
TYPED_TEST_P(D3DTests,givenSharedObjectFromInvalidContextWhen3dCreatedThenReturnCorrectCode)467 TYPED_TEST_P(D3DTests, givenSharedObjectFromInvalidContextWhen3dCreatedThenReturnCorrectCode) {
468 this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
469
470 EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
471 .Times(1)
472 .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
473 EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
474 .Times(1)
475 .WillOnce(SetArgPointee<0>(reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging)));
476
477 cl_int retCode = 0;
478 mockMM.get()->verifyValue = false;
479 auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, &retCode));
480 mockMM.get()->verifyValue = true;
481 EXPECT_EQ(nullptr, image.get());
482 EXPECT_EQ(retCode, CL_INVALID_D3D11_RESOURCE_KHR);
483 }
484
TYPED_TEST_P(D3DTests,givenSharedObjectFromInvalidContextAndNTHandleWhen3dCreatedThenReturnCorrectCode)485 TYPED_TEST_P(D3DTests, givenSharedObjectFromInvalidContextAndNTHandleWhen3dCreatedThenReturnCorrectCode) {
486 this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED_NTHANDLE;
487
488 EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
489 .Times(1)
490 .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
491 EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
492 .Times(1)
493 .WillOnce(SetArgPointee<0>(reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging)));
494
495 cl_int retCode = 0;
496 mockMM.get()->verifyValue = false;
497 auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, &retCode));
498 mockMM.get()->verifyValue = true;
499 EXPECT_EQ(nullptr, image.get());
500 EXPECT_EQ(retCode, CL_INVALID_D3D11_RESOURCE_KHR);
501 }
502
TYPED_TEST_P(D3DTests,givenSharedObjectAndAlocationFailedWhen3dCreatedThenReturnCorrectCode)503 TYPED_TEST_P(D3DTests, givenSharedObjectAndAlocationFailedWhen3dCreatedThenReturnCorrectCode) {
504 this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
505
506 EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
507 .Times(1)
508 .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
509 EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
510 .Times(1)
511 .WillOnce(SetArgPointee<0>(reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging)));
512
513 cl_int retCode = 0;
514 mockMM.get()->failAlloc = true;
515 auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, &retCode));
516 mockMM.get()->failAlloc = false;
517 EXPECT_EQ(nullptr, image.get());
518 EXPECT_EQ(retCode, CL_OUT_OF_HOST_MEMORY);
519 }
520
TYPED_TEST_P(D3DTests,givenSharedObjectAndNTHandleAndAllocationFailedWhen3dCreatedThenReturnCorrectCode)521 TYPED_TEST_P(D3DTests, givenSharedObjectAndNTHandleAndAllocationFailedWhen3dCreatedThenReturnCorrectCode) {
522 this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED_NTHANDLE;
523
524 EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
525 .Times(1)
526 .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
527 EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
528 .Times(1)
529 .WillOnce(SetArgPointee<0>(reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging)));
530
531 cl_int retCode = 0;
532 mockMM.get()->failAlloc = true;
533 auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, &retCode));
534 mockMM.get()->failAlloc = false;
535 EXPECT_EQ(nullptr, image.get());
536 EXPECT_EQ(retCode, CL_OUT_OF_HOST_MEMORY);
537 }
538
TYPED_TEST_P(D3DTests,givenFormatNotSupportedByDxWhenGettingSupportedFormatsThenOnlySupportedFormatsAreReturned)539 TYPED_TEST_P(D3DTests, givenFormatNotSupportedByDxWhenGettingSupportedFormatsThenOnlySupportedFormatsAreReturned) {
540 std::vector<DXGI_FORMAT> unsupportedDXGIformats = {
541 DXGI_FORMAT_BC6H_TYPELESS,
542 DXGI_FORMAT_BC6H_UF16,
543 DXGI_FORMAT_BC6H_SF16,
544 DXGI_FORMAT_BC7_TYPELESS,
545 DXGI_FORMAT_BC7_UNORM,
546 DXGI_FORMAT_BC7_UNORM_SRGB,
547 DXGI_FORMAT_AYUV,
548 DXGI_FORMAT_Y410,
549 DXGI_FORMAT_Y416,
550 DXGI_FORMAT_420_OPAQUE,
551 DXGI_FORMAT_YUY2,
552 DXGI_FORMAT_Y210,
553 DXGI_FORMAT_Y216,
554 DXGI_FORMAT_NV11,
555 DXGI_FORMAT_AI44,
556 DXGI_FORMAT_IA44,
557 DXGI_FORMAT_P8,
558 DXGI_FORMAT_A8P8,
559 DXGI_FORMAT_B4G4R4A4_UNORM,
560 DXGI_FORMAT_P208,
561 DXGI_FORMAT_V208,
562 DXGI_FORMAT_V408,
563 DXGI_FORMAT_FORCE_UINT};
564
565 auto checkFormat = [&](DXGI_FORMAT format, UINT *pFormat) -> bool {
566 auto iter = std::find(unsupportedDXGIformats.begin(), unsupportedDXGIformats.end(), format);
567 if (iter != unsupportedDXGIformats.end()) {
568 return false;
569 }
570 *pFormat = D3D11_FORMAT_SUPPORT_BUFFER | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D;
571 return true;
572 };
573
574 ON_CALL(*mockSharingFcns, checkFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Invoke(checkFormat));
575 ON_CALL(*mockSharingFcns, memObjectFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Return(true));
576
577 std::vector<DXGI_FORMAT> formats;
578 cl_uint numTextureFormats = 0;
579 auto retVal = getSupportedDXTextureFormats<TypeParam>(context, CL_MEM_OBJECT_IMAGE3D, 0, 0, nullptr, &numTextureFormats);
580 EXPECT_EQ(CL_SUCCESS, retVal);
581 EXPECT_NE(0u, numTextureFormats);
582
583 formats.resize(numTextureFormats);
584 retVal = getSupportedDXTextureFormats<TypeParam>(context, CL_MEM_OBJECT_IMAGE3D, 0, static_cast<cl_uint>(formats.size()), formats.data(), &numTextureFormats);
585
586 EXPECT_EQ(CL_SUCCESS, retVal);
587
588 bool foundUnsupported = false;
589 for (auto format : formats) {
590 auto iter = std::find(unsupportedDXGIformats.begin(), unsupportedDXGIformats.end(), format);
591 if (iter != unsupportedDXGIformats.end()) {
592 foundUnsupported = true;
593 }
594 }
595 EXPECT_FALSE(foundUnsupported);
596 }
597
TYPED_TEST_P(D3DTests,givenUnsupportedFormatWhenCreatingTexture2dThenInvalidImageFormatDescriptorIsReturned)598 TYPED_TEST_P(D3DTests, givenUnsupportedFormatWhenCreatingTexture2dThenInvalidImageFormatDescriptorIsReturned) {
599
600 auto checkFormat = [](DXGI_FORMAT format, UINT *pFormat) -> bool {
601 if (format == DXGI_FORMAT_R32_FLOAT) {
602 return false;
603 }
604 *pFormat = D3D11_FORMAT_SUPPORT_BUFFER | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D;
605 return true;
606 };
607
608 auto validate = [&](DXGI_FORMAT format, cl_mem_object_type type) -> cl_int {
609 return mockSharingFcns->validateFormatSupportBase(format, type);
610 };
611
612 ON_CALL(*mockSharingFcns, checkFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Invoke(checkFormat));
613 ON_CALL(*mockSharingFcns, memObjectFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Return(true));
614
615 ON_CALL(*mockSharingFcns, validateFormatSupport(::testing::_, ::testing::_))
616 .WillByDefault(::testing::Invoke(validate));
617
618 this->mockSharingFcns->mockTexture2dDesc.Format = DXGI_FORMAT_R32_FLOAT;
619
620 EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
621 .Times(1)
622 .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
623
624 cl_int retCode = CL_SUCCESS;
625 auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 0, &retCode));
626 EXPECT_EQ(nullptr, image.get());
627
628 EXPECT_EQ(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR, retCode);
629 }
630
TYPED_TEST_P(D3DTests,givenUnsupportedFormatWhenCreatingTexture3dThenInvalidImageFormatDescriptorIsReturned)631 TYPED_TEST_P(D3DTests, givenUnsupportedFormatWhenCreatingTexture3dThenInvalidImageFormatDescriptorIsReturned) {
632
633 auto checkFormat = [](DXGI_FORMAT format, UINT *pFormat) -> bool {
634 if (format == DXGI_FORMAT_R32_FLOAT) {
635 return false;
636 }
637 *pFormat = D3D11_FORMAT_SUPPORT_BUFFER | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D;
638 return true;
639 };
640
641 auto validate = [&](DXGI_FORMAT format, cl_mem_object_type type) -> cl_int {
642 return mockSharingFcns->validateFormatSupportBase(format, type);
643 };
644
645 ON_CALL(*mockSharingFcns, checkFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Invoke(checkFormat));
646 ON_CALL(*mockSharingFcns, memObjectFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Return(true));
647
648 ON_CALL(*mockSharingFcns, validateFormatSupport(::testing::_, ::testing::_))
649 .WillByDefault(::testing::Invoke(validate));
650
651 this->mockSharingFcns->mockTexture3dDesc.Format = DXGI_FORMAT_R32_FLOAT;
652
653 EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
654 .Times(1)
655 .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
656
657 cl_int retCode = CL_SUCCESS;
658 auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 0, &retCode));
659 EXPECT_EQ(nullptr, image.get());
660
661 EXPECT_EQ(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR, retCode);
662 }
663
664 REGISTER_TYPED_TEST_CASE_P(D3DTests,
665 givenSharedResourceBufferAndInteropUserSyncEnabledWhenReleaseIsCalledThenDontDoExplicitFinish,
666 givenNonSharedResourceBufferAndInteropUserSyncDisabledWhenReleaseIsCalledThenDoExplicitFinishTwice,
667 givenSharedResourceBufferAndInteropUserSyncDisabledWhenReleaseIsCalledThenDoExplicitFinishOnce,
668 givenNonSharedResourceBufferAndInteropUserSyncEnabledWhenReleaseIsCalledThenDoExplicitFinishOnce,
669 givenSharedResourceFlagWhenCreate2dTextureThenStagingTextureEqualsPassedTexture,
670 givenNonSharedResourceFlagWhenCreate2dTextureThenCreateStagingTexture,
671 givenSharedResourceFlagWhenCreate3dTextureThenStagingTextureEqualsPassedTexture,
672 givenNonSharedResourceFlagWhenCreate3dTextureThenCreateStagingTexture,
673 givenD3DDeviceParamWhenContextCreationThenSetProperValues,
674 givenSharedNtHandleFlagWhenCreate2dTextureThenGetNtHandle,
675 givenSharedNtHandleFlagWhenCreate3dTextureThenGetNtHandle,
676 WhenFillingBufferDescThenBufferContentIsCorrect,
677 WhenFillingTexture2dDescThenImageContentIsCorrect,
678 WhenFillingTexture3dDescThenImageContentIsCorrect,
679 givenPlaneWhenFindYuvSurfaceCalledThenReturnValidImgFormat,
680 GivenForced32BitAddressingWhenCreatingBufferThenBufferHas32BitAllocation,
681 givenD3DTexture2dWhenOclImageIsCreatedThenSharedImageAllocationTypeIsSet,
682 givenD3DTexture3dWhenOclImageIsCreatedThenSharedImageAllocationTypeIsSet,
683 givenSharedObjectFromInvalidContextWhen3dCreatedThenReturnCorrectCode,
684 givenSharedObjectFromInvalidContextAndNTHandleWhen3dCreatedThenReturnCorrectCode,
685 givenSharedObjectAndAlocationFailedWhen3dCreatedThenReturnCorrectCode,
686 givenSharedObjectAndNTHandleAndAllocationFailedWhen3dCreatedThenReturnCorrectCode,
687 givenFormatNotSupportedByDxWhenGettingSupportedFormatsThenOnlySupportedFormatsAreReturned,
688 givenUnsupportedFormatWhenCreatingTexture2dThenInvalidImageFormatDescriptorIsReturned,
689 givenUnsupportedFormatWhenCreatingTexture3dThenInvalidImageFormatDescriptorIsReturned);
690
691 INSTANTIATE_TYPED_TEST_CASE_P(D3DSharingTests, D3DTests, D3DTypes);
692
693 using D3D10Test = D3DTests<D3DTypesHelper::D3D10>;
694
TEST_F(D3D10Test,givenIncompatibleAdapterLuidWhenGettingDeviceIdsThenNoDevicesAreReturned)695 TEST_F(D3D10Test, givenIncompatibleAdapterLuidWhenGettingDeviceIdsThenNoDevicesAreReturned) {
696 cl_device_id deviceID;
697 cl_uint numDevices = 15;
698 static_cast<WddmMock *>(context->getDevice(0)->getRootDeviceEnvironment().osInterface->getDriverModel()->as<Wddm>())->verifyAdapterLuidReturnValue = false;
699
700 auto retVal = clGetDeviceIDsFromD3D10KHR(pPlatform, CL_D3D10_DEVICE_KHR, nullptr, CL_ALL_DEVICES_FOR_D3D10_KHR, 1, &deviceID, &numDevices);
701
702 EXPECT_EQ(CL_DEVICE_NOT_FOUND, retVal);
703 EXPECT_EQ(0, numDevices);
704 }
705
706 using D3D11Test = D3DTests<D3DTypesHelper::D3D11>;
707
TEST_F(D3D11Test,givenIncompatibleAdapterLuidWhenGettingDeviceIdsThenNoDevicesAreReturned)708 TEST_F(D3D11Test, givenIncompatibleAdapterLuidWhenGettingDeviceIdsThenNoDevicesAreReturned) {
709 cl_device_id deviceID;
710 cl_uint numDevices = 15;
711 static_cast<WddmMock *>(context->getDevice(0)->getRootDeviceEnvironment().osInterface->getDriverModel()->as<Wddm>())->verifyAdapterLuidReturnValue = false;
712
713 auto retVal = clGetDeviceIDsFromD3D11KHR(pPlatform, CL_D3D11_DEVICE_KHR, nullptr, CL_ALL_DEVICES_FOR_D3D11_KHR, 1, &deviceID, &numDevices);
714
715 EXPECT_EQ(CL_DEVICE_NOT_FOUND, retVal);
716 EXPECT_EQ(0, numDevices);
717 }
718
TEST(D3D11,GivenPlanarFormatsWhenCallingIsFormatWithPlane1ThenTrueIsReturned)719 TEST(D3D11, GivenPlanarFormatsWhenCallingIsFormatWithPlane1ThenTrueIsReturned) {
720 std::array<DXGI_FORMAT, 6> planarFormats = {DXGI_FORMAT_NV12, DXGI_FORMAT_P010, DXGI_FORMAT_P016,
721 DXGI_FORMAT_420_OPAQUE, DXGI_FORMAT_NV11, DXGI_FORMAT_P208};
722
723 for (auto format : planarFormats) {
724 EXPECT_TRUE(D3DSharing<D3DTypesHelper::D3D11>::isFormatWithPlane1(format));
725 }
726 }
727
TEST(D3D11,GivenNonPlanarFormatsWhenCallingIsFormatWithPlane1ThenFalseIsReturned)728 TEST(D3D11, GivenNonPlanarFormatsWhenCallingIsFormatWithPlane1ThenFalseIsReturned) {
729 std::array<DXGI_FORMAT, 6> planarFormats = {DXGI_FORMAT_R32G32B32_FLOAT,
730 DXGI_FORMAT_R32G32B32_UINT,
731 DXGI_FORMAT_R32G32B32_SINT};
732
733 for (auto format : planarFormats) {
734 EXPECT_FALSE(D3DSharing<D3DTypesHelper::D3D11>::isFormatWithPlane1(format));
735 }
736 }
737
738 } // namespace NEO
739