Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove device enqueue part 12 

remove:
- debug flag ForceDeviceEnqueueSupport
- functions isDeviceEnqueueSupported, supportsDeviceEnqueue

Related-To: NEO-6559
Signed-off-by: Katarzyna Cencelewska <katarzyna.cencelewska@intel.com>
This commit is contained in:
Katarzyna Cencelewska 2022-01-27 14:42:05 +00:00 committed by Compute-Runtime-Automation
parent f83cc1c140
commit 58055aecdf
16 changed files with 34 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -5190,11 +5190,9 @@ cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(cl_context conte
TRACING_EXIT(clCreateCommandQueueWithProperties, &commandQueue);
return commandQueue;
}
if (!pDevice->isDeviceEnqueueSupported()) {
err.set(CL_INVALID_QUEUE_PROPERTIES);
TRACING_EXIT(clCreateCommandQueueWithProperties, &commandQueue);
return commandQueue;
}
err.set(CL_INVALID_QUEUE_PROPERTIES);
TRACING_EXIT(clCreateCommandQueueWithProperties, &commandQueue);
return commandQueue;
}
if (commandQueueProperties & static_cast<cl_command_queue_properties>(CL_QUEUE_ON_DEVICE_DEFAULT)) {
@ -5486,12 +5484,6 @@ cl_int CL_API_CALL clSetDefaultDeviceCommandQueue(cl_context context,
return retVal;
}
if (pClDevice->isDeviceEnqueueSupported() == false) {
retVal = CL_INVALID_OPERATION;
TRACING_EXIT(clSetDefaultDeviceCommandQueue, &retVal);
return retVal;
}
retVal = CL_INVALID_OPERATION;
TRACING_EXIT(clSetDefaultDeviceCommandQueue, &retVal);
return retVal;

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

@ -195,13 +195,6 @@ DeviceBitfield ClDevice::getDeviceBitfield() const {
return device.getDeviceBitfield();
}
bool ClDevice::isDeviceEnqueueSupported() const {
if (DebugManager.flags.ForceDeviceEnqueueSupport.get() != -1) {
return DebugManager.flags.ForceDeviceEnqueueSupport.get();
}
return device.getHardwareInfo().capabilityTable.supportsDeviceEnqueue;
}
bool ClDevice::arePipesSupported() const {
if (DebugManager.flags.ForcePipeSupport.get() != -1) {
return DebugManager.flags.ForcePipeSupport.get();

19
opencl/source/cl_device/cl_device_caps.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -283,23 +283,6 @@ void ClDevice::initializeCaps() {
deviceInfo.memBaseAddressAlign = 1024;
deviceInfo.minDataTypeAlignSize = 128;
deviceInfo.deviceEnqueueSupport = isDeviceEnqueueSupported()
? CL_DEVICE_QUEUE_SUPPORTED | CL_DEVICE_QUEUE_REPLACEABLE_DEFAULT
: 0u;
if (isDeviceEnqueueSupported()) {
deviceInfo.maxOnDeviceQueues = 1;
deviceInfo.maxOnDeviceEvents = 1024;
deviceInfo.queueOnDeviceMaxSize = 64 * MB;
deviceInfo.queueOnDevicePreferredSize = 128 * KB;
deviceInfo.queueOnDeviceProperties = CL_QUEUE_PROFILING_ENABLE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
} else {
deviceInfo.maxOnDeviceQueues = 0;
deviceInfo.maxOnDeviceEvents = 0;
deviceInfo.queueOnDeviceMaxSize = 0;
deviceInfo.queueOnDevicePreferredSize = 0;
deviceInfo.queueOnDeviceProperties = 0;
}
deviceInfo.preferredInteropUserSync = 1u;
// OpenCL 1.2 requires 128MB minimum

4
opencl/source/cl_device/cl_device_info.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -177,7 +177,7 @@ cl_int ClDevice::getDeviceInfo(cl_device_info paramName,
case CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES:
if (paramValueSize == sizeof(cl_bool)) {
srcSize = retSize = sizeof(cl_bool);
param.boolean = (deviceInfo.deviceEnqueueSupport > 0u) ? CL_TRUE : CL_FALSE;
param.boolean = CL_FALSE;
src = &param.boolean;
} else {
getCap<CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES>(src, srcSize, retSize);

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

@ -1,5 +1,5 @@
#
# Copyright (C) 2018-2021 Intel Corporation
# Copyright (C) 2018-2022 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@ -110,7 +110,6 @@ set(IGDRCL_SRCS_tests_api
${CMAKE_CURRENT_SOURCE_DIR}/cl_retain_release_device_tests.inl
${CMAKE_CURRENT_SOURCE_DIR}/cl_retain_release_sampler_tests.inl
${CMAKE_CURRENT_SOURCE_DIR}/cl_set_context_destructor_callback.inl
${CMAKE_CURRENT_SOURCE_DIR}/cl_set_default_device_command_queue_tests.inl
${CMAKE_CURRENT_SOURCE_DIR}/cl_set_event_callback_tests.inl
${CMAKE_CURRENT_SOURCE_DIR}/cl_set_kernel_arg_svm_pointer_tests.inl
${CMAKE_CURRENT_SOURCE_DIR}/cl_set_kernel_exec_info_tests.inl

3
opencl/test/unit_test/api/api_tests_wrapper3.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -32,7 +32,6 @@
#include "opencl/test/unit_test/api/cl_retain_release_device_tests.inl"
#include "opencl/test/unit_test/api/cl_retain_release_sampler_tests.inl"
#include "opencl/test/unit_test/api/cl_set_context_destructor_callback.inl"
#include "opencl/test/unit_test/api/cl_set_default_device_command_queue_tests.inl"
#include "opencl/test/unit_test/api/cl_set_event_callback_tests.inl"
#include "opencl/test/unit_test/api/cl_set_kernel_arg_svm_pointer_tests.inl"
#include "opencl/test/unit_test/api/cl_set_kernel_exec_info_tests.inl"

10
opencl/test/unit_test/api/cl_create_command_queue_with_properties_tests.cpp
View File

@ -278,10 +278,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenMedPriorityWhenCreatingOoqCom
EXPECT_EQ(retVal, CL_INVALID_QUEUE_PROPERTIES);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenDeviceEnqueueDisabledWhenCreatingDeviceQueueThenNullQueueAndInvalidQueuePropertiesErrorIsReturned) {
DebugManagerStateRestore restorer;
DebugManager.flags.ForceDeviceEnqueueSupport.set(0);
TEST_F(clCreateCommandQueueWithPropertiesApi, givenDeviceQueuePropertiesWhenCreatingCommandQueueWithPropertiesThenNullQueueAndInvalidQueuePropertiesErrorIsReturned) {
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockContext context{pClDevice.get()};
@ -292,10 +289,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenDeviceEnqueueDisabledWhenCrea
EXPECT_EQ(retVal, CL_INVALID_QUEUE_PROPERTIES);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenDeviceEnqueueDisabledWhenCreatingDefaultDeviceQueueThenNullQueueAndInvalidQueuePropertiesErrorIsReturned) {
DebugManagerStateRestore restorer;
DebugManager.flags.ForceDeviceEnqueueSupport.set(0);
TEST_F(clCreateCommandQueueWithPropertiesApi, givenDefaultDeviceQueuePropertiesWhenCreatingCommandQueueWithPropertiesThenNullQueueAndInvalidQueuePropertiesErrorIsReturned) {
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockContext context{pClDevice.get()};

52
opencl/test/unit_test/api/cl_set_default_device_command_queue_tests.inl
View File

@ -1,52 +0,0 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/device/device.h"
#include "shared/test/common/test_macros/test.h"
#include "opencl/source/context/context.h"
#include "cl_api_tests.h"
using namespace NEO;
namespace ULT {
struct clSetDefaultDeviceCommandQueueApiTest : public api_tests {
clSetDefaultDeviceCommandQueueApiTest() {
}
void SetUp() override {
api_tests::SetUp();
cl_queue_properties properties[] = {CL_QUEUE_PROPERTIES,
CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE,
0,
0};
deviceQueue = clCreateCommandQueueWithProperties(pContext, testedClDevice, properties, &retVal);
if (!pContext->getDevice(0u)->getHardwareInfo().capabilityTable.supportsDeviceEnqueue) {
ASSERT_EQ(nullptr, deviceQueue);
EXPECT_EQ(CL_INVALID_QUEUE_PROPERTIES, retVal);
GTEST_SKIP();
} else {
ASSERT_NE(nullptr, deviceQueue);
ASSERT_EQ(CL_SUCCESS, retVal);
}
}
void TearDown() override {
if (deviceQueue) {
retVal = clReleaseCommandQueue(deviceQueue);
EXPECT_EQ(CL_SUCCESS, retVal);
}
api_tests::TearDown();
}
cl_command_queue deviceQueue = nullptr;
};
} // namespace ULT

105
opencl/test/unit_test/device/device_caps_tests.cpp
View File

@ -224,20 +224,11 @@ TEST_F(DeviceGetCapsTest, WhenCreatingDeviceThenCapsArePopulatedCorrectly) {
auto expectedMaxNumOfSubGroups = device->areOcl21FeaturesEnabled() ? sharedCaps.maxWorkGroupSize / hwHelper.getMinimalSIMDSize() : 0u;
EXPECT_EQ(expectedMaxNumOfSubGroups, caps.maxNumOfSubGroups);
if (defaultHwInfo->capabilityTable.supportsDeviceEnqueue || (defaultHwInfo->capabilityTable.clVersionSupport == 21)) {
EXPECT_EQ(1024u, caps.maxOnDeviceEvents);
EXPECT_EQ(1u, caps.maxOnDeviceQueues);
EXPECT_EQ(64u * MB, caps.queueOnDeviceMaxSize);
EXPECT_EQ(128 * KB, caps.queueOnDevicePreferredSize);
EXPECT_EQ(static_cast<cl_command_queue_properties>(CL_QUEUE_PROFILING_ENABLE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE),
caps.queueOnDeviceProperties);
} else {
EXPECT_EQ(0u, caps.maxOnDeviceEvents);
EXPECT_EQ(0u, caps.maxOnDeviceQueues);
EXPECT_EQ(0u, caps.queueOnDeviceMaxSize);
EXPECT_EQ(0u, caps.queueOnDevicePreferredSize);
EXPECT_EQ(static_cast<cl_command_queue_properties>(0), caps.queueOnDeviceProperties);
}
EXPECT_EQ(0u, caps.maxOnDeviceEvents);
EXPECT_EQ(0u, caps.maxOnDeviceQueues);
EXPECT_EQ(0u, caps.queueOnDeviceMaxSize);
EXPECT_EQ(0u, caps.queueOnDevicePreferredSize);
EXPECT_EQ(static_cast<cl_command_queue_properties>(0), caps.queueOnDeviceProperties);
if (defaultHwInfo->capabilityTable.supportsPipes) {
EXPECT_EQ(16u, caps.maxPipeArgs);
@ -1121,22 +1112,6 @@ TEST(DeviceGetCaps, givenDebugFlagToUseMaxSimdSizeForWkgCalculationWhenDeviceCap
EXPECT_EQ(device->getSharedDeviceInfo().maxWorkGroupSize / CommonConstants::maximalSimdSize, device->getDeviceInfo().maxNumOfSubGroups);
}
TEST(DeviceGetCaps, givenDebugFlagToDisableDeviceEnqueuesWhenCreatingDeviceThenDeviceQueueCapsAreSetCorrectly) {
REQUIRE_OCL_21_OR_SKIP(defaultHwInfo);
DebugManagerStateRestore dbgRestorer;
DebugManager.flags.ForceDeviceEnqueueSupport.set(0);
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
const auto &caps = device->getDeviceInfo();
EXPECT_EQ(0u, caps.queueOnDeviceProperties);
EXPECT_EQ(0u, caps.queueOnDevicePreferredSize);
EXPECT_EQ(0u, caps.queueOnDeviceMaxSize);
EXPECT_EQ(0u, caps.maxOnDeviceQueues);
EXPECT_EQ(0u, caps.maxOnDeviceEvents);
}
HWTEST_F(DeviceGetCapsTest, givenDeviceThatHasHighNumberOfExecutionUnitsWhenMaxWorkgroupSizeIsComputedThenItIsLimitedTo1024) {
REQUIRE_OCL_21_OR_SKIP(defaultHwInfo);
@ -1317,74 +1292,30 @@ TEST_F(DeviceGetCapsTest, givenOcl21DeviceWhenCheckingPipesSupportThenPipesAreSu
}
}
TEST_F(DeviceGetCapsTest, givenDeviceEnqueueSupportForcedWhenCheckingDeviceEnqueueSupportThenDeviceEnqueueIsCorrectlyReported) {
DebugManagerStateRestore dbgRestorer;
int32_t forceDeviceEnqueueSupportValues[] = {-1, 0, 1};
TEST_F(DeviceGetCapsTest, givenCapsDeviceEnqueueWhenCheckingDeviceEnqueueSupportThenNoSupportReported) {
auto hwInfo = *defaultHwInfo;
for (auto isDeviceEnqueueSupportedByHw : ::testing::Bool()) {
hwInfo.capabilityTable.supportsDeviceEnqueue = isDeviceEnqueueSupportedByHw;
for (auto forceDeviceEnqueueSupport : forceDeviceEnqueueSupportValues) {
DebugManager.flags.ForceDeviceEnqueueSupport.set(forceDeviceEnqueueSupport);
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo));
auto &caps = pClDevice->getDeviceInfo();
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo));
auto &caps = pClDevice->getDeviceInfo();
size_t deviceEnqueueFeaturesCount = 0;
for (auto &openclCFeature : caps.openclCFeatures) {
if (0 == strcmp(openclCFeature.name, "__opencl_c_device_enqueue")) {
deviceEnqueueFeaturesCount++;
}
}
bool expectedDeviceEnqueueSupport =
((forceDeviceEnqueueSupport == -1) ? isDeviceEnqueueSupportedByHw : forceDeviceEnqueueSupport);
if (expectedDeviceEnqueueSupport) {
EXPECT_TRUE(pClDevice->isDeviceEnqueueSupported());
EXPECT_EQ(1024u, caps.maxOnDeviceEvents);
EXPECT_EQ(1u, caps.maxOnDeviceQueues);
EXPECT_EQ(64u * MB, caps.queueOnDeviceMaxSize);
EXPECT_EQ(128 * KB, caps.queueOnDevicePreferredSize);
EXPECT_EQ(static_cast<cl_command_queue_properties>(CL_QUEUE_PROFILING_ENABLE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE),
caps.queueOnDeviceProperties);
EXPECT_EQ(1u, deviceEnqueueFeaturesCount);
} else {
EXPECT_FALSE(pClDevice->isDeviceEnqueueSupported());
EXPECT_EQ(0u, caps.maxOnDeviceEvents);
EXPECT_EQ(0u, caps.maxOnDeviceQueues);
EXPECT_EQ(0u, caps.queueOnDeviceMaxSize);
EXPECT_EQ(0u, caps.queueOnDevicePreferredSize);
EXPECT_EQ(static_cast<cl_command_queue_properties>(0), caps.queueOnDeviceProperties);
EXPECT_EQ(0u, deviceEnqueueFeaturesCount);
size_t deviceEnqueueFeaturesCount = 0;
for (auto &openclCFeature : caps.openclCFeatures) {
if (0 == strcmp(openclCFeature.name, "__opencl_c_device_enqueue")) {
deviceEnqueueFeaturesCount++;
}
}
EXPECT_EQ(0u, caps.maxOnDeviceEvents);
EXPECT_EQ(0u, caps.maxOnDeviceQueues);
EXPECT_EQ(0u, caps.queueOnDeviceMaxSize);
EXPECT_EQ(0u, caps.queueOnDevicePreferredSize);
EXPECT_EQ(static_cast<cl_command_queue_properties>(0), caps.queueOnDeviceProperties);
EXPECT_EQ(0u, deviceEnqueueFeaturesCount);
}
}
TEST_F(DeviceGetCapsTest, givenDefaultFlagForceDeviceEnqueueSupportWhenCheckingDeviceEnqueueSupportThenFalseIsReported) {
DebugManagerStateRestore dbgRestorer;
auto hwInfo = *defaultHwInfo;
DebugManager.flags.ForceDeviceEnqueueSupport.set(-1);
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo));
auto &caps = pClDevice->getDeviceInfo();
size_t deviceEnqueueFeaturesCount = 0;
for (auto &openclCFeature : caps.openclCFeatures) {
if (0 == strcmp(openclCFeature.name, "__opencl_c_device_enqueue")) {
deviceEnqueueFeaturesCount++;
}
}
EXPECT_FALSE(pClDevice->isDeviceEnqueueSupported());
EXPECT_EQ(0u, caps.maxOnDeviceEvents);
EXPECT_EQ(0u, caps.maxOnDeviceQueues);
EXPECT_EQ(0u, caps.queueOnDeviceMaxSize);
EXPECT_EQ(0u, caps.queueOnDevicePreferredSize);
EXPECT_EQ(static_cast<cl_command_queue_properties>(0), caps.queueOnDeviceProperties);
EXPECT_EQ(0u, deviceEnqueueFeaturesCount);
}
TEST_F(DeviceGetCapsTest, givenPipeSupportForcedWhenCheckingPipeSupportThenPipeIsCorrectlyReported) {
DebugManagerStateRestore dbgRestorer;
int32_t forcePipeSupportValues[] = {-1, 0, 1};

21
opencl/test/unit_test/device/device_tests.cpp
View File

@ -54,27 +54,6 @@ TEST_F(DeviceTest, WhenDeviceIsCreatedThenEnabledClVersionMatchesHardwareInfo) {
EXPECT_EQ(version, version2);
}
TEST_F(DeviceTest, WhenDeviceIsCheckedForOcl21ConformanceThenCorrectValueIsReturned) {
auto hwInfo = pClDevice->getHardwareInfo();
for (auto supportsOcl21Features : ::testing::Bool()) {
hwInfo.capabilityTable.supportsOcl21Features = supportsOcl21Features;
for (auto supportsIfp : ::testing::Bool()) {
hwInfo.capabilityTable.supportsIndependentForwardProgress = supportsIfp;
for (auto supportsDeviceEnqueue : ::testing::Bool()) {
hwInfo.capabilityTable.supportsDeviceEnqueue = supportsDeviceEnqueue;
for (auto supportsPipes : ::testing::Bool()) {
hwInfo.capabilityTable.supportsPipes = supportsPipes;
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo));
auto expectedOcl21Conformance = (supportsOcl21Features && supportsIfp && supportsDeviceEnqueue && supportsPipes);
EXPECT_EQ(expectedOcl21Conformance, pClDevice->isOcl21Conformant());
}
}
}
}
}
TEST_F(DeviceTest, givenDeviceWhenEngineIsCreatedThenSetInitialValueForTag) {
for (auto &engine : pDevice->allEngines) {
auto tagAddress = engine.commandStreamReceiver->getTagAddress();

12
opencl/test/unit_test/device/get_device_info_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -596,11 +596,11 @@ TEST(GetDeviceInfo, WhenQueryingDeviceEnqueueSupportThenProperValueIsReturned) {
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(sizeof(cl_bool), paramRetSize);
cl_bool expectedDeviceEnqueueSupport = deviceFactory.rootDevices[0]->isDeviceEnqueueSupported() ? CL_TRUE : CL_FALSE;
cl_bool expectedDeviceEnqueueSupport = CL_FALSE;
EXPECT_EQ(expectedDeviceEnqueueSupport, deviceEnqueueSupport);
}
TEST(GetDeviceInfo, WhenQueryingDeviceEnqueueCapabilitiesThenProperValueIsReturned) {
TEST(GetDeviceInfo, WhenQueryingDeviceEnqueueCapabilitiesThenFalseIsReturned) {
UltClDeviceFactory deviceFactory{1, 0};
cl_device_device_enqueue_capabilities deviceEnqueueCapabilities;
@ -611,11 +611,7 @@ TEST(GetDeviceInfo, WhenQueryingDeviceEnqueueCapabilitiesThenProperValueIsReturn
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(sizeof(cl_device_device_enqueue_capabilities), paramRetSize);
cl_device_device_enqueue_capabilities expectedDeviceEnqueueCapabilities =
deviceFactory.rootDevices[0]->isDeviceEnqueueSupported()
? CL_DEVICE_QUEUE_SUPPORTED | CL_DEVICE_QUEUE_REPLACEABLE_DEFAULT
: 0u;
EXPECT_EQ(expectedDeviceEnqueueCapabilities, deviceEnqueueCapabilities);
EXPECT_FALSE(deviceEnqueueCapabilities);
}
TEST(GetDeviceInfo, WhenQueryingPipesSupportThenProperValueIsReturned) {

1
opencl/test/unit_test/test_files/igdrcl.config
View File

@ -166,7 +166,6 @@ RenderCompressedBuffersEnabled = -1
EnableSharedSystemUsmSupport = -1
EnablePassInlineData = -1
ForceFineGrainedSVMSupport = -1
ForceDeviceEnqueueSupport = -1
ForcePipeSupport = -1
ForceSystemMemoryPlacement = 0
ForceNonSystemMemoryPlacement = 0

12
opencl/test/unit_test/test_macros/test_checks_ocl.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -35,16 +35,6 @@ bool TestChecks::supportsOcl21(const std::unique_ptr<HardwareInfo> &pHardwareInf
pHardwareInfo->capabilityTable.supportsPipes && pHardwareInfo->capabilityTable.supportsIndependentForwardProgress);
}
bool TestChecks::supportsDeviceEnqueue(const ClDevice *pClDevice) {
return pClDevice->getHardwareInfo().capabilityTable.supportsDeviceEnqueue;
}
bool TestChecks::supportsDeviceEnqueue(const Context *pContext) {
return supportsDeviceEnqueue(pContext->getDevice(0));
}
bool TestChecks::supportsDeviceEnqueue(const std::unique_ptr<HardwareInfo> &pHardwareInfo) {
return pHardwareInfo->capabilityTable.supportsDeviceEnqueue;
}
bool TestChecks::supportsAuxResolves() {
KernelInfo kernelInfo{};
kernelInfo.kernelDescriptor.payloadMappings.explicitArgs.resize(1);

3
opencl/test/unit_test/test_macros/test_checks_ocl.h
View File

@ -19,9 +19,6 @@ bool supportsSvm(const ClDevice *pClDevice);
bool supportsImages(const Context *pContext);
bool supportsOcl21(const Context *pContext);
bool supportsOcl21(const std::unique_ptr<HardwareInfo> &pHardwareInfo);
bool supportsDeviceEnqueue(const ClDevice *pClDevice);
bool supportsDeviceEnqueue(const Context *pContext);
bool supportsDeviceEnqueue(const std::unique_ptr<HardwareInfo> &pHardwareInfo);
bool supportsPipes(const ClDevice *pClDevice);
bool supportsAuxResolves();
} // namespace TestChecks

9
shared/source/compiler_interface/oclc_extensions.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -127,13 +127,6 @@ void getOpenclCFeaturesList(const HardwareInfo &hwInfo, OpenClCFeaturesContainer
openclCFeatures.push_back(openClCFeature);
}
auto forceDeviceEnqueueSupport = DebugManager.flags.ForceDeviceEnqueueSupport.get();
if ((hwInfo.capabilityTable.supportsDeviceEnqueue && (forceDeviceEnqueueSupport == -1)) ||
(forceDeviceEnqueueSupport == 1)) {
strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_device_enqueue");
openclCFeatures.push_back(openClCFeature);
}
auto forcePipeSupport = DebugManager.flags.ForcePipeSupport.get();
if ((hwInfo.capabilityTable.supportsPipes && (forcePipeSupport == -1)) ||
(forcePipeSupport == 1)) {

1
shared/source/debug_settings/debug_variables_base.inl
View File

@ -325,7 +325,6 @@ DECLARE_DEBUG_VARIABLE(int32_t, RenderCompressedBuffersEnabled, -1, "-1: default
DECLARE_DEBUG_VARIABLE(int32_t, EnableSharedSystemUsmSupport, -1, "-1: default, 0: shared system memory disabled, 1: shared system memory enabled")
DECLARE_DEBUG_VARIABLE(int32_t, EnablePassInlineData, -1, "-1: default, 0: Do not allow to pass inline data 1: Enable passing of inline data")
DECLARE_DEBUG_VARIABLE(int32_t, ForceFineGrainedSVMSupport, -1, "-1: default, 0: Do not report Fine Grained SVM capabilties 1: Report SVM Fine Grained capabilities if device supports SVM")
DECLARE_DEBUG_VARIABLE(int32_t, ForceDeviceEnqueueSupport, -1, "-1: default, 0: disabled, 1: enabled")
DECLARE_DEBUG_VARIABLE(int32_t, ForcePipeSupport, -1, "-1: default, 0: disabled, 1: enabled")
DECLARE_DEBUG_VARIABLE(int32_t, UseAsyncDrmExec, -1, "-1: default, 0: Disabled 1: Enabled. If enabled, pass EXEC_OBJECT_ASYNC to exec ioctl.")
DECLARE_DEBUG_VARIABLE(int32_t, UseBindlessMode, -1, "Use precompiled builtins in bindless mode, -1: api dependent, 0: disabled, 1: enabled")