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

Dont allocate dynamic memory when preparing params for vm bind call

Browse Source 
Related-To: NEO-6837
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2022-04-05 17:04:53 +02:00
committed by Compute-Runtime-Automation
parent 33340d28f7
commit d3b7ea10c8
6 changed files with 33 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
shared/source/os_interface/linux/drm_neo.cpp
View File

@ -1397,7 +1397,7 @@ int changeBufferObjectBinding(Drm *drm, OsContext *osContext, uint32_t vmHandleI
closEnabled = !!DebugManager.flags.ClosEnabled.get(); closEnabled = !!DebugManager.flags.ClosEnabled.get();
} }
auto vmBindExtSetPat = ioctlHelper->createVmBindExtSetPat(); VmBindExtSetPatT vmBindExtSetPat{};
if (closEnabled) { if (closEnabled) {
uint64_t patIndex = ClosHelper::getPatIndex(bo->peekCacheRegion(), bo->peekCachePolicy()); uint64_t patIndex = ClosHelper::getPatIndex(bo->peekCacheRegion(), bo->peekCachePolicy());
@ -1405,7 +1405,7 @@ int changeBufferObjectBinding(Drm *drm, OsContext *osContext, uint32_t vmHandleI
patIndex = static_cast<uint64_t>(DebugManager.flags.OverridePatIndex.get()); patIndex = static_cast<uint64_t>(DebugManager.flags.OverridePatIndex.get());
} }
ioctlHelper->fillVmBindExtSetPat(vmBindExtSetPat, patIndex, castToUint64(extensions.get())); ioctlHelper->fillVmBindExtSetPat(vmBindExtSetPat, patIndex, castToUint64(extensions.get()));
vmBind.extensions = castToUint64(vmBindExtSetPat.get()); vmBind.extensions = castToUint64(vmBindExtSetPat);
} else { } else {
vmBind.extensions = castToUint64(extensions.get()); vmBind.extensions = castToUint64(extensions.get());
} }
@ -1413,7 +1413,7 @@ int changeBufferObjectBinding(Drm *drm, OsContext *osContext, uint32_t vmHandleI
if (bind) { if (bind) {
std::unique_lock<std::mutex> lock; std::unique_lock<std::mutex> lock;
auto vmBindExtUserFence = ioctlHelper->createVmBindExtUserFence(); VmBindExtUserFenceT vmBindExtUserFence{};
if (drm->useVMBindImmediate()) { if (drm->useVMBindImmediate()) {
lock = drm->lockBindFenceMutex(); lock = drm->lockBindFenceMutex();
@ -1424,7 +1424,7 @@ int changeBufferObjectBinding(Drm *drm, OsContext *osContext, uint32_t vmHandleI
auto value = drm->getNextFenceVal(vmHandleId); auto value = drm->getNextFenceVal(vmHandleId);
ioctlHelper->fillVmBindExtUserFence(vmBindExtUserFence, address, value, nextExtension); ioctlHelper->fillVmBindExtUserFence(vmBindExtUserFence, address, value, nextExtension);
vmBind.extensions = castToUint64(vmBindExtUserFence.get()); vmBind.extensions = castToUint64(vmBindExtUserFence);
} }
} }

20
shared/source/os_interface/linux/ioctl_helper.h
View File

@ -72,6 +72,8 @@ struct UuidRegisterResult {
}; };
using MemRegionsVec = StackVec<MemoryClassInstance, 5>; using MemRegionsVec = StackVec<MemoryClassInstance, 5>;
using VmBindExtSetPatT = uint8_t[40];
using VmBindExtUserFenceT = uint8_t[56];
class IoctlHelper { class IoctlHelper {
public: public:
@ -110,10 +112,8 @@ class IoctlHelper {
virtual uint32_t getFlagsForVmCreate(bool disableScratch, bool enablePageFault) = 0; virtual uint32_t getFlagsForVmCreate(bool disableScratch, bool enablePageFault) = 0;
virtual uint32_t createContextWithAccessCounters(Drm *drm, drm_i915_gem_context_create_ext &gcc) = 0; virtual uint32_t createContextWithAccessCounters(Drm *drm, drm_i915_gem_context_create_ext &gcc) = 0;
virtual uint32_t createCooperativeContext(Drm *drm, drm_i915_gem_context_create_ext &gcc) = 0; virtual uint32_t createCooperativeContext(Drm *drm, drm_i915_gem_context_create_ext &gcc) = 0;
virtual std::unique_ptr<uint8_t[]> createVmBindExtSetPat() = 0; virtual void fillVmBindExtSetPat(VmBindExtSetPatT &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) = 0;
virtual void fillVmBindExtSetPat(const std::unique_ptr<uint8_t[]> &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) = 0; virtual void fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) = 0;
virtual std::unique_ptr<uint8_t[]> createVmBindExtUserFence() = 0;
virtual void fillVmBindExtUserFence(const std::unique_ptr<uint8_t[]> &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) = 0;
virtual std::optional<uint64_t> getCopyClassSaturatePCIECapability() = 0; virtual std::optional<uint64_t> getCopyClassSaturatePCIECapability() = 0;
virtual std::optional<uint64_t> getCopyClassSaturateLinkCapability() = 0; virtual std::optional<uint64_t> getCopyClassSaturateLinkCapability() = 0;
virtual uint32_t getVmAdviseAtomicAttribute() = 0; virtual uint32_t getVmAdviseAtomicAttribute() = 0;
@ -163,10 +163,8 @@ class IoctlHelperUpstream : public IoctlHelper {
uint32_t getFlagsForVmCreate(bool disableScratch, bool enablePageFault) override; uint32_t getFlagsForVmCreate(bool disableScratch, bool enablePageFault) override;
uint32_t createContextWithAccessCounters(Drm *drm, drm_i915_gem_context_create_ext &gcc) override; uint32_t createContextWithAccessCounters(Drm *drm, drm_i915_gem_context_create_ext &gcc) override;
uint32_t createCooperativeContext(Drm *drm, drm_i915_gem_context_create_ext &gcc) override; uint32_t createCooperativeContext(Drm *drm, drm_i915_gem_context_create_ext &gcc) override;
std::unique_ptr<uint8_t[]> createVmBindExtSetPat() override; void fillVmBindExtSetPat(VmBindExtSetPatT &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) override;
void fillVmBindExtSetPat(const std::unique_ptr<uint8_t[]> &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) override; void fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) override;
std::unique_ptr<uint8_t[]> createVmBindExtUserFence() override;
void fillVmBindExtUserFence(const std::unique_ptr<uint8_t[]> &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) override;
std::optional<uint64_t> getCopyClassSaturatePCIECapability() override; std::optional<uint64_t> getCopyClassSaturatePCIECapability() override;
std::optional<uint64_t> getCopyClassSaturateLinkCapability() override; std::optional<uint64_t> getCopyClassSaturateLinkCapability() override;
uint32_t getVmAdviseAtomicAttribute() override; uint32_t getVmAdviseAtomicAttribute() override;
@ -229,10 +227,8 @@ class IoctlHelperPrelim20 : public IoctlHelper {
uint32_t getFlagsForVmCreate(bool disableScratch, bool enablePageFault) override; uint32_t getFlagsForVmCreate(bool disableScratch, bool enablePageFault) override;
uint32_t createContextWithAccessCounters(Drm *drm, drm_i915_gem_context_create_ext &gcc) override; uint32_t createContextWithAccessCounters(Drm *drm, drm_i915_gem_context_create_ext &gcc) override;
uint32_t createCooperativeContext(Drm *drm, drm_i915_gem_context_create_ext &gcc) override; uint32_t createCooperativeContext(Drm *drm, drm_i915_gem_context_create_ext &gcc) override;
std::unique_ptr<uint8_t[]> createVmBindExtSetPat() override; void fillVmBindExtSetPat(VmBindExtSetPatT &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) override;
void fillVmBindExtSetPat(const std::unique_ptr<uint8_t[]> &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) override; void fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) override;
std::unique_ptr<uint8_t[]> createVmBindExtUserFence() override;
void fillVmBindExtUserFence(const std::unique_ptr<uint8_t[]> &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) override;
std::optional<uint64_t> getCopyClassSaturatePCIECapability() override; std::optional<uint64_t> getCopyClassSaturatePCIECapability() override;
std::optional<uint64_t> getCopyClassSaturateLinkCapability() override; std::optional<uint64_t> getCopyClassSaturateLinkCapability() override;
uint32_t getVmAdviseAtomicAttribute() override; uint32_t getVmAdviseAtomicAttribute() override;

16
shared/source/os_interface/linux/ioctl_helper_prelim.cpp
View File

@ -437,24 +437,20 @@ uint32_t IoctlHelperPrelim20::createCooperativeContext(Drm *drm, drm_i915_gem_co
return gemCreateContextExt(drm, gcc, extSetparam); return gemCreateContextExt(drm, gcc, extSetparam);
} }
std::unique_ptr<uint8_t[]> IoctlHelperPrelim20::createVmBindExtSetPat() { static_assert(sizeof(VmBindExtSetPatT) == sizeof(prelim_drm_i915_vm_bind_ext_set_pat), "Invalid size for VmBindExtSetPat");
return std::make_unique<uint8_t[]>(sizeof(prelim_drm_i915_vm_bind_ext_set_pat));
};
void IoctlHelperPrelim20::fillVmBindExtSetPat(const std::unique_ptr<uint8_t[]> &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) { void IoctlHelperPrelim20::fillVmBindExtSetPat(VmBindExtSetPatT &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) {
auto prelimVmBindExtSetPat = reinterpret_cast<prelim_drm_i915_vm_bind_ext_set_pat *>(vmBindExtSetPat.get()); auto prelimVmBindExtSetPat = reinterpret_cast<prelim_drm_i915_vm_bind_ext_set_pat *>(vmBindExtSetPat);
UNRECOVERABLE_IF(!prelimVmBindExtSetPat); UNRECOVERABLE_IF(!prelimVmBindExtSetPat);
prelimVmBindExtSetPat->base.name = PRELIM_I915_VM_BIND_EXT_SET_PAT; prelimVmBindExtSetPat->base.name = PRELIM_I915_VM_BIND_EXT_SET_PAT;
prelimVmBindExtSetPat->pat_index = patIndex; prelimVmBindExtSetPat->pat_index = patIndex;
prelimVmBindExtSetPat->base.next_extension = nextExtension; prelimVmBindExtSetPat->base.next_extension = nextExtension;
} }
std::unique_ptr<uint8_t[]> IoctlHelperPrelim20::createVmBindExtUserFence() { static_assert(sizeof(VmBindExtUserFenceT) == sizeof(prelim_drm_i915_vm_bind_ext_user_fence), "Invalid size for VmBindExtUserFence");
return std::make_unique<uint8_t[]>(sizeof(prelim_drm_i915_vm_bind_ext_user_fence));
}
void IoctlHelperPrelim20::fillVmBindExtUserFence(const std::unique_ptr<uint8_t[]> &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) { void IoctlHelperPrelim20::fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) {
auto prelimVmBindExtUserFence = reinterpret_cast<prelim_drm_i915_vm_bind_ext_user_fence *>(vmBindExtUserFence.get()); auto prelimVmBindExtUserFence = reinterpret_cast<prelim_drm_i915_vm_bind_ext_user_fence *>(vmBindExtUserFence);
UNRECOVERABLE_IF(!prelimVmBindExtUserFence); UNRECOVERABLE_IF(!prelimVmBindExtUserFence);
prelimVmBindExtUserFence->base.name = PRELIM_I915_VM_BIND_EXT_USER_FENCE; prelimVmBindExtUserFence->base.name = PRELIM_I915_VM_BIND_EXT_USER_FENCE;
prelimVmBindExtUserFence->base.next_extension = nextExtension; prelimVmBindExtUserFence->base.next_extension = nextExtension;

12
shared/source/os_interface/linux/ioctl_helper_upstream.cpp
View File

@ -194,17 +194,9 @@ uint32_t IoctlHelperUpstream::createCooperativeContext(Drm *drm, drm_i915_gem_co
return EINVAL; return EINVAL;
} }
std::unique_ptr<uint8_t[]> IoctlHelperUpstream::createVmBindExtSetPat() { void IoctlHelperUpstream::fillVmBindExtSetPat(VmBindExtSetPatT &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) {}
return {};
}
void IoctlHelperUpstream::fillVmBindExtSetPat(const std::unique_ptr<uint8_t[]> &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) {} void IoctlHelperUpstream::fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) {}
std::unique_ptr<uint8_t[]> IoctlHelperUpstream::createVmBindExtUserFence() {
return {};
}
void IoctlHelperUpstream::fillVmBindExtUserFence(const std::unique_ptr<uint8_t[]> &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) {}
std::optional<uint64_t> IoctlHelperUpstream::getCopyClassSaturatePCIECapability() { std::optional<uint64_t> IoctlHelperUpstream::getCopyClassSaturatePCIECapability() {
return std::nullopt; return std::nullopt;

35
shared/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp
View File

@ -5,6 +5,7 @@
* *
*/ */
#include "shared/source/helpers/string.h"
#include "shared/source/os_interface/linux/ioctl_helper.h" #include "shared/source/os_interface/linux/ioctl_helper.h"
#include "shared/source/os_interface/linux/ioctl_strings.h" #include "shared/source/os_interface/linux/ioctl_strings.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h" #include "shared/test/common/helpers/debug_manager_state_restore.h"
@ -193,56 +194,38 @@ TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenGettingFlagForWaitUserFenceSoftTh
EXPECT_EQ(PRELIM_I915_UFENCE_WAIT_SOFT, ioctlHelper.getWaitUserFenceSoftFlag()); EXPECT_EQ(PRELIM_I915_UFENCE_WAIT_SOFT, ioctlHelper.getWaitUserFenceSoftFlag());
} }
TEST_F(IoctlPrelimHelperTests, whenCreateVmBindSetPatThenValidPointerIsReturned) {
EXPECT_NE(nullptr, ioctlHelper.createVmBindExtSetPat());
}
TEST_F(IoctlPrelimHelperTests, whenCreateVmBindUserFenceThenValidPointerIsReturned) {
EXPECT_NE(nullptr, ioctlHelper.createVmBindExtUserFence());
}
TEST_F(IoctlPrelimHelperTests, givenNullptrWhenFillVmBindSetPatThenUnrecoverableIsThrown) {
std::unique_ptr<uint8_t[]> vmBindExtSetPat{};
EXPECT_THROW(ioctlHelper.fillVmBindExtSetPat(vmBindExtSetPat, 0u, 0u), std::runtime_error);
}
TEST_F(IoctlPrelimHelperTests, givenNullptrWhenFillVmBindUserFenceThenUnrecoverableIsThrown) {
std::unique_ptr<uint8_t[]> vmBindExtUserFence{};
EXPECT_THROW(ioctlHelper.fillVmBindExtUserFence(vmBindExtUserFence, 0u, 0u, 0u), std::runtime_error);
}
TEST_F(IoctlPrelimHelperTests, givenValidInputWhenFillVmBindSetPatThenProperValuesAreSet) { TEST_F(IoctlPrelimHelperTests, givenValidInputWhenFillVmBindSetPatThenProperValuesAreSet) {
std::unique_ptr<uint8_t[]> vmBindExtSetPat{}; VmBindExtSetPatT vmBindExtSetPat{};
prelim_drm_i915_vm_bind_ext_set_pat prelimVmBindExtSetPat{}; prelim_drm_i915_vm_bind_ext_set_pat prelimVmBindExtSetPat{};
vmBindExtSetPat.reset(reinterpret_cast<uint8_t *>(&prelimVmBindExtSetPat));
uint64_t expectedPatIndex = 2; uint64_t expectedPatIndex = 2;
uint64_t expectedNextExtension = 3; uint64_t expectedNextExtension = 3;
ioctlHelper.fillVmBindExtSetPat(vmBindExtSetPat, expectedPatIndex, expectedNextExtension); ioctlHelper.fillVmBindExtSetPat(vmBindExtSetPat, expectedPatIndex, expectedNextExtension);
memcpy_s(&prelimVmBindExtSetPat, sizeof(prelimVmBindExtSetPat), vmBindExtSetPat, sizeof(vmBindExtSetPat));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_I915_VM_BIND_EXT_SET_PAT), prelimVmBindExtSetPat.base.name); EXPECT_EQ(static_cast<uint32_t>(PRELIM_I915_VM_BIND_EXT_SET_PAT), prelimVmBindExtSetPat.base.name);
EXPECT_EQ(expectedPatIndex, prelimVmBindExtSetPat.pat_index); EXPECT_EQ(expectedPatIndex, prelimVmBindExtSetPat.pat_index);
EXPECT_EQ(expectedNextExtension, prelimVmBindExtSetPat.base.next_extension); EXPECT_EQ(expectedNextExtension, prelimVmBindExtSetPat.base.next_extension);
vmBindExtSetPat.release();
} }
TEST_F(IoctlPrelimHelperTests, givenValidInputWhenFillVmBindUserFenceThenProperValuesAreSet) { TEST_F(IoctlPrelimHelperTests, givenValidInputWhenFillVmBindUserFenceThenProperValuesAreSet) {
std::unique_ptr<uint8_t[]> vmBindExtUserFence{}; VmBindExtUserFenceT vmBindExtUserFence{};
prelim_drm_i915_vm_bind_ext_user_fence prelimVmBindExtUserFence{}; prelim_drm_i915_vm_bind_ext_user_fence prelimVmBindExtUserFence{};
vmBindExtUserFence.reset(reinterpret_cast<uint8_t *>(&prelimVmBindExtUserFence));
uint64_t expectedAddress = 0xdead; uint64_t expectedAddress = 0xdead;
uint64_t expectedValue = 0xc0de; uint64_t expectedValue = 0xc0de;
uint64_t expectedNextExtension = 1234; uint64_t expectedNextExtension = 1234;
uint64_t expectedSize = sizeof(prelimVmBindExtUserFence.base) + sizeof(uint64_t) * 3; uint64_t expectedSize = sizeof(prelimVmBindExtUserFence.base) + sizeof(uint64_t) * 3;
ioctlHelper.fillVmBindExtUserFence(vmBindExtUserFence, expectedAddress, expectedValue, expectedNextExtension); ioctlHelper.fillVmBindExtUserFence(vmBindExtUserFence, expectedAddress, expectedValue, expectedNextExtension);
memcpy_s(&prelimVmBindExtUserFence, sizeof(prelimVmBindExtUserFence), vmBindExtUserFence, sizeof(vmBindExtUserFence));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_I915_VM_BIND_EXT_USER_FENCE), prelimVmBindExtUserFence.base.name); EXPECT_EQ(static_cast<uint32_t>(PRELIM_I915_VM_BIND_EXT_USER_FENCE), prelimVmBindExtUserFence.base.name);
EXPECT_EQ(expectedAddress, prelimVmBindExtUserFence.addr); EXPECT_EQ(expectedAddress, prelimVmBindExtUserFence.addr);
EXPECT_EQ(expectedValue, prelimVmBindExtUserFence.val); EXPECT_EQ(expectedValue, prelimVmBindExtUserFence.val);
EXPECT_EQ(expectedNextExtension, prelimVmBindExtUserFence.base.next_extension); EXPECT_EQ(expectedNextExtension, prelimVmBindExtUserFence.base.next_extension);
EXPECT_EQ(expectedSize, sizeof(prelimVmBindExtUserFence)); EXPECT_EQ(expectedSize, sizeof(prelimVmBindExtUserFence));
vmBindExtUserFence.release();
} }
TEST_F(IoctlPrelimHelperTests, givenPrelimWhenGettingEuStallPropertiesThenCorrectPropertiesAreReturned) { TEST_F(IoctlPrelimHelperTests, givenPrelimWhenGettingEuStallPropertiesThenCorrectPropertiesAreReturned) {

18
shared/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp
View File

@ -284,25 +284,15 @@ TEST(IoctlHelperTestsUpstream, whenCreateCooperativeContexIsCalledThenErrorIsRet
EXPECT_EQ(static_cast<uint32_t>(EINVAL), ioctlHelper.createCooperativeContext(drm.get(), gcc)); EXPECT_EQ(static_cast<uint32_t>(EINVAL), ioctlHelper.createCooperativeContext(drm.get(), gcc));
} }
TEST(IoctlHelperTestsUpstream, whenCreateVmBindSetPatThenNullptrIsReturned) { TEST(IoctlHelperTestsUpstream, whenFillVmBindSetPatThenNothingThrows) {
IoctlHelperUpstream ioctlHelper{}; IoctlHelperUpstream ioctlHelper{};
EXPECT_EQ(nullptr, ioctlHelper.createVmBindExtSetPat()); VmBindExtSetPatT vmBindExtSetPat{};
}
TEST(IoctlHelperTestsUpstream, whenCreateVmBindUserFenceThenNullptrIsReturned) {
IoctlHelperUpstream ioctlHelper{};
EXPECT_EQ(nullptr, ioctlHelper.createVmBindExtUserFence());
}
TEST(IoctlHelperTestsUpstream, givenNullptrWhenFillVmBindSetPatThenNothingThrows) {
IoctlHelperUpstream ioctlHelper{};
auto vmBindExtSetPat = ioctlHelper.createVmBindExtSetPat();
EXPECT_NO_THROW(ioctlHelper.fillVmBindExtSetPat(vmBindExtSetPat, 0u, 0u)); EXPECT_NO_THROW(ioctlHelper.fillVmBindExtSetPat(vmBindExtSetPat, 0u, 0u));
} }
TEST(IoctlHelperTestsUpstream, givenNullptrWhenFillVmBindUserFenceThenNothingThrows) { TEST(IoctlHelperTestsUpstream, whenFillVmBindUserFenceThenNothingThrows) {
IoctlHelperUpstream ioctlHelper{}; IoctlHelperUpstream ioctlHelper{};
auto vmBindExtUserFence = ioctlHelper.createVmBindExtUserFence(); VmBindExtUserFenceT vmBindExtUserFence{};
EXPECT_NO_THROW(ioctlHelper.fillVmBindExtUserFence(vmBindExtUserFence, 0u, 0u, 0u)); EXPECT_NO_THROW(ioctlHelper.fillVmBindExtUserFence(vmBindExtUserFence, 0u, 0u, 0u));
} }