Move vme builtins to separated target

Change-Id: I1a6bf556f8b19a8cd4da62cb814305e1fdfdd7cd
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>

CMakeLists.txt

@@ -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)

runtime/CMakeLists.txt

@@ -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}>
   )

runtime/api/api.cpp

@@ -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);

runtime/built_ins/CMakeLists.txt

@@ -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
 )
 

runtime/built_ins/built_in_ops_base.h

@@ -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

runtime/built_ins/built_in_ops_vme.h

@@ -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

runtime/built_ins/built_ins.cpp

@@ -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;

runtime/built_ins/built_ins.h

@@ -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() {

runtime/built_ins/built_ins_storage.cpp

@@ -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";
     };
 }
 

runtime/built_ins/builtinops/built_in_ops.h

@@ -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

runtime/built_ins/registry/CMakeLists.txt

@@ -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}
+)

runtime/built_ins/registry/register_ext_vme_source.cpp

@@ -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>

runtime/built_ins/vme_builtin.cpp

@@ -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

runtime/built_ins/vme_builtin.h

@@ -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

runtime/built_ins/vme_dispatch_builder.h

@@ -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"

unit_tests/CMakeLists.txt

@@ -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}>
 )

unit_tests/api/cl_create_program_with_built_in_kernels_tests.cpp

@@ -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 = Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockMotionEstimateIntel, *pDev);
-    auto &vmeBuilder = pDev->getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(NEO::EBuiltInOps::VmeBlockMotionEstimateIntel, ctxNeo->getDevice(0)->getDevice());
     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 = Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, *pDev);
-    auto &vmeBuilder = pDev->getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(NEO::EBuiltInOps::VmeBlockAdvancedMotionEstimateCheckIntel, ctxNeo->getDevice(0)->getDevice());
     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);

unit_tests/built_ins/built_in_tests.cpp

@@ -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);