Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-10 12:53:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove test API to disable overdispatch

Browse Source 
Signed-off-by: Dunajski, Bartosz <bartosz.dunajski@intel.com>
This commit is contained in:
Dunajski, Bartosz
2022-10-06 08:47:30 +00:00
committed by Compute-Runtime-Automation
parent 8e2fcc9137
commit 9100610b5d
8 changed files with 0 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
opencl/extensions/public/cl_ext_private.h
View File

@ -164,7 +164,6 @@ using cl_unified_shared_memory_type_intel = cl_uint;
#define CL_KERNEL_EXEC_INFO_THREAD_ARBITRATION_POLICY_AFTER_DEPENDENCY_ROUND_ROBIN_INTEL 0x10024
#define CL_KERNEL_EXEC_INFO_THREAD_ARBITRATION_POLICY_INTEL 0x10025
#define CL_KERNEL_EXEC_INFO_THREAD_ARBITRATION_POLICY_STALL_BASED_ROUND_ROBIN_INTEL 0x10026
#define CL_KERNEL_EXEC_INFO_EU_THREAD_OVER_DISPATCH_INTEL 0x10027
/******************************
* SLICE COUNT SELECTING *

7
opencl/source/api/api.cpp
View File

@ -5096,13 +5096,6 @@ cl_int CL_API_CALL clSetKernelExecInfo(cl_kernel kernel,
TRACING_EXIT(ClSetKernelExecInfo, &retVal);
return retVal;
}
case CL_KERNEL_EXEC_INFO_EU_THREAD_OVER_DISPATCH_INTEL: {
if ((paramValueSize != sizeof(cl_bool)) || (paramValue == nullptr)) {
return CL_INVALID_VALUE;
}
retVal = pMultiDeviceKernel->setOverdispatchParam(paramValueSize, paramValue);
break;
}
default: {
retVal = CL_INVALID_VALUE;
break;

17
opencl/source/kernel/kernel.cpp
View File

@ -2260,21 +2260,4 @@ bool Kernel::graphicsAllocationTypeUseSystemMemory(AllocationType type) {
(type == AllocationType::SVM_ZERO_COPY);
}
int32_t Kernel::setOverdispatchParam(size_t paramValueSize, const void *paramValue) {
auto &hwInfo = clDevice.getHardwareInfo();
const auto &hwInfoConfig = *HwInfoConfig::get(hwInfo.platform.eProductFamily);
if (!hwInfoConfig.isDisableOverdispatchAvailable(hwInfo)) {
return CL_INVALID_VALUE;
}
if (*static_cast<const cl_bool *>(paramValue) == CL_TRUE) {
additionalKernelExecInfo = AdditionalKernelExecInfo::NotSet;
return CL_SUCCESS;
}
additionalKernelExecInfo = AdditionalKernelExecInfo::DisableOverdispatch;
return CL_SUCCESS;
}
} // namespace NEO

1
opencl/source/kernel/kernel.h
View File

@ -355,7 +355,6 @@ class Kernel : public ReferenceTrackedObject<Kernel> {
uint64_t getKernelStartAddress(const bool localIdsGenerationByRuntime, const bool kernelUsesLocalIds, const bool isCssUsed, const bool returnFullAddress) const;
bool isKernelDebugEnabled() const { return debugEnabled; }
int32_t setOverdispatchParam(size_t paramValueSize, const void *paramValue);
void setAdditionalKernelExecInfo(uint32_t additionalKernelExecInfo);
uint32_t getAdditionalKernelExecInfo() const;
MOCKABLE_VIRTUAL bool requiresWaDisableRccRhwoOptimization() const;

1
opencl/source/kernel/multi_device_kernel.cpp
View File

@ -53,7 +53,6 @@ void MultiDeviceKernel::clearSvmKernelExecInfo() { callOnEachKernel(&Kernel::cle
void MultiDeviceKernel::clearUnifiedMemoryExecInfo() { callOnEachKernel(&Kernel::clearUnifiedMemoryExecInfo); }
int MultiDeviceKernel::setKernelThreadArbitrationPolicy(uint32_t propertyValue) { return getResultFromEachKernel(&Kernel::setKernelThreadArbitrationPolicy, propertyValue); }
cl_int MultiDeviceKernel::setKernelExecutionType(cl_execution_info_kernel_type_intel executionType) { return getResultFromEachKernel(&Kernel::setKernelExecutionType, executionType); }
int32_t MultiDeviceKernel::setOverdispatchParam(size_t paramValueSize, const void *paramValue) { return getResultFromEachKernel(&Kernel::setOverdispatchParam, paramValueSize, paramValue); }
void MultiDeviceKernel::storeKernelArgAllocIdMemoryManagerCounter(uint32_t argIndex, uint32_t allocIdMemoryManagerCounter) {
for (auto rootDeviceIndex = 0u; rootDeviceIndex < kernels.size(); rootDeviceIndex++) {

1
opencl/source/kernel/multi_device_kernel.h
View File

@ -66,7 +66,6 @@ class MultiDeviceKernel : public BaseObject<_cl_kernel> {
void clearUnifiedMemoryExecInfo();
int setKernelThreadArbitrationPolicy(uint32_t propertyValue);
cl_int setKernelExecutionType(cl_execution_info_kernel_type_intel executionType);
int32_t setOverdispatchParam(size_t paramValueSize, const void *paramValue);
void storeKernelArgAllocIdMemoryManagerCounter(uint32_t argIndex, uint32_t allocIdMemoryManagerCounter);
Program *getProgram() const { return program; }
const KernelInfoContainer &getKernelInfos() const { return kernelInfos; }

4
opencl/test/unit_test/api/CMakeLists.txt
View File

@ -124,10 +124,6 @@ set(IGDRCL_SRCS_tests_api
${CMAKE_CURRENT_SOURCE_DIR}/cl_unload_platform_compiler_tests.inl
)
if(TESTS_DG2_AND_LATER)
list(APPEND IGDRCL_SRCS_tests_api ${CMAKE_CURRENT_SOURCE_DIR}/api_tests_dg2_and_later.cpp)
endif()
if(TESTS_PVC_AND_LATER)
list(APPEND IGDRCL_SRCS_tests_api ${CMAKE_CURRENT_SOURCE_DIR}/cl_get_device_info_pvc_and_later_tests.cpp)
endif()

142
opencl/test/unit_test/api/api_tests_dg2_and_later.cpp
View File

@ -1,142 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/os_interface/hw_info_config.h"
#include "shared/test/common/test_macros/test.h"
#include "opencl/source/api/additional_extensions.h"
#include "opencl/test/unit_test/api/cl_api_tests.h"
#include "opencl/test/unit_test/fixtures/hello_world_fixture.h"
#include "opencl/test/unit_test/test_macros/test_checks_ocl.h"
using namespace NEO;
struct AdditionalKernelExecInfoFixture : public ApiFixture<> {
void setUp() {
ApiFixture::setUp();
auto hwInfo = pDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
auto revId = HwInfoConfig::get(hwInfo->platform.eProductFamily)->getHwRevIdFromStepping(REVISION_B, *hwInfo);
hwInfo->platform.usRevId = revId;
}
};
using AdditionalKernelExecInfoTests = Test<AdditionalKernelExecInfoFixture>;
using matcherDG2AndLater = IsAtLeastXeHpgCore;
HWTEST2_F(AdditionalKernelExecInfoTests, givenEuThreadOverDispatchEnableWhenCallingClSetKernelExecInfoThenOverDispatchIsDisabled, matcherDG2AndLater) {
std::unique_ptr<KernelInfo> pKernelInfo = std::make_unique<KernelInfo>();
std::unique_ptr<MultiDeviceKernel> pMultiDeviceKernel(MockMultiDeviceKernel::create<MockKernel>(pProgram, MockKernel::toKernelInfoContainer(*pKernelInfo, testedRootDeviceIndex)));
auto pKernel = pMultiDeviceKernel->getKernel(testedRootDeviceIndex);
const auto &hwInfo = pDevice->getHardwareInfo();
const auto &hwInfoConfig = *HwInfoConfig::get(hwInfo.platform.eProductFamily);
cl_kernel_exec_info paramName = CL_KERNEL_EXEC_INFO_EU_THREAD_OVER_DISPATCH_INTEL;
cl_bool paramValue = CL_FALSE;
cl_int retVal = clSetKernelExecInfo(pMultiDeviceKernel.get(), paramName, sizeof(cl_bool), &paramValue);
if (hwInfoConfig.isDisableOverdispatchAvailable(hwInfo)) {
EXPECT_EQ(CL_SUCCESS, retVal);
} else {
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
EXPECT_EQ(AdditionalKernelExecInfo::DisableOverdispatch, pKernel->getAdditionalKernelExecInfo());
}
HWTEST2_F(AdditionalKernelExecInfoTests, givenNullPtrParamWhenSetKernelExecInfoSetThenReturnError, matcherDG2AndLater) {
std::unique_ptr<KernelInfo> pKernelInfo = std::make_unique<KernelInfo>();
std::unique_ptr<MultiDeviceKernel> pMultiDeviceKernel(MockMultiDeviceKernel::create<MockKernel>(pProgram, MockKernel::toKernelInfoContainer(*pKernelInfo, testedRootDeviceIndex)));
auto pKernel = pMultiDeviceKernel->getKernel(testedRootDeviceIndex);
cl_kernel_exec_info paramName = CL_KERNEL_EXEC_INFO_EU_THREAD_OVER_DISPATCH_INTEL;
cl_int retVal = clSetKernelExecInfo(pMultiDeviceKernel.get(), paramName, sizeof(cl_bool), nullptr);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
EXPECT_EQ(AdditionalKernelExecInfo::DisableOverdispatch, pKernel->getAdditionalKernelExecInfo());
}
HWTEST2_F(AdditionalKernelExecInfoTests, givenIncorrectParamSizeWhenSetKernelExecInfoSetThenReturnError, matcherDG2AndLater) {
std::unique_ptr<KernelInfo> pKernelInfo = std::make_unique<KernelInfo>();
std::unique_ptr<MultiDeviceKernel> pMultiDeviceKernel(MockMultiDeviceKernel::create<MockKernel>(pProgram, MockKernel::toKernelInfoContainer(*pKernelInfo, testedRootDeviceIndex)));
auto pKernel = pMultiDeviceKernel->getKernel(testedRootDeviceIndex);
cl_kernel_exec_info paramName = CL_KERNEL_EXEC_INFO_EU_THREAD_OVER_DISPATCH_INTEL;
cl_bool paramValue = CL_FALSE;
size_t paramSize = sizeof(cl_bool) + 1;
cl_int retVal = clSetKernelExecInfo(pMultiDeviceKernel.get(), paramName, paramSize, &paramValue);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
EXPECT_EQ(AdditionalKernelExecInfo::DisableOverdispatch, pKernel->getAdditionalKernelExecInfo());
}
struct EnqueueTaskWithAdditionalKernelExecInfo : public HelloWorldTest<HelloWorldFixtureFactory> {
using Parent = HelloWorldTest<HelloWorldFixtureFactory>;
void SetUp() override {
Parent::kernelFilename = "required_work_group";
Parent::kernelName = "CopyBuffer2";
Parent::SetUp();
}
void TearDown() override {
Parent::TearDown();
}
};
HWTEST2_F(EnqueueTaskWithAdditionalKernelExecInfo, givenKernelWithOverDispatchDisabledWhenEnqueuingTaskThenOverdispatchIsDisabledSuccessIsReturned, matcherDG2AndLater) {
auto hwInfo = pDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
const auto &hwInfoConfig = *HwInfoConfig::get(hwInfo->platform.eProductFamily);
hwInfo->platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(REVISION_B, *hwInfo);
if (!hwInfoConfig.isDisableOverdispatchAvailable(*hwInfo)) {
GTEST_SKIP();
}
cl_uint numEventsInWaitList = 0;
cl_event *eventWaitList = nullptr;
cl_event *event = nullptr;
cl_kernel_exec_info paramName = CL_KERNEL_EXEC_INFO_EU_THREAD_OVER_DISPATCH_INTEL;
cl_bool paramValue = CL_FALSE;
retVal = clSetKernelExecInfo(pMultiDeviceKernel, paramName, sizeof(cl_bool), &paramValue);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(AdditionalKernelExecInfo::DisableOverdispatch, pKernel->getAdditionalKernelExecInfo());
cl_command_queue commandQueue = static_cast<cl_command_queue>(pCmdQ);
cl_kernel kernel = static_cast<cl_kernel>(pMultiDeviceKernel);
retVal = clEnqueueTask(
commandQueue,
kernel,
numEventsInWaitList,
eventWaitList,
event);
EXPECT_EQ(CL_SUCCESS, retVal);
}
HWTEST2_F(AdditionalKernelExecInfoTests, givenEuThreadOverDispatchEnableWhenCallingClSetKernelExecInfoThenThenStateIsTheSameAndSuccessIsReturned, IsAtLeastXeHpCore) {
const auto &hwInfo = pDevice->getHardwareInfo();
const auto &hwInfoConfig = *HwInfoConfig::get(hwInfo.platform.eProductFamily);
if (!hwInfoConfig.isDisableOverdispatchAvailable(hwInfo)) {
GTEST_SKIP();
}
std::unique_ptr<KernelInfo> pKernelInfo = std::make_unique<KernelInfo>();
std::unique_ptr<MultiDeviceKernel> pMultiDeviceKernel(MockMultiDeviceKernel::create<MockKernel>(pProgram, MockKernel::toKernelInfoContainer(*pKernelInfo, testedRootDeviceIndex)));
auto pKernel = pMultiDeviceKernel->getKernel(testedRootDeviceIndex);
EXPECT_EQ(AdditionalKernelExecInfo::DisableOverdispatch, pKernel->getAdditionalKernelExecInfo());
cl_kernel_exec_info paramName = CL_KERNEL_EXEC_INFO_EU_THREAD_OVER_DISPATCH_INTEL;
cl_bool paramValue = CL_TRUE;
cl_int retVal = clSetKernelExecInfo(pMultiDeviceKernel.get(), paramName, sizeof(cl_bool), &paramValue);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(AdditionalKernelExecInfo::NotSet, pKernel->getAdditionalKernelExecInfo());
}