Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Move vme builtins to separated target

Browse Source 
Change-Id: I1a6bf556f8b19a8cd4da62cb814305e1fdfdd7cd
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2020-02-20 16:00:19 +01:00
committed by sys_ocldev
parent 176fd39621
commit 21aa550dba
18 changed files with 222 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -837,6 +837,7 @@ macro(generate_runtime_lib LIB_NAME MOCKABLE GENERATE_EXEC)
add_subdirectory(runtime "${NEO_BUILD_DIR}/${LIB_NAME}" EXCLUDE_FROM_ALL)
endif()
target_compile_definitions(${BUILTINS_SOURCES_LIB_NAME} PUBLIC MOCKABLE_VIRTUAL=)
target_compile_definitions(${BUILTINS_VME_LIB_NAME} PUBLIC MOCKABLE_VIRTUAL=)
target_compile_definitions(${BUILTINS_BINARIES_LIB_NAME} PUBLIC MOCKABLE_VIRTUAL=)
target_compile_definitions(${SCHEDULER_BINARY_LIB_NAME} PUBLIC MOCKABLE_VIRTUAL=)
@ -857,6 +858,7 @@ set(NEO_DLL_NAME_BASE "igdrcl")
set(BIKSIM_LIB_NAME "biksim")
set(BUILTINS_SOURCES_LIB_NAME "builtins_sources")
set(BUILTINS_BINARIES_LIB_NAME "builtins_binaries")
set(BUILTINS_VME_LIB_NAME "builtins_vme")
set(SCHEDULER_BINARY_LIB_NAME "scheduler_binary")
if(DONT_CARE_OF_VIRTUALS)

1
runtime/CMakeLists.txt
View File

@ -116,6 +116,7 @@ if(${GENERATE_EXECUTABLE})
list(APPEND NEO_DYNAMIC_LIB__TARGET_OBJECTS
$<TARGET_OBJECTS:${SHARINGS_ENABLE_LIB_NAME}>
$<TARGET_OBJECTS:${BUILTINS_SOURCES_LIB_NAME}>
$<TARGET_OBJECTS:${BUILTINS_VME_LIB_NAME}>
$<TARGET_OBJECTS:${BUILTINS_BINARIES_LIB_NAME}>
$<TARGET_OBJECTS:${SCHEDULER_BINARY_LIB_NAME}>
)

5
runtime/api/api.cpp
View File

