Test DRM query, bind, context create

Signed-off-by: Daniel Chabrowski daniel.chabrowski@intel.com
Related-To: NEO-6591

shared/test/common/libult/linux/drm_mock_prelim_context.cpp

@@ -55,6 +55,15 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
             return 0;
         }
     } break;
+    case DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT: {
+        auto create = static_cast<drm_i915_gem_context_create_ext *>(arg);
+        auto setParam = reinterpret_cast<drm_i915_gem_context_create_ext_setparam *>(create->extensions);
+        if (setParam->param.param == PRELIM_I915_CONTEXT_PARAM_ACC) {
+            const auto paramAcc = reinterpret_cast<prelim_drm_i915_gem_context_param_acc *>(setParam->param.value);
+            receivedContextParamAcc = GemContextParamAcc{paramAcc->trigger, paramAcc->notify, paramAcc->granularity};
+        }
+        return 0;
+    } break;
     case PRELIM_DRM_IOCTL_I915_GEM_CLOS_RESERVE: {
         auto closReserveArg = static_cast<prelim_drm_i915_gem_clos_reserve *>(arg);
         closIndex++;
@@ -62,6 +71,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
             return EINVAL;
         }
         closReserveArg->clos_index = closIndex;
+        return 0;
     } break;
     case PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE: {
         auto closFreeArg = static_cast<prelim_drm_i915_gem_clos_free *>(arg);
@@ -69,6 +79,7 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
             return EINVAL;
         }
         closIndex--;
+        return 0;
     } break;
     case PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE: {
         auto cacheReserveArg = static_cast<prelim_drm_i915_gem_cache_reserve *>(arg);
@@ -85,13 +96,25 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
             return EINVAL;
         }
         allocNumWays += cacheReserveArg->num_ways;
