mirror of
https://github.com/intel/compute-runtime.git
synced 2025-09-15 13:01:45 +08:00
Remove device enqueue part 1
Remove: -tests with matcher for device enqueue -classes: MockDeviceQueueHw, DeviceQueueHw, SchedulerSimulation, DeviceQueueHwTest, KernelArgDevQueueTest -functions: forceDispatchScheduler, processDeviceEnqueue, dispatchScheduler Related-To: NEO-6559 Signed-off-by: Katarzyna Cencelewska <katarzyna.cencelewska@intel.com>
This commit is contained in:
Katarzyna Cencelewska
committed by
Compute-Runtime-Automation
Compute-Runtime-Automation
parent
61e5e0687d
commit
a9ebb49fb5
@ -1,5 +1,5 @@
|
||||
#
|
||||
# Copyright (C) 2018-2021 Intel Corporation
|
||||
# Copyright (C) 2018-2022 Intel Corporation
|
||||
#
|
||||
# SPDX-License-Identifier: MIT
|
||||
#
|
||||
@ -21,7 +21,6 @@ set(IGDRCL_SRCS_tests_kernel
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/kernel_image_arg_tests.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/kernel_immediate_arg_tests.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/kernel_is_patched_tests.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/kernel_arg_dev_queue_tests.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/kernel_reflection_surface_tests.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/kernel_slm_arg_tests.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/kernel_slm_tests.cpp
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2018-2021 Intel Corporation
|
||||
* Copyright (C) 2018-2022 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@ -15,11 +15,9 @@
|
||||
#include "opencl/source/kernel/kernel.h"
|
||||
#include "opencl/source/mem_obj/pipe.h"
|
||||
#include "opencl/test/unit_test/fixtures/context_fixture.h"
|
||||
#include "opencl/test/unit_test/fixtures/device_queue_matcher.h"
|
||||
#include "opencl/test/unit_test/fixtures/image_fixture.h"
|
||||
#include "opencl/test/unit_test/fixtures/multi_root_device_fixture.h"
|
||||
#include "opencl/test/unit_test/mocks/mock_buffer.h"
|
||||
#include "opencl/test/unit_test/mocks/mock_device_queue.h"
|
||||
#include "opencl/test/unit_test/mocks/mock_kernel.h"
|
||||
#include "opencl/test/unit_test/mocks/mock_pipe.h"
|
||||
#include "opencl/test/unit_test/mocks/mock_program.h"
|
||||
@ -424,48 +422,6 @@ TEST_F(CloneKernelTest, GivenArgSamplerWhenCloningKernelThenKernelInfoIsCorrect)
|
||||
EXPECT_EQ(3, sampler->getRefInternalCount());
|
||||
}
|
||||
|
||||
HWTEST2_F(CloneKernelTest, GivenArgDeviceQueueWhenCloningKernelThenKernelInfoIsCorrect, DeviceEnqueueSupport) {
|
||||
pKernelInfo->addArgDevQueue(0, 0x20, sizeof(void *));
|
||||
|
||||
REQUIRE_DEVICE_ENQUEUE_OR_SKIP(device1);
|
||||
|
||||
cl_queue_properties queueProps[5] = {
|
||||
CL_QUEUE_PROPERTIES,
|
||||
CL_QUEUE_ON_DEVICE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE,
|
||||
0, 0, 0};
|
||||
|
||||
MockDeviceQueueHw<FamilyType> mockDevQueue(context.get(), device1, queueProps[0]);
|
||||
auto clDeviceQueue = static_cast<cl_command_queue>(&mockDevQueue);
|
||||
auto rootDeviceIndex = *context->getRootDeviceIndices().begin();
|
||||
|
||||
pSourceKernel[rootDeviceIndex]->setKernelArgHandler(0, &Kernel::setArgDevQueue);
|
||||
pClonedKernel[rootDeviceIndex]->setKernelArgHandler(0, &Kernel::setArgDevQueue);
|
||||
|
||||
retVal = pSourceKernel[rootDeviceIndex]->setArg(0, sizeof(cl_command_queue), &clDeviceQueue);
|
||||
ASSERT_EQ(CL_SUCCESS, retVal);
|
||||
|
||||
EXPECT_EQ(1u, pSourceKernel[rootDeviceIndex]->getKernelArguments().size());
|
||||
EXPECT_EQ(Kernel::DEVICE_QUEUE_OBJ, pSourceKernel[rootDeviceIndex]->getKernelArgInfo(0).type);
|
||||
EXPECT_NE(0u, pSourceKernel[rootDeviceIndex]->getKernelArgInfo(0).size);
|
||||
EXPECT_EQ(1u, pSourceKernel[rootDeviceIndex]->getPatchedArgumentsNum());
|
||||
EXPECT_TRUE(pSourceKernel[rootDeviceIndex]->getKernelArgInfo(0).isPatched);
|
||||
|
||||
retVal = pClonedMultiDeviceKernel->cloneKernel(pSourceMultiDeviceKernel.get());
|
||||
EXPECT_EQ(CL_SUCCESS, retVal);
|
||||
|
||||
EXPECT_EQ(pSourceKernel[rootDeviceIndex]->getKernelArguments().size(), pClonedKernel[rootDeviceIndex]->getKernelArguments().size());
|
||||
EXPECT_EQ(pSourceKernel[rootDeviceIndex]->getKernelArgInfo(0).type, pClonedKernel[rootDeviceIndex]->getKernelArgInfo(0).type);
|
||||
EXPECT_EQ(pSourceKernel[rootDeviceIndex]->getKernelArgInfo(0).object, pClonedKernel[rootDeviceIndex]->getKernelArgInfo(0).object);
|
||||
EXPECT_EQ(pSourceKernel[rootDeviceIndex]->getKernelArgInfo(0).value, pClonedKernel[rootDeviceIndex]->getKernelArgInfo(0).value);
|
||||
EXPECT_EQ(pSourceKernel[rootDeviceIndex]->getKernelArgInfo(0).size, pClonedKernel[rootDeviceIndex]->getKernelArgInfo(0).size);
|
||||
EXPECT_EQ(pSourceKernel[rootDeviceIndex]->getPatchedArgumentsNum(), pClonedKernel[rootDeviceIndex]->getPatchedArgumentsNum());
|
||||
EXPECT_EQ(pSourceKernel[rootDeviceIndex]->getKernelArgInfo(0).isPatched, pClonedKernel[rootDeviceIndex]->getKernelArgInfo(0).isPatched);
|
||||
|
||||
auto pKernelArg = (uintptr_t *)(pClonedKernel[rootDeviceIndex]->getCrossThreadData() +
|
||||
pClonedKernel[rootDeviceIndex]->getKernelInfo().getArgDescriptorAt(0).as<ArgDescPointer>().stateless);
|
||||
EXPECT_EQ(static_cast<uintptr_t>(mockDevQueue.getQueueBuffer()->getGpuAddressToPatch()), *pKernelArg);
|
||||
}
|
||||
|
||||
TEST_F(CloneKernelTest, GivenArgSvmWhenCloningKernelThenKernelInfoIsCorrect) {
|
||||
char *svmPtr = new char[256];
|
||||
|
||||
|
||||
@ -1,125 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2018-2021 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
|
||||
#include "opencl/test/unit_test/fixtures/device_host_queue_fixture.h"
|
||||
#include "opencl/test/unit_test/fixtures/device_queue_matcher.h"
|
||||
#include "opencl/test/unit_test/mocks/mock_buffer.h"
|
||||
#include "opencl/test/unit_test/mocks/mock_kernel.h"
|
||||
#include "opencl/test/unit_test/mocks/mock_program.h"
|
||||
|
||||
using namespace NEO;
|
||||
using namespace DeviceHostQueue;
|
||||
|
||||
struct KernelArgDevQueueTest : public DeviceHostQueueFixture<DeviceQueue> {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
DeviceHostQueueFixture<DeviceQueue>::SetUp();
|
||||
REQUIRE_DEVICE_ENQUEUE_OR_SKIP(pDevice);
|
||||
|
||||
pDeviceQueue = createQueueObject();
|
||||
|
||||
pKernelInfo = std::make_unique<MockKernelInfo>();
|
||||
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 1;
|
||||
|
||||
pKernelInfo->addArgDevQueue(0, crossThreadOffset, 4);
|
||||
|
||||
program = std::make_unique<MockProgram>(toClDeviceVector(*pDevice));
|
||||
pKernel = new MockKernel(program.get(), *pKernelInfo, *pDevice);
|
||||
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
|
||||
|
||||
uint8_t pCrossThreadData[crossThreadDataSize];
|
||||
memset(pCrossThreadData, crossThreadDataInit, sizeof(pCrossThreadData));
|
||||
pKernel->setCrossThreadData(pCrossThreadData, sizeof(pCrossThreadData));
|
||||
}
|
||||
|
||||
void TearDown() override {
|
||||
delete pKernel;
|
||||
|
||||
delete pDeviceQueue;
|
||||
|
||||
DeviceHostQueueFixture<DeviceQueue>::TearDown();
|
||||
}
|
||||
|
||||
bool crossThreadDataUnchanged() {
|
||||
for (uint32_t i = 0; i < crossThreadDataSize; i++) {
|
||||
if (pKernel->mockCrossThreadData[i] != crossThreadDataInit) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static const uint32_t crossThreadDataSize = 0x10;
|
||||
static const char crossThreadDataInit = 0x7e;
|
||||
const CrossThreadDataOffset crossThreadOffset = 0x4;
|
||||
|
||||
std::unique_ptr<MockProgram> program;
|
||||
DeviceQueue *pDeviceQueue = nullptr;
|
||||
MockKernel *pKernel = nullptr;
|
||||
std::unique_ptr<MockKernelInfo> pKernelInfo;
|
||||
};
|
||||
|
||||
HWTEST2_F(KernelArgDevQueueTest, GivenKernelWithDevQueueArgWhenSettingArgHandleThenCorrectHandleIsSet, DeviceEnqueueSupport) {
|
||||
EXPECT_EQ(pKernel->kernelArgHandlers[0], &Kernel::setArgDevQueue);
|
||||
}
|
||||
|
||||
HWTEST2_F(KernelArgDevQueueTest, GivenDeviceQueueWhenSettingArgDevQueueThenCorrectlyPatched, DeviceEnqueueSupport) {
|
||||
auto clDeviceQueue = static_cast<cl_command_queue>(pDeviceQueue);
|
||||
|
||||
auto ret = pKernel->setArgDevQueue(0, sizeof(cl_command_queue), &clDeviceQueue);
|
||||
EXPECT_EQ(ret, CL_SUCCESS);
|
||||
|
||||
auto gpuAddress = static_cast<uint32_t>(pDeviceQueue->getQueueBuffer()->getGpuAddressToPatch());
|
||||
auto patchLocation = ptrOffset(pKernel->mockCrossThreadData.data(), crossThreadOffset);
|
||||
EXPECT_EQ(*(reinterpret_cast<uint32_t *>(patchLocation)), gpuAddress);
|
||||
}
|
||||
|
||||
HWTEST2_F(KernelArgDevQueueTest, GivenCommandQueueWhenSettingArgDevQueueThenInvalidDeviceQueueErrorIsReturned, DeviceEnqueueSupport) {
|
||||
auto clCmdQueue = static_cast<cl_command_queue>(pCommandQueue);
|
||||
|
||||
auto ret = pKernel->setArgDevQueue(0, sizeof(cl_command_queue), &clCmdQueue);
|
||||
EXPECT_EQ(ret, CL_INVALID_DEVICE_QUEUE);
|
||||
EXPECT_EQ(crossThreadDataUnchanged(), true);
|
||||
}
|
||||
|
||||
HWTEST2_F(KernelArgDevQueueTest, GivenNonQueueObjectWhenSettingArgDevQueueThenInvalidDeviceQueueErrorIsReturned, DeviceEnqueueSupport) {
|
||||
Buffer *buffer = new MockBuffer();
|
||||
auto clBuffer = static_cast<cl_mem>(buffer);
|
||||
|
||||
auto ret = pKernel->setArgDevQueue(0, sizeof(cl_command_queue), &clBuffer);
|
||||
EXPECT_EQ(ret, CL_INVALID_DEVICE_QUEUE);
|
||||
EXPECT_EQ(crossThreadDataUnchanged(), true);
|
||||
|
||||
delete buffer;
|
||||
}
|
||||
|
||||
HWTEST2_F(KernelArgDevQueueTest, GivenInvalidQueueWhenSettingArgDevQueueThenInvalidDeviceQueueErrorIsReturned, DeviceEnqueueSupport) {
|
||||
char *pFakeDeviceQueue = new char[sizeof(DeviceQueue)];
|
||||
auto clFakeDeviceQueue = reinterpret_cast<cl_command_queue *>(pFakeDeviceQueue);
|
||||
|
||||
auto ret = pKernel->setArgDevQueue(0, sizeof(cl_command_queue), &clFakeDeviceQueue);
|
||||
EXPECT_EQ(ret, CL_INVALID_DEVICE_QUEUE);
|
||||
EXPECT_EQ(crossThreadDataUnchanged(), true);
|
||||
|
||||
delete[] pFakeDeviceQueue;
|
||||
}
|
||||
|
||||
HWTEST2_F(KernelArgDevQueueTest, GivenNullDeviceQueueWhenSettingArgDevQueueThenInvalidArgValueErrorIsReturned, DeviceEnqueueSupport) {
|
||||
auto ret = pKernel->setArgDevQueue(0, sizeof(cl_command_queue), nullptr);
|
||||
EXPECT_EQ(ret, CL_INVALID_ARG_VALUE);
|
||||
EXPECT_EQ(crossThreadDataUnchanged(), true);
|
||||
}
|
||||
|
||||
HWTEST2_F(KernelArgDevQueueTest, GivenInvalidSizeWhenSettingArgDevQueueThenInvalidArgSizeErrorIsReturned, DeviceEnqueueSupport) {
|
||||
auto clDeviceQueue = static_cast<cl_command_queue>(pDeviceQueue);
|
||||
|
||||
auto ret = pKernel->setArgDevQueue(0, sizeof(cl_command_queue) - 1, &clDeviceQueue);
|
||||
EXPECT_EQ(ret, CL_INVALID_ARG_SIZE);
|
||||
EXPECT_EQ(crossThreadDataUnchanged(), true);
|
||||
}
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 2018-2021 Intel Corporation
|
||||
* Copyright (C) 2018-2022 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
@ -19,7 +19,6 @@
|
||||
#include "opencl/test/unit_test/fixtures/multi_root_device_fixture.h"
|
||||
#include "opencl/test/unit_test/helpers/gtest_helpers.h"
|
||||
#include "opencl/test/unit_test/mocks/mock_context.h"
|
||||
#include "opencl/test/unit_test/mocks/mock_device_queue.h"
|
||||
#include "opencl/test/unit_test/mocks/mock_kernel.h"
|
||||
#include "opencl/test/unit_test/mocks/mock_mdi.h"
|
||||
#include "opencl/test/unit_test/mocks/mock_program.h"
|
||||
|
||||
@ -34,7 +34,6 @@
|
||||
#include "opencl/source/mem_obj/image.h"
|
||||
#include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
|
||||
#include "opencl/test/unit_test/fixtures/device_host_queue_fixture.h"
|
||||
#include "opencl/test/unit_test/fixtures/device_queue_matcher.h"
|
||||
#include "opencl/test/unit_test/fixtures/execution_model_fixture.h"
|
||||
#include "opencl/test/unit_test/fixtures/multi_root_device_fixture.h"
|
||||
#include "opencl/test/unit_test/helpers/gtest_helpers.h"
|
||||
@ -1013,264 +1012,6 @@ TEST_F(KernelConstantSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenCon
|
||||
delete pKernel;
|
||||
}
|
||||
|
||||
HWTEST2_F(KernelEventPoolSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenEventPoolSurfaceStateIsPatchedWithNullSurface, DeviceEnqueueSupport) {
|
||||
|
||||
// define kernel info
|
||||
auto pKernelInfo = std::make_unique<MockKernelInfo>();
|
||||
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 32;
|
||||
|
||||
pKernelInfo->setDeviceSideEnqueueEventPoolSurface(8, 0, 0);
|
||||
|
||||
// create kernel
|
||||
MockProgram program(&context, false, toClDeviceVector(*pClDevice));
|
||||
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
|
||||
|
||||
// setup surface state heap
|
||||
char surfaceStateHeap[0x80];
|
||||
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
|
||||
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
|
||||
|
||||
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
|
||||
|
||||
EXPECT_NE(0u, pKernel->getSurfaceStateHeapSize());
|
||||
|
||||
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
|
||||
auto surfaceState = reinterpret_cast<const RENDER_SURFACE_STATE *>(
|
||||
ptrOffset(pKernel->getSurfaceStateHeap(),
|
||||
pKernelInfo->kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress.bindful));
|
||||
auto surfaceAddress = surfaceState->getSurfaceBaseAddress();
|
||||
|
||||
EXPECT_EQ(0u, surfaceAddress);
|
||||
auto surfaceType = surfaceState->getSurfaceType();
|
||||
EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_NULL, surfaceType);
|
||||
|
||||
delete pKernel;
|
||||
}
|
||||
|
||||
HWTEST2_F(KernelEventPoolSurfaceTest, givenStatefulKernelWhenEventPoolIsPatchedThenEventPoolSurfaceStateIsProgrammed, DeviceEnqueueSupport) {
|
||||
|
||||
// define kernel info
|
||||
auto pKernelInfo = std::make_unique<MockKernelInfo>();
|
||||
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 32;
|
||||
|
||||
pKernelInfo->setDeviceSideEnqueueEventPoolSurface(8, 0, 0);
|
||||
|
||||
// create kernel
|
||||
MockProgram program(&context, false, toClDeviceVector(*pClDevice));
|
||||
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
|
||||
|
||||
// setup surface state heap
|
||||
char surfaceStateHeap[0x80];
|
||||
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
|
||||
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
|
||||
|
||||
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
|
||||
|
||||
pKernel->patchEventPool(pDevQueue);
|
||||
|
||||
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
|
||||
auto surfaceState = reinterpret_cast<const RENDER_SURFACE_STATE *>(
|
||||
ptrOffset(pKernel->getSurfaceStateHeap(),
|
||||
pKernelInfo->kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress.bindful));
|
||||
auto surfaceAddress = surfaceState->getSurfaceBaseAddress();
|
||||
|
||||
EXPECT_EQ(pDevQueue->getEventPoolBuffer()->getGpuAddress(), surfaceAddress);
|
||||
auto surfaceType = surfaceState->getSurfaceType();
|
||||
EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER, surfaceType);
|
||||
|
||||
delete pKernel;
|
||||
}
|
||||
|
||||
HWTEST2_F(KernelEventPoolSurfaceTest, givenKernelWithNullEventPoolInKernelInfoWhenEventPoolIsPatchedThenAddressIsNotPatched, DeviceEnqueueSupport) {
|
||||
// define kernel info
|
||||
auto pKernelInfo = std::make_unique<KernelInfo>();
|
||||
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 32;
|
||||
pKernelInfo->kernelDescriptor.kernelAttributes.bufferAddressingMode = KernelDescriptor::Stateless;
|
||||
|
||||
// create kernel
|
||||
MockProgram program(toClDeviceVector(*pClDevice));
|
||||
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
|
||||
|
||||
uint64_t crossThreadData = 123;
|
||||
|
||||
pKernel->setCrossThreadData(&crossThreadData, sizeof(uint64_t));
|
||||
|
||||
pKernel->patchEventPool(pDevQueue);
|
||||
|
||||
EXPECT_EQ(123u, *(uint64_t *)pKernel->getCrossThreadData());
|
||||
|
||||
delete pKernel;
|
||||
}
|
||||
|
||||
HWTEST2_F(KernelEventPoolSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenEventPoolSurfaceStateIsNotPatched, DeviceEnqueueSupport) {
|
||||
// define kernel info
|
||||
auto pKernelInfo = std::make_unique<MockKernelInfo>();
|
||||
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 32;
|
||||
pKernelInfo->setDeviceSideEnqueueEventPoolSurface(8, 0);
|
||||
|
||||
// create kernel
|
||||
MockProgram program(toClDeviceVector(*pClDevice));
|
||||
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
|
||||
|
||||
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
|
||||
if (pClDevice->areOcl21FeaturesSupported() == false) {
|
||||
EXPECT_EQ(0u, pKernel->getSurfaceStateHeapSize());
|
||||
} else {
|
||||
}
|
||||
|
||||
delete pKernel;
|
||||
}
|
||||
|
||||
HWTEST2_F(KernelEventPoolSurfaceTest, givenStatelessKernelWhenEventPoolIsPatchedThenCrossThreadDataIsPatched, DeviceEnqueueSupport) {
|
||||
// define kernel info
|
||||
auto pKernelInfo = std::make_unique<MockKernelInfo>();
|
||||
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 32;
|
||||
pKernelInfo->setDeviceSideEnqueueEventPoolSurface(8, 0);
|
||||
|
||||
// create kernel
|
||||
MockProgram program(toClDeviceVector(*pClDevice));
|
||||
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
|
||||
|
||||
uint64_t crossThreadData = 0;
|
||||
|
||||
pKernel->setCrossThreadData(&crossThreadData, sizeof(uint64_t));
|
||||
|
||||
pKernel->patchEventPool(pDevQueue);
|
||||
|
||||
EXPECT_EQ(pDevQueue->getEventPoolBuffer()->getGpuAddressToPatch(), *(uint64_t *)pKernel->getCrossThreadData());
|
||||
|
||||
delete pKernel;
|
||||
}
|
||||
|
||||
HWTEST2_F(KernelDefaultDeviceQueueSurfaceTest, givenStatefulKernelWhenKernelIsCreatedThenDefaultDeviceQueueSurfaceStateIsPatchedWithNullSurface, DeviceEnqueueSupport) {
|
||||
|
||||
// define kernel info
|
||||
auto pKernelInfo = std::make_unique<MockKernelInfo>();
|
||||
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 32;
|
||||
pKernelInfo->setDeviceSideEnqueueDefaultQueueSurface(8, 0, 0);
|
||||
|
||||
// create kernel
|
||||
MockProgram program(&context, false, toClDeviceVector(*pClDevice));
|
||||
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
|
||||
|
||||
// setup surface state heap
|
||||
char surfaceStateHeap[0x80];
|
||||
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
|
||||
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
|
||||
|
||||
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
|
||||
|
||||
EXPECT_NE(0u, pKernel->getSurfaceStateHeapSize());
|
||||
|
||||
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
|
||||
auto surfaceState = reinterpret_cast<const RENDER_SURFACE_STATE *>(
|
||||
ptrOffset(pKernel->getSurfaceStateHeap(),
|
||||
pKernelInfo->kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress.bindful));
|
||||
auto surfaceAddress = surfaceState->getSurfaceBaseAddress();
|
||||
|
||||
EXPECT_EQ(0u, surfaceAddress);
|
||||
auto surfaceType = surfaceState->getSurfaceType();
|
||||
EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_NULL, surfaceType);
|
||||
|
||||
delete pKernel;
|
||||
}
|
||||
|
||||
HWTEST2_F(KernelDefaultDeviceQueueSurfaceTest, givenStatefulKernelWhenDefaultDeviceQueueIsPatchedThenSurfaceStateIsCorrectlyProgrammed, DeviceEnqueueSupport) {
|
||||
|
||||
// define kernel info
|
||||
auto pKernelInfo = std::make_unique<MockKernelInfo>();
|
||||
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 32;
|
||||
pKernelInfo->setDeviceSideEnqueueDefaultQueueSurface(8, 0, 0);
|
||||
|
||||
// create kernel
|
||||
MockProgram program(&context, false, toClDeviceVector(*pClDevice));
|
||||
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
|
||||
|
||||
// setup surface state heap
|
||||
char surfaceStateHeap[0x80];
|
||||
pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
|
||||
pKernelInfo->heapInfo.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
|
||||
|
||||
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
|
||||
|
||||
pKernel->patchDefaultDeviceQueue(pDevQueue);
|
||||
|
||||
EXPECT_NE(0u, pKernel->getSurfaceStateHeapSize());
|
||||
|
||||
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
|
||||
auto surfaceState = reinterpret_cast<const RENDER_SURFACE_STATE *>(
|
||||
ptrOffset(pKernel->getSurfaceStateHeap(),
|
||||
pKernelInfo->kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress.bindful));
|
||||
auto surfaceAddress = surfaceState->getSurfaceBaseAddress();
|
||||
|
||||
EXPECT_EQ(pDevQueue->getQueueBuffer()->getGpuAddress(), surfaceAddress);
|
||||
auto surfaceType = surfaceState->getSurfaceType();
|
||||
EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER, surfaceType);
|
||||
|
||||
delete pKernel;
|
||||
}
|
||||
|
||||
HWTEST2_F(KernelDefaultDeviceQueueSurfaceTest, givenStatelessKernelWhenKernelIsCreatedThenDefaultDeviceQueueSurfaceStateIsNotPatched, DeviceEnqueueSupport) {
|
||||
|
||||
// define kernel info
|
||||
auto pKernelInfo = std::make_unique<MockKernelInfo>();
|
||||
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 32;
|
||||
pKernelInfo->setDeviceSideEnqueueDefaultQueueSurface(8, 0);
|
||||
|
||||
// create kernel
|
||||
MockProgram program(toClDeviceVector(*pClDevice));
|
||||
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
|
||||
|
||||
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
|
||||
|
||||
EXPECT_EQ(0u, pKernel->getSurfaceStateHeapSize());
|
||||
|
||||
delete pKernel;
|
||||
}
|
||||
|
||||
HWTEST2_F(KernelDefaultDeviceQueueSurfaceTest, givenKernelWithNullDeviceQueueKernelInfoWhenDefaultDeviceQueueIsPatchedThenAddressIsNotPatched, DeviceEnqueueSupport) {
|
||||
|
||||
// define kernel info
|
||||
auto pKernelInfo = std::make_unique<KernelInfo>();
|
||||
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 32;
|
||||
|
||||
// create kernel
|
||||
MockProgram program(toClDeviceVector(*pClDevice));
|
||||
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
|
||||
|
||||
uint64_t crossThreadData = 123;
|
||||
|
||||
pKernel->setCrossThreadData(&crossThreadData, sizeof(uint64_t));
|
||||
|
||||
pKernel->patchDefaultDeviceQueue(pDevQueue);
|
||||
|
||||
EXPECT_EQ(123u, *(uint64_t *)pKernel->getCrossThreadData());
|
||||
|
||||
delete pKernel;
|
||||
}
|
||||
|
||||
HWTEST2_F(KernelDefaultDeviceQueueSurfaceTest, givenStatelessKernelWhenDefaultDeviceQueueIsPatchedThenCrossThreadDataIsPatched, DeviceEnqueueSupport) {
|
||||
|
||||
// define kernel info
|
||||
auto pKernelInfo = std::make_unique<MockKernelInfo>();
|
||||
pKernelInfo->kernelDescriptor.kernelAttributes.simdSize = 32;
|
||||
pKernelInfo->setDeviceSideEnqueueDefaultQueueSurface(8, 0);
|
||||
|
||||
// create kernel
|
||||
MockProgram program(toClDeviceVector(*pClDevice));
|
||||
MockKernel *pKernel = new MockKernel(&program, *pKernelInfo, *pClDevice);
|
||||
|
||||
uint64_t crossThreadData = 0;
|
||||
|
||||
pKernel->setCrossThreadData(&crossThreadData, sizeof(uint64_t));
|
||||
|
||||
pKernel->patchDefaultDeviceQueue(pDevQueue);
|
||||
|
||||
EXPECT_EQ(pDevQueue->getQueueBuffer()->getGpuAddressToPatch(), *(uint64_t *)pKernel->getCrossThreadData());
|
||||
|
||||
delete pKernel;
|
||||
}
|
||||
|
||||
typedef Test<ClDeviceFixture> KernelResidencyTest;
|
||||
|
||||
HWTEST_F(KernelResidencyTest, givenKernelWhenMakeResidentIsCalledThenKernelIsaIsMadeResident) {
|
||||
@ -3052,64 +2793,6 @@ TEST(KernelTest, givenKernelWhenSettingAdditinalKernelExecInfoThenCorrectValueIs
|
||||
EXPECT_EQ(AdditionalKernelExecInfo::NotApplicable, mockKernel.getAdditionalKernelExecInfo());
|
||||
}
|
||||
|
||||
namespace NEO {
|
||||
|
||||
template <typename GfxFamily>
|
||||
class DeviceQueueHwMock : public DeviceQueueHw<GfxFamily> {
|
||||
using BaseClass = DeviceQueueHw<GfxFamily>;
|
||||
|
||||
public:
|
||||
using BaseClass::buildSlbDummyCommands;
|
||||
using BaseClass::getCSPrefetchSize;
|
||||
using BaseClass::getExecutionModelCleanupSectionSize;
|
||||
using BaseClass::getMediaStateClearCmdsSize;
|
||||
using BaseClass::getMinimumSlbSize;
|
||||
using BaseClass::getProfilingEndCmdsSize;
|
||||
using BaseClass::getSlbCS;
|
||||
using BaseClass::getWaCommandsSize;
|
||||
using BaseClass::offsetDsh;
|
||||
|
||||
DeviceQueueHwMock(Context *context, ClDevice *device, cl_queue_properties &properties) : BaseClass(context, device, properties) {
|
||||
auto slb = this->getSlbBuffer();
|
||||
LinearStream *slbCS = getSlbCS();
|
||||
slbCS->replaceBuffer(slb->getUnderlyingBuffer(), slb->getUnderlyingBufferSize()); // reset
|
||||
};
|
||||
};
|
||||
} // namespace NEO
|
||||
|
||||
HWTEST2_F(DeviceQueueHwTest, whenSlbEndOffsetGreaterThanZeroThenOverwriteOneEnqueue, DeviceEnqueueSupport) {
|
||||
std::unique_ptr<DeviceQueueHwMock<FamilyType>> mockDeviceQueueHw(new DeviceQueueHwMock<FamilyType>(pContext, device, deviceQueueProperties::minimumProperties[0]));
|
||||
|
||||
auto slb = mockDeviceQueueHw->getSlbBuffer();
|
||||
auto commandsSize = mockDeviceQueueHw->getMinimumSlbSize() + mockDeviceQueueHw->getWaCommandsSize();
|
||||
auto slbCopy = malloc(slb->getUnderlyingBufferSize());
|
||||
memset(slb->getUnderlyingBuffer(), 0xFE, slb->getUnderlyingBufferSize());
|
||||
memcpy(slbCopy, slb->getUnderlyingBuffer(), slb->getUnderlyingBufferSize());
|
||||
|
||||
auto igilCmdQueue = reinterpret_cast<IGIL_CommandQueue *>(mockDeviceQueueHw->getQueueBuffer()->getUnderlyingBuffer());
|
||||
|
||||
// slbEndOffset < commandsSize * 128
|
||||
// always fill only 1 enqueue (after offset)
|
||||
auto offset = static_cast<int>(commandsSize) * 50;
|
||||
igilCmdQueue->m_controls.m_SLBENDoffsetInBytes = offset;
|
||||
mockDeviceQueueHw->resetDeviceQueue();
|
||||
EXPECT_EQ(0, memcmp(slb->getUnderlyingBuffer(), slbCopy, offset)); // dont touch memory before offset
|
||||
EXPECT_NE(0, memcmp(ptrOffset(slb->getUnderlyingBuffer(), offset),
|
||||
slbCopy, commandsSize)); // change 1 enqueue
|
||||
EXPECT_EQ(0, memcmp(ptrOffset(slb->getUnderlyingBuffer(), offset + commandsSize),
|
||||
slbCopy, offset)); // dont touch memory after (offset + 1 enqueue)
|
||||
|
||||
// slbEndOffset == commandsSize * 128
|
||||
// dont fill commands
|
||||
memset(slb->getUnderlyingBuffer(), 0xFEFEFEFE, slb->getUnderlyingBufferSize());
|
||||
offset = static_cast<int>(commandsSize) * 128;
|
||||
igilCmdQueue->m_controls.m_SLBENDoffsetInBytes = static_cast<int>(commandsSize);
|
||||
mockDeviceQueueHw->resetDeviceQueue();
|
||||
EXPECT_EQ(0, memcmp(slb->getUnderlyingBuffer(), slbCopy, commandsSize * 128)); // dont touch memory for enqueues
|
||||
|
||||
free(slbCopy);
|
||||
}
|
||||
|
||||
using KernelMultiRootDeviceTest = MultiRootDeviceFixture;
|
||||
|
||||
TEST_F(KernelMultiRootDeviceTest, givenKernelWithPrivateSurfaceWhenInitializeThenPrivateSurfacesHaveCorrectRootDeviceIndex) {
|
||||
|
||||
Reference in New Issue
Block a user