@ -21,6 +21,7 @@
#include "runtime/api/additional_extensions.h"
#include "runtime/aub/aub_center.h"
#include "runtime/built_ins/built_ins.h"
#include "runtime/built_ins/vme_builtin.h"
#include "runtime/command_queue/command_queue.h"
#include "runtime/command_stream/command_stream_receiver.h"
#include "runtime/context/context.h"
@ -1367,9 +1368,11 @@ cl_program CL_API_CALL clCreateProgramWithBuiltInKernels(cl_context context,
if (retVal == CL_SUCCESS) {
for (cl_uint i = 0; i < numDevices; i++) {
auto pContext = castToObject<Context>(context);
auto pDevice = castToObject<ClDevice>(*deviceList);
program = pDevice->getExecutionEnvironment()->getBuiltIns()->createBuiltInProgram(
program = Vme::createBuiltInProgram(
*pContext,
pDevice->getDevice(),
kernelNames,
retVal);

3
runtime/built_ins/CMakeLists.txt
View File

@ -12,10 +12,13 @@ set(RUNTIME_SRCS_BUILT_INS
${CMAKE_CURRENT_SOURCE_DIR}/built_ins.cpp
${CMAKE_CURRENT_SOURCE_DIR}/built_ins.h
${CMAKE_CURRENT_SOURCE_DIR}/built_in_ops_base.h
${CMAKE_CURRENT_SOURCE_DIR}/built_in_ops_vme.h
${CMAKE_CURRENT_SOURCE_DIR}/built_ins.inl
${CMAKE_CURRENT_SOURCE_DIR}/sip.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sip.h
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/unknown_built_in_name.cpp
${CMAKE_CURRENT_SOURCE_DIR}/vme_builtin.cpp
${CMAKE_CURRENT_SOURCE_DIR}/vme_builtin.h
${CMAKE_CURRENT_SOURCE_DIR}/vme_dispatch_builder.h
)

7
runtime/built_ins/built_in_ops_base.h
View File

@ -5,6 +5,7 @@
*
*/
#pragma once
#include <cstdint>
namespace NEO {
@ -29,10 +30,8 @@ constexpr Type CopyImageToImage3d{13};
constexpr Type FillImage1d{14};
constexpr Type FillImage2d{15};
constexpr Type FillImage3d{16};
constexpr Type VmeBlockMotionEstimateIntel{17};
constexpr Type VmeBlockAdvancedMotionEstimateCheckIntel{18};
constexpr Type VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel{19};
constexpr uint32_t MaxBaseValue{19};
constexpr Type MaxBaseValue{16};
constexpr Type COUNT{64};
} // namespace EBuiltInOps
} // namespace NEO

20
runtime/built_ins/built_in_ops_vme.h Normal file
View File

@ -0,0 +1,20 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "built_in_ops.h"
namespace NEO {
namespace EBuiltInOps {
using Type = uint32_t;
constexpr Type VmeBlockMotionEstimateIntel{MaxCoreValue + 1};
constexpr Type VmeBlockAdvancedMotionEstimateCheckIntel{MaxCoreValue + 2};
constexpr Type VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel{MaxCoreValue + 3};
} // namespace EBuiltInOps
} // namespace NEO

82
runtime/built_ins/built_ins.cpp
View File

@ -13,7 +13,6 @@
#include "runtime/built_ins/aux_translation_builtin.h"
#include "runtime/built_ins/built_ins.inl"
#include "runtime/built_ins/sip.h"
#include "runtime/built_ins/vme_dispatch_builder.h"
#include "runtime/device/cl_device.h"
#include "runtime/helpers/built_ins_helper.h"
#include "runtime/helpers/convert_color.h"
@ -72,78 +71,6 @@ const SipKernel &BuiltIns::getSipKernel(SipKernelType type, Device &device) {
return *sipBuiltIn.first;
}
// VME:
static const char *blockMotionEstimateIntelSrc = {
#include "kernels/vme_block_motion_estimate_intel_frontend.igdrcl_built_in"
};
static const char *blockAdvancedMotionEstimateCheckIntelSrc = {
#include "kernels/vme_block_advanced_motion_estimate_check_intel_frontend.igdrcl_built_in"
};
static const char *blockAdvancedMotionEstimateBidirectionalCheckIntelSrc = {
#include "kernels/vme_block_advanced_motion_estimate_bidirectional_check_intel_frontend.igdrcl_built_in"
};
static const std::tuple<const char *, const char *> mediaBuiltIns[] = {
std::make_tuple("block_motion_estimate_intel", blockMotionEstimateIntelSrc),
std::make_tuple("block_advanced_motion_estimate_check_intel", blockAdvancedMotionEstimateCheckIntelSrc),
std::make_tuple("block_advanced_motion_estimate_bidirectional_check_intel", blockAdvancedMotionEstimateBidirectionalCheckIntelSrc),
};
// Unlike other built-ins media kernels are not stored in BuiltIns object.
// Pointer to program with built in kernels is returned to the user through API
// call and user is responsible for releasing it by calling clReleaseProgram.
Program *BuiltIns::createBuiltInProgram(
Device &device,
const char *kernelNames,
int &errcodeRet) {
std::string programSourceStr = "";
std::istringstream ss(kernelNames);
std::string currentKernelName;
while (std::getline(ss, currentKernelName, ';')) {
bool found = false;
for (auto &builtInTuple : mediaBuiltIns) {
if (currentKernelName == std::get<0>(builtInTuple)) {
programSourceStr += std::get<1>(builtInTuple);
found = true;
break;
}
}
if (!found) {
errcodeRet = CL_INVALID_VALUE;
return nullptr;
}
}
if (programSourceStr.empty() == true) {
errcodeRet = CL_INVALID_VALUE;
return nullptr;
}
Program *pBuiltInProgram = nullptr;
pBuiltInProgram = Program::create(programSourceStr.c_str(), nullptr, device, true, nullptr);
if (pBuiltInProgram) {
std::unordered_map<std::string, BuiltinDispatchInfoBuilder *> builtinsBuilders;
builtinsBuilders["block_motion_estimate_intel"] =
&device.getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockMotionEstimateIntel, device);
builtinsBuilders["block_advanced_motion_estimate_check_intel"] =
&device.getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, device);
builtinsBuilders["block_advanced_motion_estimate_bidirectional_check_intel"] =
&device.getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel, device);
errcodeRet = pBuiltInProgram->build(
&device,
mediaKernelsBuildOptions,
enableCacheing,
builtinsBuilders);
} else {
errcodeRet = CL_INVALID_VALUE;
}
return pBuiltInProgram;
}
template <>
class BuiltInOp<EBuiltInOps::CopyBufferToBuffer> : public BuiltinDispatchInfoBuilder {
public:
@ -866,15 +793,6 @@ BuiltinDispatchInfoBuilder &BuiltIns::getBuiltinDispatchInfoBuilder(EBuiltInOps:
case EBuiltInOps::FillImage3d:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::FillImage3d>>(*this, device); });
break;
case EBuiltInOps::VmeBlockMotionEstimateIntel:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::VmeBlockMotionEstimateIntel>>(*this, device); });
break;
case EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel>>(*this, device); });
break;
case EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel>>(*this, device); });
break;
case EBuiltInOps::AuxTranslation:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::AuxTranslation>>(*this, device); });
break;