+        return 0;
     } break;
     case PRELIM_DRM_IOCTL_I915_GEM_VM_BIND: {
         vmBindCalled++;
+        const auto vmBind = reinterpret_cast<prelim_drm_i915_gem_vm_bind *>(arg);
+        receivedVmBind = VmBindParams{
+            vmBind->vm_id,
+            vmBind->handle,
+            vmBind->start,
+            vmBind->offset,
+            vmBind->length,
+            vmBind->flags,
+            vmBind->extensions,
+        };
         return vmBindReturn;
     } break;
     case PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND: {
         vmUnbindCalled++;
+        vmUnbindHandle = reinterpret_cast<prelim_drm_i915_gem_vm_bind *>(arg)->handle;
         return vmUnbindReturn;
     } break;
     case PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT: {
@@ -132,6 +155,22 @@ int DrmMockPrelimContext::handlePrelimRequest(unsigned long request, void *arg)
         if ((firstMemoryRegion.memoryClass != PRELIM_I915_MEMORY_CLASS_SYSTEM) && (firstMemoryRegion.memoryClass != PRELIM_I915_MEMORY_CLASS_DEVICE)) {
             return EINVAL;
         }
+        return 0;
+    } break;
+    case PRELIM_DRM_IOCTL_I915_GEM_WAIT_USER_FENCE: {
+        waitUserFenceCalled++;
+        const auto wait = reinterpret_cast<prelim_drm_i915_gem_wait_user_fence *>(arg);
+        receivedWaitUserFence = WaitUserFence{
+            wait->extensions,
+            wait->addr,
+            wait->ctx_id,
+            wait->op,
+            wait->flags,
+            wait->value,
+            wait->mask,
+            wait->timeout,
+        };
+        return 0;
     } break;
     case PRELIM_DRM_IOCTL_I915_UUID_REGISTER: {
         auto uuidControl = reinterpret_cast<prelim_drm_i915_uuid_control *>(arg);
@@ -350,3 +389,47 @@ uint32_t DrmPrelimHelper::getComputeEngineClass() {
 uint32_t DrmPrelimHelper::getStringUuidClass() {
     return PRELIM_I915_UUID_CLASS_STRING;
 }
+
+uint32_t DrmPrelimHelper::getULLSContextCreateFlag() {
+    return PRELIM_I915_CONTEXT_CREATE_FLAGS_ULLS;
+}
+
+uint32_t DrmPrelimHelper::getRunAloneContextParam() {
+    return PRELIM_I915_CONTEXT_PARAM_RUNALONE;
+}
+
+uint32_t DrmPrelimHelper::getAccContextParam() {
+    return PRELIM_I915_CONTEXT_PARAM_ACC;
+}
+
+uint32_t DrmPrelimHelper::getAccContextParamSize() {
+    return sizeof(prelim_drm_i915_gem_context_param_acc);
+}
+
+std::array<uint32_t, 4> DrmPrelimHelper::getContextAcgValues() {
+    return {PRELIM_I915_CONTEXT_ACG_128K, PRELIM_I915_CONTEXT_ACG_2M, PRELIM_I915_CONTEXT_ACG_16M, PRELIM_I915_CONTEXT_ACG_64M};
+}
+
+uint32_t DrmPrelimHelper::getEnablePageFaultVmCreateFlag() {
+    return PRELIM_I915_VM_CREATE_FLAGS_ENABLE_PAGE_FAULT;
+}
+
+uint32_t DrmPrelimHelper::getDisableScratchVmCreateFlag() {
+    return PRELIM_I915_VM_CREATE_FLAGS_DISABLE_SCRATCH;
+}
+
+uint64_t DrmPrelimHelper::getU8WaitUserFenceFlag() {
+    return PRELIM_I915_UFENCE_WAIT_U8;
+}
+
+uint64_t DrmPrelimHelper::getU16WaitUserFenceFlag() {
+    return PRELIM_I915_UFENCE_WAIT_U16;
+}
+
+uint64_t DrmPrelimHelper::getCaptureVmBindFlag() {
+    return PRELIM_I915_GEM_VM_BIND_CAPTURE;
+}
+
+uint64_t DrmPrelimHelper::getImmediateVmBindFlag() {
+    return PRELIM_I915_GEM_VM_BIND_IMMEDIATE;
+}

shared/test/common/libult/linux/drm_mock_prelim_context.h

@@ -10,6 +10,7 @@
 #include "shared/source/execution_environment/root_device_environment.h"
 #include "shared/source/helpers/hw_info.h"
 #include "shared/source/os_interface/linux/cache_info.h"
+#include "shared/source/os_interface/linux/ioctl_helper.h"
 
 #include <optional>
 #include <vector>
@@ -37,6 +38,23 @@ struct CreateGemExt {
     std::vector<MemoryClassInstance> memoryRegions{};
 };
 
+struct GemContextParamAcc {
+    uint16_t trigger{0};
+    uint16_t notify{0};
+    uint8_t granularity{0};
+};
+
+struct WaitUserFence {
+    uint64_t extensions{0};
+    uint64_t addr{0};
+    uint32_t ctxId{0};
+    uint16_t op{0};
+    uint16_t flags{0};
+    uint64_t value{0};
+    uint64_t mask{0};
+    int64_t timeout{0};
+};
+
 struct DrmMockPrelimContext {
     const HardwareInfo *hwInfo;
     const RootDeviceEnvironment &rootDeviceEnvironment;
@@ -54,9 +72,11 @@ struct DrmMockPrelimContext {
     int vmBindQueryReturn{0};
 
     size_t vmBindCalled{0};
+    std::optional<VmBindParams> receivedVmBind{};
     int vmBindReturn{0};
 
     size_t vmUnbindCalled{0};
+    std::optional<uint32_t> vmUnbindHandle{};
     int vmUnbindReturn{0};
 
     int hasPageFaultQueryValue{0};
@@ -64,6 +84,9 @@ struct DrmMockPrelimContext {
 
     uint32_t queryMemoryRegionInfoSuccessCount{std::numeric_limits<uint32_t>::max()};
 
+    size_t waitUserFenceCalled{0};
+    std::optional<WaitUserFence> receivedWaitUserFence{};
+
     uint32_t uuidHandle{1};
     std::optional<UuidControl> receivedRegisterUuid{};
     std::optional<UuidControl> receivedUnregisterUuid{};
@@ -71,6 +94,7 @@ struct DrmMockPrelimContext {
     int uuidControlReturn{0};
 
     std::optional<CreateGemExt> receivedCreateGemExt{};
+    std::optional<GemContextParamAcc> receivedContextParamAcc{};
 
     bool failDistanceInfoQuery{false};
     bool disableCcsSupport{false};
@@ -84,4 +108,15 @@ uint32_t getQueryComputeSlicesIoctl();
 uint32_t getDistanceInfoQueryId();
 uint32_t getComputeEngineClass();
 uint32_t getStringUuidClass();
+uint32_t getULLSContextCreateFlag();
+uint32_t getRunAloneContextParam();
+uint32_t getAccContextParam();
+uint32_t getAccContextParamSize();
+std::array<uint32_t, 4> getContextAcgValues();
+uint32_t getEnablePageFaultVmCreateFlag();
+uint32_t getDisableScratchVmCreateFlag();
+uint64_t getU8WaitUserFenceFlag();
+uint64_t getU16WaitUserFenceFlag();
+uint64_t getCaptureVmBindFlag();
+uint64_t getImmediateVmBindFlag();
 }; // namespace DrmPrelimHelper

shared/test/unit_test/os_interface/linux/CMakeLists.txt

@@ -24,6 +24,7 @@ if(NEO_ENABLE_i915_PRELIM_DETECTION)
   list(APPEND NEO_CORE_OS_INTERFACE_TESTS_LINUX
        ${CMAKE_CURRENT_SOURCE_DIR}/drm_cache_info_tests.cpp
        ${CMAKE_CURRENT_SOURCE_DIR}/drm_debug_prelim_tests.cpp
+       ${CMAKE_CURRENT_SOURCE_DIR}/drm_query_prelim_tests.cpp
        ${CMAKE_CURRENT_SOURCE_DIR}/drm_query_topology_prelim_tests.cpp
        ${CMAKE_CURRENT_SOURCE_DIR}/drm_memory_info_prelim_tests.cpp
        ${CMAKE_CURRENT_SOURCE_DIR}/drm_with_prelim_tests.cpp

shared/test/unit_test/os_interface/linux/drm_query_prelim_tests.cpp

@@ -0,0 +1,419 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/os_interface/linux/drm_buffer_object.h"
+#include "shared/source/os_interface/linux/os_context_linux.h"
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/helpers/engine_descriptor_helper.h"
+#include "shared/test/common/libult/linux/drm_mock_prelim_context.h"
+#include "shared/test/common/libult/linux/drm_query_mock.h"
+#include "shared/test/common/mocks/linux/mock_drm_allocation.h"
+
+#include "gtest/gtest.h"
+
+using namespace NEO;
+
+namespace NEO {
+namespace SysCalls {
+extern uint32_t vmFlags;
+extern uint64_t ioctlVmCreateExtensionArg;
+} // namespace SysCalls
+} // namespace NEO
+
+TEST(DrmQueryTest, givenDirectSubmissionActiveWhenCreateDrmContextThenProperFlagIsSet) {
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+
+    drm.createDrmContext(0, true, false);
+
+    EXPECT_TRUE(drm.receivedContextCreateFlags & DrmPrelimHelper::getULLSContextCreateFlag());
+}
+
+TEST(DrmQueryTest, givenDirectSubmissionDisabledAndDirectSubmissionDrmContextSetWhenCreateDrmContextThenProperFlagIsSet) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.DirectSubmissionDrmContext.set(1);
+
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+
+    drm.createDrmContext(0, false, false);
+
+    EXPECT_TRUE(drm.receivedContextCreateFlags & DrmPrelimHelper::getULLSContextCreateFlag());
+}
+
+TEST(DrmQueryTest, givenDirectSubmissionActiveAndDirectSubmissionDrmContextSetZeroWhenCreateDrmContextThenProperFlagIsNotSet) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.DirectSubmissionDrmContext.set(0);
+
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+
+    drm.createDrmContext(0, true, false);
+
+    EXPECT_FALSE(drm.receivedContextCreateFlags & DrmPrelimHelper::getULLSContextCreateFlag());
+}
+
+TEST(DrmQueryTest, givenCooperativeEngineWhenCreateDrmContextThenRunAloneContextIsRequested) {
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+
+    drm.createDrmContext(0, false, true);
+
+    const auto &extSetparam = drm.receivedContextCreateSetParam;
+
+    EXPECT_EQ(static_cast<uint32_t>(I915_CONTEXT_CREATE_EXT_SETPARAM), extSetparam.base.name);
+    EXPECT_EQ(0u, extSetparam.base.next_extension);
+    EXPECT_EQ(0u, extSetparam.base.flags);
+
+    EXPECT_EQ(static_cast<uint64_t>(DrmPrelimHelper::getRunAloneContextParam()), extSetparam.param.param);
+    EXPECT_EQ(0u, extSetparam.param.size);
+    EXPECT_EQ(0u, extSetparam.param.ctx_id);
+    EXPECT_EQ(0u, extSetparam.param.value);
+}
+
+TEST(DrmQueryTest, givenForceRunAloneContextFlagSetWhenCreateDrmContextThenRunAloneContextIsRequested) {
+    DebugManagerStateRestore restorer;
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+
+    {
+        DebugManager.flags.ForceRunAloneContext.set(0);
+        drm.createDrmContext(0, false, false);
+
+        auto extSetparam = drm.receivedContextCreateSetParam;
+        EXPECT_NE(static_cast<uint64_t>(DrmPrelimHelper::getRunAloneContextParam()), extSetparam.param.param);
+    }
+    {
+        DebugManager.flags.ForceRunAloneContext.set(1);
+        drm.createDrmContext(0, false, false);
+
+        auto extSetparam = drm.receivedContextCreateSetParam;
+        EXPECT_EQ(static_cast<uint32_t>(I915_CONTEXT_CREATE_EXT_SETPARAM), extSetparam.base.name);
+        EXPECT_EQ(0u, extSetparam.base.next_extension);
+        EXPECT_EQ(0u, extSetparam.base.flags);
+
+        EXPECT_EQ(static_cast<uint64_t>(DrmPrelimHelper::getRunAloneContextParam()), extSetparam.param.param);
+        EXPECT_EQ(0u, extSetparam.param.size);
+        EXPECT_EQ(0u, extSetparam.param.ctx_id);
+        EXPECT_EQ(0u, extSetparam.param.value);
+    }
+}
+
+TEST(DrmQueryTest, givenCreateContextWithAccessCountersWhenDrmContextIsCreatedThenProgramAccessCountersWithDefaultGranularity) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.CreateContextWithAccessCounters.set(0);
+
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+
+    auto ret = drm.createDrmContext(0, false, false);
+    EXPECT_EQ(0u, ret);
+
+    EXPECT_TRUE(drm.receivedContextCreateFlags & I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS);
+
+    auto extSetparam = drm.receivedContextCreateSetParam;
+
+    EXPECT_EQ(static_cast<uint32_t>(I915_CONTEXT_CREATE_EXT_SETPARAM), extSetparam.base.name);
+    EXPECT_EQ(0u, extSetparam.base.next_extension);
+    EXPECT_EQ(0u, extSetparam.base.flags);
+
+    EXPECT_EQ(static_cast<uint64_t>(DrmPrelimHelper::getAccContextParam()), extSetparam.param.param);
+    EXPECT_EQ(DrmPrelimHelper::getAccContextParamSize(), extSetparam.param.size);
+    EXPECT_EQ(0u, extSetparam.param.ctx_id);
+    EXPECT_NE(0u, extSetparam.param.value);
+
+    auto paramAcc = drm.context.receivedContextParamAcc;
+    ASSERT_TRUE(paramAcc);
+    EXPECT_EQ(1u, paramAcc->notify);
+    EXPECT_EQ(0u, paramAcc->trigger);
+    EXPECT_EQ(static_cast<uint8_t>(DrmPrelimHelper::getContextAcgValues()[1]), paramAcc->granularity);
+}
+
+TEST(DrmQueryTest, givenCreateContextWithAccessCounterWhenDrmContextIsCreatedThenProgramAccessCountersWithSpecifiedTriggeringThreshold) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.CreateContextWithAccessCounters.set(0);
+
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+
+    for (uint16_t threshold : {0, 1, 1024, 65535}) {
+        DebugManager.flags.AccessCountersTrigger.set(threshold);
+
+        auto ret = drm.createDrmContext(0, false, false);
+        EXPECT_EQ(0u, ret);
+
+        EXPECT_TRUE(drm.receivedContextCreateFlags & I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS);
+
+        auto extSetparam = drm.receivedContextCreateSetParam;
+
+        EXPECT_EQ(static_cast<uint32_t>(I915_CONTEXT_CREATE_EXT_SETPARAM), extSetparam.base.name);
+        EXPECT_EQ(0u, extSetparam.base.next_extension);
+        EXPECT_EQ(0u, extSetparam.base.flags);
+
+        EXPECT_EQ(static_cast<uint64_t>(DrmPrelimHelper::getAccContextParam()), extSetparam.param.param);
+        EXPECT_EQ(DrmPrelimHelper::getAccContextParamSize(), extSetparam.param.size);
+        EXPECT_EQ(0u, extSetparam.param.ctx_id);
+        EXPECT_NE(0u, extSetparam.param.value);
+
+        auto paramAcc = drm.context.receivedContextParamAcc;
+        ASSERT_TRUE(paramAcc);
+        EXPECT_EQ(DrmPrelimHelper::getContextAcgValues()[1], paramAcc->granularity);
+        EXPECT_EQ(1u, paramAcc->notify);
+        EXPECT_EQ(threshold, paramAcc->trigger);
+    }
+}
+
+TEST(DrmQueryTest, givenCreateContextWithAccessCounterWhenDrmContextIsCreatedThenProgramAccessCountersWithSpecifiedGranularity) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.CreateContextWithAccessCounters.set(0);
+
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+
+    for (uint8_t granularity : DrmPrelimHelper::getContextAcgValues()) {
+        DebugManager.flags.AccessCountersGranularity.set(granularity);
+
+        auto ret = drm.createDrmContext(0, false, false);
+        EXPECT_EQ(0u, ret);
+
+        EXPECT_TRUE(drm.receivedContextCreateFlags & I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS);
+
+        auto extSetparam = drm.receivedContextCreateSetParam;
+
+        EXPECT_EQ(static_cast<uint32_t>(I915_CONTEXT_CREATE_EXT_SETPARAM), extSetparam.base.name);
+        EXPECT_EQ(0u, extSetparam.base.next_extension);
+        EXPECT_EQ(0u, extSetparam.base.flags);
+
+        EXPECT_EQ(static_cast<uint64_t>(DrmPrelimHelper::getAccContextParam()), extSetparam.param.param);
+        EXPECT_EQ(DrmPrelimHelper::getAccContextParamSize(), extSetparam.param.size);
+        EXPECT_EQ(0u, extSetparam.param.ctx_id);
+        EXPECT_NE(0u, extSetparam.param.value);
+
+        auto paramAcc = drm.context.receivedContextParamAcc;
+        ASSERT_TRUE(paramAcc);
+        EXPECT_EQ(1u, paramAcc->notify);
+        EXPECT_EQ(0u, paramAcc->trigger);
+        EXPECT_EQ(static_cast<uint8_t>(granularity), paramAcc->granularity);
+    }
+}
+
+struct BufferObjectMock : public BufferObject {
+    using BufferObject::BufferObject;
+    using BufferObject::fillExecObject;
+};
+
+TEST(DrmBufferObjectTestPrelim, givenDisableScratchPagesWhenCreateDrmVirtualMemoryThenProperFlagIsSet) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.DisableScratchPages.set(true);
+    DebugManager.flags.UseTileMemoryBankInVirtualMemoryCreation.set(0u);
+
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+
+    uint32_t vmId = 0;
+    drm.createDrmVirtualMemory(vmId);
+
+    EXPECT_TRUE(NEO::SysCalls::vmFlags & DrmPrelimHelper::getDisableScratchVmCreateFlag());
+}
+
+TEST(DrmBufferObjectTestPrelim, givenLocalMemoryDisabledWhenCreateDrmVirtualMemoryThenVmRegionExtensionIsNotPassed) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.EnableLocalMemory.set(0);
+    DebugManager.flags.UseTileMemoryBankInVirtualMemoryCreation.set(1u);
+
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    DrmQueryMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
+
+    uint32_t vmId = 0;
+    drm.createDrmVirtualMemory(vmId);
+
+    EXPECT_EQ(NEO::SysCalls::ioctlVmCreateExtensionArg, 0ull);
+}
+
+TEST(DrmBufferObjectTestPrelim, givenLocalMemoryEnabledWhenCreateDrmVirtualMemoryThenVmRegionExtensionIsPassed) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.EnableLocalMemory.set(1);
+    DebugManager.flags.UseTileMemoryBankInVirtualMemoryCreation.set(1u);
+
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    HardwareInfo testHwInfo = *defaultHwInfo;
+
+    testHwInfo.gtSystemInfo.MultiTileArchInfo.IsValid = true;
+    testHwInfo.gtSystemInfo.MultiTileArchInfo.TileCount = 1;
+    testHwInfo.gtSystemInfo.MultiTileArchInfo.Tile0 = 1;
+    testHwInfo.gtSystemInfo.MultiTileArchInfo.TileMask = 0b1;
+    DrmQueryMock drm(*executionEnvironment->rootDeviceEnvironments[0], &testHwInfo);
+
+    uint32_t vmId = 0;
+    drm.createDrmVirtualMemory(vmId);
+
+    EXPECT_NE(NEO::SysCalls::ioctlVmCreateExtensionArg, 0ull);
+}
+
+TEST(DrmBufferObjectTestPrelim, givenBufferObjectSetToColourWithBindWhenBindingThenSetProperAddressAndSize) {
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(NEO::defaultHwInfo.get());
+    executionEnvironment->initializeMemoryManager();
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+    BufferObjectMock bo(&drm, 1, 0, 1);
+    bo.setColourWithBind();
+    bo.setColourChunk(MemoryConstants::pageSize64k);
+    bo.addColouringAddress(0xffeeffee);
+    OsContextLinux osContext(drm, 0u, EngineDescriptorHelper::getDefaultDescriptor());
+    osContext.ensureContextInitialized();
+
+    bo.bind(&osContext, 0);
+    ASSERT_TRUE(drm.context.receivedVmBind);
+    EXPECT_EQ(drm.context.receivedVmBind->length, MemoryConstants::pageSize64k);
+    EXPECT_EQ(drm.context.receivedVmBind->start, 0xffeeffee);
+}
+
+TEST(DrmBufferObjectTestPrelim, givenPageFaultNotSupportedWhenCallingCreateDrmVirtualMemoryThenDontEnablePageFaultsOnVirtualMemory) {
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+    EXPECT_FALSE(drm.pageFaultSupported);
+
+    uint32_t vmId = 0;
+    drm.createDrmVirtualMemory(vmId);
+
+    EXPECT_FALSE(NEO::SysCalls::vmFlags & DrmPrelimHelper::getEnablePageFaultVmCreateFlag());
+
+    drm.destroyDrmVirtualMemory(vmId);
+}
+
+TEST(DrmBufferObjectTestPrelim, givenPageFaultSupportedWhenVmBindIsAvailableThenEnablePageFaultsOnVirtualMemory) {
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+
+    drm.pageFaultSupported = true;
+
+    for (auto vmBindAvailable : {false, true}) {
+        drm.bindAvailable = vmBindAvailable;
+
+        uint32_t vmId = 0;
+        drm.createDrmVirtualMemory(vmId);
+
+        if (drm.isVmBindAvailable()) {
+            EXPECT_TRUE(NEO::SysCalls::vmFlags & DrmPrelimHelper::getEnablePageFaultVmCreateFlag());
+        } else {
+            EXPECT_FALSE(NEO::SysCalls::vmFlags & DrmPrelimHelper::getEnablePageFaultVmCreateFlag());
+        }
+
+        drm.destroyDrmVirtualMemory(vmId);
+    }
+}
+
+TEST(DrmBufferObjectTestPrelim, givenBufferObjectMarkedForCaptureWhenBindingThenCaptureFlagIsSet) {
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(NEO::defaultHwInfo.get());
+    executionEnvironment->initializeMemoryManager();
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+    BufferObjectMock bo(&drm, 1, 0, 1);
+    OsContextLinux osContext(drm, 0u, EngineDescriptorHelper::getDefaultDescriptor());
+    osContext.ensureContextInitialized();
+    bo.markForCapture();
+
+    bo.bind(&osContext, 0);
+    ASSERT_TRUE(drm.context.receivedVmBind);
+    EXPECT_TRUE(drm.context.receivedVmBind->flags & DrmPrelimHelper::getCaptureVmBindFlag());
+}
+
+TEST(DrmBufferObjectTestPrelim, givenNoActiveDirectSubmissionAndForceUseImmediateExtensionWhenBindingThenImmediateFlagIsSetAndExtensionListIsNotNull) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.EnableImmediateVmBindExt.set(1);
+
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(NEO::defaultHwInfo.get());
+    executionEnvironment->initializeMemoryManager();
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+    BufferObjectMock bo(&drm, 1, 0, 1);
+    OsContextLinux osContext(drm, 0u, EngineDescriptorHelper::getDefaultDescriptor());
+    osContext.ensureContextInitialized();
+
+    bo.bind(&osContext, 0);
+    ASSERT_TRUE(drm.context.receivedVmBind);
+    EXPECT_TRUE(drm.context.receivedVmBind->flags & DrmPrelimHelper::getImmediateVmBindFlag());
+    EXPECT_NE(drm.context.receivedVmBind->extensions, 0u);
+}
+
+TEST(DrmBufferObjectTestPrelim, whenBindingThenImmediateFlagIsSetAndExtensionListIsNotNull) {
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(NEO::defaultHwInfo.get());
+    executionEnvironment->initializeMemoryManager();
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+    drm.setDirectSubmissionActive(true);
+    BufferObjectMock bo(&drm, 1, 0, 1);
+    OsContextLinux osContext(drm, 0u, EngineDescriptorHelper::getDefaultDescriptor());
+    osContext.ensureContextInitialized();
+    osContext.setDirectSubmissionActive();
+
+    bo.bind(&osContext, 0);
+    ASSERT_TRUE(drm.context.receivedVmBind);
+    EXPECT_TRUE(drm.context.receivedVmBind->flags & DrmPrelimHelper::getImmediateVmBindFlag());
+    EXPECT_NE(drm.context.receivedVmBind->extensions, 0u);
+}
+
+TEST(DrmBufferObjectTestPrelim, givenProvidedCtxIdWhenCallingWaitUserFenceThenExpectCtxFlagSetAndNoSoftFlagSet) {
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+    OsContextLinux osContext(drm, 0u, EngineDescriptorHelper::getDefaultDescriptor());
+    osContext.ensureContextInitialized();
+
+    uint64_t gpuAddress = 0x1020304000ull;
+    uint64_t value = 0x98765ull;
+    drm.waitUserFence(10u, gpuAddress, value, Drm::ValueWidth::U8, -1, 0u);
+
+    EXPECT_EQ(1u, drm.context.waitUserFenceCalled);
+    const auto &waitUserFence = drm.context.receivedWaitUserFence;
+    ASSERT_TRUE(waitUserFence);
+    EXPECT_EQ(10u, waitUserFence->ctxId);
+    EXPECT_EQ(DrmPrelimHelper::getU8WaitUserFenceFlag(), waitUserFence->mask);
+    EXPECT_EQ(gpuAddress, waitUserFence->addr);
+    EXPECT_EQ(0u, waitUserFence->flags);
+    EXPECT_EQ(value, waitUserFence->value);
+    EXPECT_EQ(-1, waitUserFence->timeout);
+}
+
+TEST(DrmBufferObjectTestPrelim, givenProvidedNoCtxIdWhenCallingWaitUserFenceThenExpectCtxFlagNotSetAndSoftFlagSet) {
+    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    executionEnvironment->prepareRootDeviceEnvironments(1);
+    DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+    OsContextLinux osContext(drm, 0u, EngineDescriptorHelper::getDefaultDescriptor());
+    osContext.ensureContextInitialized();
+
+    uint64_t gpuAddress = 0x1020304000ull;
+    uint64_t value = 0x98765ull;
+    drm.waitUserFence(0u, gpuAddress, value, Drm::ValueWidth::U16, 2, 3u);
+
+    EXPECT_EQ(1u, drm.context.waitUserFenceCalled);
+    const auto &waitUserFence = drm.context.receivedWaitUserFence;
+    ASSERT_TRUE(waitUserFence);
+    EXPECT_EQ(0u, waitUserFence->ctxId);
+    EXPECT_EQ(DrmPrelimHelper::getU16WaitUserFenceFlag(), waitUserFence->mask);
+    EXPECT_EQ(gpuAddress, waitUserFence->addr);
+    EXPECT_EQ(3u, waitUserFence->flags);
+    EXPECT_EQ(value, waitUserFence->value);
+    EXPECT_EQ(2, waitUserFence->timeout);
+}