From 0b141ed4ea059e1cff62d5b1ac6e7bffa3d3a4a2 Mon Sep 17 00:00:00 2001 From: Filip Hazubski Date: Tue, 21 Jan 2020 19:02:36 +0100 Subject: [PATCH] Add KernelExecutionType Add possibility to set Kernel execution type via clSetKernelExecInfo. Change-Id: I2de0bf4e067921440e34e14c6975f640d3f47162 Signed-off-by: Filip Hazubski --- public/cl_ext_private.h | 11 +++- runtime/api/api.cpp | 12 ++++ runtime/kernel/CMakeLists.txt | 3 +- runtime/kernel/kernel.cpp | 15 +++++ runtime/kernel/kernel.h | 3 + runtime/kernel/kernel_execution_type.h | 15 +++++ .../api/cl_set_kernel_exec_info_tests.inl | 57 +++++++++++++++++++ unit_tests/kernel/kernel_tests.cpp | 25 ++++++++ unit_tests/mocks/mock_kernel.h | 1 + 9 files changed, 140 insertions(+), 2 deletions(-) create mode 100644 runtime/kernel/kernel_execution_type.h diff --git a/public/cl_ext_private.h b/public/cl_ext_private.h index ea91e151bf..545fd34173 100644 --- a/public/cl_ext_private.h +++ b/public/cl_ext_private.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2017-2019 Intel Corporation + * Copyright (C) 2017-2020 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -16,6 +16,14 @@ #define CL_DEVICE_DRIVER_VERSION_INTEL_NEO1 0x454E4831 // Driver version is ENH1 +/********************************************* + * Internal only kernel exec info properties * + *********************************************/ + +#define CL_KERNEL_EXEC_INFO_KERNEL_TYPE_INTEL 0x1000C +#define CL_KERNEL_EXEC_INFO_DEFAULT_TYPE_INTEL 0x1000D +#define CL_KERNEL_EXEC_INFO_CONCURRENT_TYPE_INTEL 0x1000E + /********************************* * cl_intel_debug_info extension * *********************************/ @@ -41,6 +49,7 @@ * Internal only cl types * **************************/ +using cl_execution_info_kernel_type_intel = cl_uint; using cl_mem_alloc_flags_intel = cl_bitfield; using cl_mem_properties_intel = cl_bitfield; using cl_mem_flags_intel = cl_mem_flags; diff --git a/runtime/api/api.cpp b/runtime/api/api.cpp index bbe1c75872..298c08509a 100644 --- a/runtime/api/api.cpp +++ b/runtime/api/api.cpp @@ -4468,6 +4468,18 @@ cl_int CL_API_CALL clSetKernelExecInfo(cl_kernel kernel, TRACING_EXIT(clSetKernelExecInfo, &retVal); return retVal; } + case CL_KERNEL_EXEC_INFO_KERNEL_TYPE_INTEL: { + if (paramValueSize != sizeof(cl_execution_info_kernel_type_intel) || + paramValue == nullptr) { + retVal = CL_INVALID_VALUE; + TRACING_EXIT(clSetKernelExecInfo, &retVal); + return retVal; + } + auto kernelType = *static_cast(paramValue); + retVal = pKernel->setKernelExecutionType(kernelType); + TRACING_EXIT(clSetKernelExecInfo, &retVal); + return retVal; + } default: { retVal = CL_INVALID_VALUE; TRACING_EXIT(clSetKernelExecInfo, &retVal); diff --git a/runtime/kernel/CMakeLists.txt b/runtime/kernel/CMakeLists.txt index 1129d15b8a..72e8fa2fbd 100644 --- a/runtime/kernel/CMakeLists.txt +++ b/runtime/kernel/CMakeLists.txt @@ -1,5 +1,5 @@ # -# Copyright (C) 2018-2019 Intel Corporation +# Copyright (C) 2018-2020 Intel Corporation # # SPDX-License-Identifier: MIT # @@ -13,6 +13,7 @@ set(RUNTIME_SRCS_KERNEL ${CMAKE_CURRENT_SOURCE_DIR}/kernel.cpp ${CMAKE_CURRENT_SOURCE_DIR}/kernel.h ${CMAKE_CURRENT_SOURCE_DIR}/kernel.inl + ${CMAKE_CURRENT_SOURCE_DIR}/kernel_execution_type.h ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/kernel_extra.cpp ) target_sources(${NEO_STATIC_LIB_NAME} PRIVATE ${RUNTIME_SRCS_KERNEL}) diff --git a/runtime/kernel/kernel.cpp b/runtime/kernel/kernel.cpp index ff5f2b8445..892d5f89e2 100644 --- a/runtime/kernel/kernel.cpp +++ b/runtime/kernel/kernel.cpp @@ -984,6 +984,21 @@ void Kernel::clearUnifiedMemoryExecInfo() { kernelUnifiedMemoryGfxAllocations.clear(); } +cl_int Kernel::setKernelExecutionType(cl_execution_info_kernel_type_intel executionType) { + switch (executionType) { + case CL_KERNEL_EXEC_INFO_DEFAULT_TYPE_INTEL: + this->executionType = KernelExecutionType::Default; + break; + case CL_KERNEL_EXEC_INFO_CONCURRENT_TYPE_INTEL: + this->executionType = KernelExecutionType::Concurrent; + break; + default: { + return CL_INVALID_VALUE; + } + } + return CL_SUCCESS; +} + uint32_t Kernel::getMaxWorkGroupCount(const cl_uint workDim, const size_t *localWorkSize) const { auto &hardwareInfo = getDevice().getHardwareInfo(); auto executionEnvironment = kernelInfo.patchInfo.executionEnvironment; diff --git a/runtime/kernel/kernel.h b/runtime/kernel/kernel.h index 298790f6f1..ca45be8b6c 100644 --- a/runtime/kernel/kernel.h +++ b/runtime/kernel/kernel.h @@ -18,6 +18,7 @@ #include "runtime/device_queue/device_queue.h" #include "runtime/helpers/base_object.h" #include "runtime/helpers/properties_helper.h" +#include "runtime/kernel/kernel_execution_type.h" #include "runtime/program/kernel_info.h" #include "runtime/program/program.h" @@ -396,6 +397,7 @@ class Kernel : public BaseObject<_cl_kernel> { bool areStatelessWritesUsed() { return containsStatelessWrites; } int setKernelThreadArbitrationPolicy(uint32_t propertyValue); + cl_int setKernelExecutionType(cl_execution_info_kernel_type_intel executionType); void setThreadArbitrationPolicy(uint32_t policy) { this->threadArbitrationPolicy = policy; } @@ -523,6 +525,7 @@ class Kernel : public BaseObject<_cl_kernel> { uint32_t startOffset = 0; uint32_t statelessUncacheableArgsCount = 0; uint32_t threadArbitrationPolicy = ThreadArbitrationPolicy::NotPresent; + KernelExecutionType executionType = KernelExecutionType::Default; std::vector patchInfoDataList; std::unique_ptr imageTransformer; diff --git a/runtime/kernel/kernel_execution_type.h b/runtime/kernel/kernel_execution_type.h new file mode 100644 index 0000000000..d9d4746af9 --- /dev/null +++ b/runtime/kernel/kernel_execution_type.h @@ -0,0 +1,15 @@ +/* + * Copyright (C) 2020 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once + +namespace NEO { +enum class KernelExecutionType { + Default = 0x0u, + Concurrent = 0x1u +}; +} // namespace NEO diff --git a/unit_tests/api/cl_set_kernel_exec_info_tests.inl b/unit_tests/api/cl_set_kernel_exec_info_tests.inl index 18828aa2fd..c7ebeada55 100644 --- a/unit_tests/api/cl_set_kernel_exec_info_tests.inl +++ b/unit_tests/api/cl_set_kernel_exec_info_tests.inl @@ -263,4 +263,61 @@ HWTEST_F(clSetKernelExecInfoTests, givenInvalidThreadArbitrationPolicyWhenSettin ); EXPECT_EQ(CL_INVALID_VALUE, retVal); } + +HWTEST_F(clSetKernelExecInfoTests, givenInvalidParamSizeWhenSettingKernelExecutionTypeThenClInvalidValueErrorIsReturned) { + cl_execution_info_kernel_type_intel kernelExecutionType; + + retVal = clSetKernelExecInfo( + pMockKernel, // cl_kernel kernel + CL_KERNEL_EXEC_INFO_KERNEL_TYPE_INTEL, // cl_kernel_exec_info param_name + sizeof(cl_execution_info_kernel_type_intel) - 1, // size_t param_value_size + &kernelExecutionType // const void *param_value + ); + EXPECT_EQ(CL_INVALID_VALUE, retVal); +} + +HWTEST_F(clSetKernelExecInfoTests, givenInvalidParamValueWhenSettingKernelExecutionTypeThenClInvalidValueErrorIsReturned) { + retVal = clSetKernelExecInfo( + pMockKernel, // cl_kernel kernel + CL_KERNEL_EXEC_INFO_KERNEL_TYPE_INTEL, // cl_kernel_exec_info param_name + sizeof(cl_execution_info_kernel_type_intel), // size_t param_value_size + nullptr // const void *param_value + ); + EXPECT_EQ(CL_INVALID_VALUE, retVal); +} + +HWTEST_F(clSetKernelExecInfoTests, givenDifferentExecutionTypesWhenSettingAdditionalKernelInfoThenCorrectValuesAreSet) { + cl_kernel_exec_info paramName = CL_KERNEL_EXEC_INFO_KERNEL_TYPE_INTEL; + size_t paramSize = sizeof(cl_execution_info_kernel_type_intel); + cl_execution_info_kernel_type_intel kernelExecutionType = -1; + + retVal = clSetKernelExecInfo( + pMockKernel, // cl_kernel kernel + paramName, // cl_kernel_exec_info param_name + paramSize, // size_t param_value_size + &kernelExecutionType // const void *param_value + ); + EXPECT_EQ(CL_INVALID_VALUE, retVal); + + kernelExecutionType = CL_KERNEL_EXEC_INFO_DEFAULT_TYPE_INTEL; + retVal = clSetKernelExecInfo( + pMockKernel, // cl_kernel kernel + paramName, // cl_kernel_exec_info param_name + paramSize, // size_t param_value_size + &kernelExecutionType // const void *param_value + ); + EXPECT_EQ(CL_SUCCESS, retVal); + EXPECT_EQ(KernelExecutionType::Default, pMockKernel->executionType); + + kernelExecutionType = CL_KERNEL_EXEC_INFO_CONCURRENT_TYPE_INTEL; + retVal = clSetKernelExecInfo( + pMockKernel, // cl_kernel kernel + paramName, // cl_kernel_exec_info param_name + paramSize, // size_t param_value_size + &kernelExecutionType // const void *param_value + ); + EXPECT_EQ(CL_SUCCESS, retVal); + EXPECT_EQ(KernelExecutionType::Concurrent, pMockKernel->executionType); +} + } // namespace ULT diff --git a/unit_tests/kernel/kernel_tests.cpp b/unit_tests/kernel/kernel_tests.cpp index fdd01fe269..f9eb2399cf 100644 --- a/unit_tests/kernel/kernel_tests.cpp +++ b/unit_tests/kernel/kernel_tests.cpp @@ -2902,6 +2902,31 @@ TEST(KernelTest, givenPolicyWhensetKernelThreadArbitrationPolicyThenExpectedClVa EXPECT_EQ(CL_INVALID_VALUE, kernel.mockKernel->setKernelThreadArbitrationPolicy(notExistPolicy)); } +TEST(KernelTest, GivenDifferentValuesWhenSetKernelExecutionTypeIsCalledThenCorrectValueIsSet) { + auto device = std::make_unique(MockDevice::createWithNewExecutionEnvironment(platformDevices[0])); + MockKernelWithInternals mockKernelWithInternals(*device); + auto &kernel = *mockKernelWithInternals.mockKernel; + cl_int retVal; + + EXPECT_EQ(KernelExecutionType::Default, kernel.executionType); + + retVal = kernel.setKernelExecutionType(-1); + EXPECT_EQ(CL_INVALID_VALUE, retVal); + EXPECT_EQ(KernelExecutionType::Default, kernel.executionType); + + retVal = kernel.setKernelExecutionType(CL_KERNEL_EXEC_INFO_CONCURRENT_TYPE_INTEL); + EXPECT_EQ(CL_SUCCESS, retVal); + EXPECT_EQ(KernelExecutionType::Concurrent, kernel.executionType); + + retVal = kernel.setKernelExecutionType(-1); + EXPECT_EQ(CL_INVALID_VALUE, retVal); + EXPECT_EQ(KernelExecutionType::Concurrent, kernel.executionType); + + retVal = kernel.setKernelExecutionType(CL_KERNEL_EXEC_INFO_DEFAULT_TYPE_INTEL); + EXPECT_EQ(CL_SUCCESS, retVal); + EXPECT_EQ(KernelExecutionType::Default, kernel.executionType); +} + namespace NEO { template diff --git a/unit_tests/mocks/mock_kernel.h b/unit_tests/mocks/mock_kernel.h index 9d1e962ea9..23a719a107 100644 --- a/unit_tests/mocks/mock_kernel.h +++ b/unit_tests/mocks/mock_kernel.h @@ -30,6 +30,7 @@ class MockKernel : public Kernel { using Kernel::allBufferArgsStateful; using Kernel::auxTranslationRequired; using Kernel::containsStatelessWrites; + using Kernel::executionType; using Kernel::isSchedulerKernel; using Kernel::kernelArgHandlers; using Kernel::kernelArgRequiresCacheFlush;