6
runtime/built_ins/built_ins.h
View File

@ -53,6 +53,7 @@ std::string createBuiltinResourceName(EBuiltInOps::Type builtin, const std::stri
std::string joinPath(const std::string &lhs, const std::string &rhs);
const char *getBuiltinAsString(EBuiltInOps::Type builtin);
const char *getUnknownBuiltinAsString(EBuiltInOps::Type builtin);
const char *getAdditionalBuiltinAsString(EBuiltInOps::Type builtin);
class Storage {
public:
@ -174,11 +175,6 @@ class BuiltIns {
BuiltIns();
virtual ~BuiltIns();
Program *createBuiltInProgram(
Device &device,
const char *kernelNames,
int &errcodeRet);
MOCKABLE_VIRTUAL const SipKernel &getSipKernel(SipKernelType type, Device &device);
BuiltinsLib &getBuiltinsLib() {

10
runtime/built_ins/built_ins_storage.cpp
View File

@ -17,6 +17,10 @@
namespace NEO {
const char *getBuiltinAsString(EBuiltInOps::Type builtin) {
const char *builtinString = getAdditionalBuiltinAsString(builtin);
if (builtinString) {
return builtinString;
}
switch (builtin) {
default:
return getUnknownBuiltinAsString(builtin);
@ -54,12 +58,6 @@ const char *getBuiltinAsString(EBuiltInOps::Type builtin) {
return "fill_image2d.igdrcl_built_in";
case EBuiltInOps::FillImage3d:
return "fill_image3d.igdrcl_built_in";
case EBuiltInOps::VmeBlockMotionEstimateIntel:
return "vme_block_motion_estimate_intel.igdrcl_built_in";
case EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel:
return "vme_block_advanced_motion_estimate_check_intel.igdrcl_built_in";
case EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel:
return "vme_block_advanced_motion_estimate_bidirectional_check_intel";
};
}

5
runtime/built_ins/builtinops/built_in_ops.h
View File

@ -1,14 +1,15 @@
/*
* Copyright (C) 2019 Intel Corporation
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "runtime/built_ins/built_in_ops_base.h"
namespace NEO {
namespace EBuiltInOps {
constexpr Type COUNT{MaxBaseValue + 1};
constexpr Type MaxCoreValue{MaxBaseValue};
}
} // namespace NEO

12
runtime/built_ins/registry/CMakeLists.txt
View File

@ -8,7 +8,6 @@ add_library(${BUILTINS_SOURCES_LIB_NAME} OBJECT EXCLUDE_FROM_ALL
CMakeLists.txt
built_ins_registry.h
register_copy_kernels_source.cpp
register_ext_vme_source.cpp
)
set_target_properties(${BUILTINS_SOURCES_LIB_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
@ -24,3 +23,14 @@ target_include_directories(${BUILTINS_SOURCES_LIB_NAME} PRIVATE
)
add_subdirectories()
add_library(${BUILTINS_VME_LIB_NAME} OBJECT EXCLUDE_FROM_ALL
CMakeLists.txt
register_ext_vme_source.cpp
)
set_target_properties(${BUILTINS_VME_LIB_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
set_target_properties(${BUILTINS_VME_LIB_NAME} PROPERTIES FOLDER "built_ins")
target_include_directories(${BUILTINS_VME_LIB_NAME} PRIVATE
${KHRONOS_HEADERS_DIR}
)

3
runtime/built_ins/registry/register_ext_vme_source.cpp
View File

@ -1,10 +1,11 @@
/*
* Copyright (C) 2017-2019 Intel Corporation
* Copyright (C) 2017-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "runtime/built_ins/built_in_ops_vme.h"
#include "runtime/built_ins/registry/built_ins_registry.h"
#include <string>

120
runtime/built_ins/vme_builtin.cpp Normal file
View File

@ -0,0 +1,120 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "runtime/built_ins/vme_builtin.h"
#include "core/device/device.h"
#include "runtime/built_ins/built_in_ops_vme.h"
#include "runtime/built_ins/built_ins.h"
#include "runtime/built_ins/builtins_dispatch_builder.h"
#include "runtime/built_ins/populate_built_ins.inl"
#include "runtime/built_ins/vme_dispatch_builder.h"
#include "runtime/program/program.h"
namespace NEO {
static const char *blockMotionEstimateIntelSrc = {
#include "kernels/vme_block_motion_estimate_intel_frontend.igdrcl_built_in"
};
static const char *blockAdvancedMotionEstimateCheckIntelSrc = {
#include "kernels/vme_block_advanced_motion_estimate_check_intel_frontend.igdrcl_built_in"
};
static const char *blockAdvancedMotionEstimateBidirectionalCheckIntelSrc = {
#include "kernels/vme_block_advanced_motion_estimate_bidirectional_check_intel_frontend.igdrcl_built_in"
};
static const std::tuple<const char *, const char *> mediaBuiltIns[] = {
std::make_tuple("block_motion_estimate_intel", blockMotionEstimateIntelSrc),
std::make_tuple("block_advanced_motion_estimate_check_intel", blockAdvancedMotionEstimateCheckIntelSrc),
std::make_tuple("block_advanced_motion_estimate_bidirectional_check_intel", blockAdvancedMotionEstimateBidirectionalCheckIntelSrc),
};
// Unlike other built-ins media kernels are not stored in BuiltIns object.
// Pointer to program with built in kernels is returned to the user through API
// call and user is responsible for releasing it by calling clReleaseProgram.
Program *Vme::createBuiltInProgram(
Context &context,
Device &device,
const char *kernelNames,
int &errcodeRet) {
std::string programSourceStr = "";
std::istringstream ss(kernelNames);
std::string currentKernelName;
while (std::getline(ss, currentKernelName, ';')) {
bool found = false;
for (auto &builtInTuple : mediaBuiltIns) {
if (currentKernelName == std::get<0>(builtInTuple)) {
programSourceStr += std::get<1>(builtInTuple);
found = true;
break;
}
}
if (!found) {
errcodeRet = CL_INVALID_VALUE;
return nullptr;
}
}
if (programSourceStr.empty() == true) {
errcodeRet = CL_INVALID_VALUE;
return nullptr;
}
Program *pBuiltInProgram = nullptr;
pBuiltInProgram = Program::create(programSourceStr.c_str(), &context, device, true, nullptr);
if (pBuiltInProgram) {
std::unordered_map<std::string, BuiltinDispatchInfoBuilder *> builtinsBuilders;
builtinsBuilders["block_motion_estimate_intel"] =
&Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockMotionEstimateIntel, device);
builtinsBuilders["block_advanced_motion_estimate_check_intel"] =
&Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, device);
builtinsBuilders["block_advanced_motion_estimate_bidirectional_check_intel"] =
&Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel, device);
errcodeRet = pBuiltInProgram->build(&device, mediaKernelsBuildOptions, true, builtinsBuilders);
} else {
errcodeRet = CL_INVALID_VALUE;
}
return pBuiltInProgram;
}
const char *getAdditionalBuiltinAsString(EBuiltInOps::Type builtin) {
switch (builtin) {
default:
return nullptr;
case EBuiltInOps::VmeBlockMotionEstimateIntel:
return "vme_block_motion_estimate_intel.igdrcl_built_in";
case EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel:
return "vme_block_advanced_motion_estimate_check_intel.igdrcl_built_in";
case EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel:
return "vme_block_advanced_motion_estimate_bidirectional_check_intel";
}
}
BuiltinDispatchInfoBuilder &Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::Type operation, Device &device) {
auto &builtins = *device.getExecutionEnvironment()->getBuiltIns();
uint32_t operationId = static_cast<uint32_t>(operation);
auto &operationBuilder = builtins.BuiltinOpsBuilders[operationId];
switch (operation) {
default:
return builtins.getBuiltinDispatchInfoBuilder(operation, device);
case EBuiltInOps::VmeBlockMotionEstimateIntel:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::VmeBlockMotionEstimateIntel>>(builtins, device); });
break;
case EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel>>(builtins, device); });
break;
case EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel>>(builtins, device); });
break;
}
return *operationBuilder.first;
}
} // namespace NEO

28
runtime/built_ins/vme_builtin.h Normal file
View File

@ -0,0 +1,28 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "runtime/built_ins/built_in_ops_vme.h"
namespace NEO {
class Program;
class Device;
class Context;
class BuiltIns;
class BuiltinDispatchInfoBuilder;
namespace Vme {
Program *createBuiltInProgram(
Context &context,
Device &device,
const char *kernelNames,
int &errcodeRet);
BuiltinDispatchInfoBuilder &getBuiltinDispatchInfoBuilder(EBuiltInOps::Type operation, Device &device);
} // namespace Vme
} // namespace NEO

1
runtime/built_ins/vme_dispatch_builder.h
View File

@ -9,6 +9,7 @@
#include "runtime/accelerators/intel_accelerator.h"
#include "runtime/accelerators/intel_motion_estimation.h"
#include "runtime/built_ins/built_in_ops_vme.h"
#include "runtime/built_ins/built_ins.h"
#include "runtime/built_ins/builtins_dispatch_builder.h"
#include "runtime/helpers/dispatch_info_builder.h"

1
unit_tests/CMakeLists.txt
View File

@ -84,6 +84,7 @@ set(NEO_IGDRCL_TESTS__TARGET_OBJECTS
$<TARGET_OBJECTS:mock_gmm>
$<TARGET_OBJECTS:${SHARINGS_ENABLE_LIB_NAME}>
$<TARGET_OBJECTS:${BUILTINS_SOURCES_LIB_NAME}>
$<TARGET_OBJECTS:${BUILTINS_VME_LIB_NAME}>
$<TARGET_OBJECTS:${BUILTINS_BINARIES_LIB_NAME}>
$<TARGET_OBJECTS:${SCHEDULER_BINARY_LIB_NAME}>
)

16
unit_tests/api/cl_create_program_with_built_in_kernels_tests.cpp
View File

@ -7,7 +7,9 @@
#include "core/compiler_interface/compiler_interface.h"
#include "core/device/device.h"
#include "runtime/built_ins/built_in_ops_vme.h"
#include "runtime/built_ins/built_ins.h"
#include "runtime/built_ins/vme_builtin.h"
#include "runtime/context/context.h"
#include "runtime/device/cl_device.h"
#include "runtime/helpers/base_object.h"
@ -154,7 +156,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockMotionEstimateKer
cl_int retVal = CL_SUCCESS;
overwriteBuiltInBinaryName(pDev, "media_kernels_backend");
pDev->getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockMotionEstimateIntel, *pDev);
Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockMotionEstimateIntel, *pDev);
restoreBuiltInBinaryName(pDev);
overwriteBuiltInBinaryName(pDev, "media_kernels_frontend");
@ -179,8 +181,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockMotionEstimateKer
EXPECT_NE(nullptr, kernNeo->getKernelInfo().builtinDispatchBuilder);
EXPECT_EQ(6U, kernNeo->getKernelArgsNumber());
auto ctxNeo = castToObject<Context>(pContext);
auto &vmeBuilder = pDev->getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(NEO::EBuiltInOps::VmeBlockMotionEstimateIntel, ctxNeo->getDevice(0)->getDevice());
auto &vmeBuilder = Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockMotionEstimateIntel, *pDev);
EXPECT_EQ(&vmeBuilder, kernNeo->getKernelInfo().builtinDispatchBuilder);
clReleaseKernel(kernel);
@ -191,7 +192,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockAdvancedMotionEst
cl_int retVal = CL_SUCCESS;
overwriteBuiltInBinaryName(pDev, "media_kernels_backend");
pDev->getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, *pDev);
Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, *pDev);
restoreBuiltInBinaryName(pDev);
overwriteBuiltInBinaryName(pDev, "media_kernels_frontend");
@ -216,8 +217,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockAdvancedMotionEst
EXPECT_NE(nullptr, kernNeo->getKernelInfo().builtinDispatchBuilder);
EXPECT_EQ(15U, kernNeo->getKernelArgsNumber());
auto ctxNeo = castToObject<Context>(pContext);
auto &vmeBuilder = pDev->getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(NEO::EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, ctxNeo->getDevice(0)->getDevice());
auto &vmeBuilder = Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, *pDev);
EXPECT_EQ(&vmeBuilder, kernNeo->getKernelInfo().builtinDispatchBuilder);
clReleaseKernel(kernel);
@ -228,7 +228,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockAdvancedMotionEst
cl_int retVal = CL_SUCCESS;
overwriteBuiltInBinaryName(pDev, "media_kernels_backend");
pDev->getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel, *pDev);
Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel, *pDev);
restoreBuiltInBinaryName(pDev);
overwriteBuiltInBinaryName(pDev, "media_kernels_frontend");
@ -254,7 +254,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockAdvancedMotionEst
EXPECT_EQ(20U, kernNeo->getKernelArgsNumber());
auto ctxNeo = castToObject<Context>(pContext);
auto &vmeBuilder = pDev->getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(NEO::EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel, ctxNeo->getDevice(0)->getDevice());
auto &vmeBuilder = Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel, ctxNeo->getDevice(0)->getDevice());
EXPECT_EQ(&vmeBuilder, kernNeo->getKernelInfo().builtinDispatchBuilder);
clReleaseKernel(kernel);

15
unit_tests/built_ins/built_in_tests.cpp
View File

@ -16,6 +16,7 @@
#include "runtime/built_ins/aux_translation_builtin.h"
#include "runtime/built_ins/built_ins.h"
#include "runtime/built_ins/builtins_dispatch_builder.h"
#include "runtime/built_ins/vme_builtin.h"
#include "runtime/built_ins/vme_dispatch_builder.h"
#include "runtime/helpers/dispatch_info_builder.h"
#include "runtime/kernel/kernel.h"
@ -971,18 +972,21 @@ TEST_F(VmeBuiltInTests, BuiltinDispatchInfoBuilderGetVMEBuilderReturnNonNull) {
EBuiltInOps::Type vmeOps[] = {EBuiltInOps::VmeBlockMotionEstimateIntel, EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel};
for (auto op : vmeOps) {
BuiltinDispatchInfoBuilder &builder = pBuiltIns->getBuiltinDispatchInfoBuilder(op, *pDevice);
BuiltinDispatchInfoBuilder &builder = Vme::getBuiltinDispatchInfoBuilder(op, *pDevice);
EXPECT_NE(nullptr, &builder);
}
restoreBuiltInBinaryName(pDevice);
}
TEST_F(VmeBuiltInTests, givenInvalidBuiltInOpWhenGetVmeBuilderInfoThenExceptionIsThrown) {
EXPECT_THROW(Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::COUNT, *pDevice), std::exception);
}
TEST_F(VmeBuiltInTests, BuiltinDispatchInfoBuilderVMEBuilderNullKernel) {
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
EBuiltInOps::Type vmeOps[] = {EBuiltInOps::VmeBlockMotionEstimateIntel, EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, EBuiltInOps::VmeBlockAdvancedMotionEstimateBidirectionalCheckIntel};
for (auto op : vmeOps) {
BuiltinDispatchInfoBuilder &builder = pBuiltIns->getBuiltinDispatchInfoBuilder(op, *pDevice);
BuiltinDispatchInfoBuilder &builder = Vme::getBuiltinDispatchInfoBuilder(op, *pDevice);
MultiDispatchInfo outMdi;
Vec3<size_t> gws{352, 288, 0};
@ -1004,7 +1008,7 @@ TEST_F(VmeBuiltInTests, BuiltinDispatchInfoBuilderVMEBuilder) {
mockKernel.kernelInfo.reqdWorkGroupSize[2] = 0;
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
BuiltinDispatchInfoBuilder &builder = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockMotionEstimateIntel, *pDevice);
BuiltinDispatchInfoBuilder &builder = Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockMotionEstimateIntel, *pDevice);
restoreBuiltInBinaryName(pDevice);
MultiDispatchInfo outMdi;
@ -1071,7 +1075,7 @@ TEST_F(VmeBuiltInTests, BuiltinDispatchInfoBuilderAdvancedVMEBuilder) {
for (auto op : vmeOps) {
MultiDispatchInfo outMdi;
overwriteBuiltInBinaryName(pDevice, "media_kernels_backend");
BuiltinDispatchInfoBuilder &builder = pBuiltIns->getBuiltinDispatchInfoBuilder(op, *pDevice);
BuiltinDispatchInfoBuilder &builder = Vme::getBuiltinDispatchInfoBuilder(op, *pDevice);
restoreBuiltInBinaryName(pDevice);
bool ret = builder.setExplicitArg(srcImageArgNum, sizeof(cl_mem), &srcImageArg, err);
@ -1984,7 +1988,8 @@ TEST_F(BuiltInTests, createBuiltInProgramForInvalidBuiltinKernelName) {
const char *kernelNames = "invalid_kernel";
cl_int retVal = CL_SUCCESS;
cl_program program = pDevice->getExecutionEnvironment()->getBuiltIns()->createBuiltInProgram(
cl_program program = Vme::createBuiltInProgram(
*pContext,
*pDevice,
kernelNames,
retVal);