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();
}
auto vmBindExtSetPat = ioctlHelper->createVmBindExtSetPat();
VmBindExtSetPatT vmBindExtSetPat{};
if (closEnabled) {
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());
}
ioctlHelper->fillVmBindExtSetPat(vmBindExtSetPat, patIndex, castToUint64(extensions.get()));
vmBind.extensions = castToUint64(vmBindExtSetPat.get());
vmBind.extensions = castToUint64(vmBindExtSetPat);
} else {
vmBind.extensions = castToUint64(extensions.get());
}
@ -1413,7 +1413,7 @@ int changeBufferObjectBinding(Drm *drm, OsContext *osContext, uint32_t vmHandleI
if (bind) {
std::unique_lock<std::mutex> lock;
auto vmBindExtUserFence = ioctlHelper->createVmBindExtUserFence();
VmBindExtUserFenceT vmBindExtUserFence{};
if (drm->useVMBindImmediate()) {
lock = drm->lockBindFenceMutex();
@ -1424,7 +1424,7 @@ int changeBufferObjectBinding(Drm *drm, OsContext *osContext, uint32_t vmHandleI
auto value = drm->getNextFenceVal(vmHandleId);
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 VmBindExtSetPatT = uint8_t[40];
using VmBindExtUserFenceT = uint8_t[56];
class IoctlHelper {
public:
@ -110,10 +112,8 @@ class IoctlHelper {
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 createCooperativeContext(Drm *drm, drm_i915_gem_context_create_ext &gcc) = 0;
virtual std::unique_ptr<uint8_t[]> createVmBindExtSetPat() = 0;
virtual void fillVmBindExtSetPat(const std::unique_ptr<uint8_t[]> &vmBindExtSetPat, uint64_t patIndex, 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 void fillVmBindExtSetPat(VmBindExtSetPatT &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::optional<uint64_t> getCopyClassSaturatePCIECapability() = 0;
virtual std::optional<uint64_t> getCopyClassSaturateLinkCapability() = 0;
virtual uint32_t getVmAdviseAtomicAttribute() = 0;
@ -163,10 +163,8 @@ class IoctlHelperUpstream : public IoctlHelper {
uint32_t getFlagsForVmCreate(bool disableScratch, bool enablePageFault) 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;
std::unique_ptr<uint8_t[]> createVmBindExtSetPat() override;
void fillVmBindExtSetPat(const std::unique_ptr<uint8_t[]> &vmBindExtSetPat, uint64_t patIndex, 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;
void fillVmBindExtSetPat(VmBindExtSetPatT &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) override;
void fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) override;
std::optional<uint64_t> getCopyClassSaturatePCIECapability() override;
std::optional<uint64_t> getCopyClassSaturateLinkCapability() override;
uint32_t getVmAdviseAtomicAttribute() override;
@ -229,10 +227,8 @@ class IoctlHelperPrelim20 : public IoctlHelper {
uint32_t getFlagsForVmCreate(bool disableScratch, bool enablePageFault) 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;
std::unique_ptr<uint8_t[]> createVmBindExtSetPat() override;
void fillVmBindExtSetPat(const std::unique_ptr<uint8_t[]> &vmBindExtSetPat, uint64_t patIndex, 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;
void fillVmBindExtSetPat(VmBindExtSetPatT &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) override;
void fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) override;
std::optional<uint64_t> getCopyClassSaturatePCIECapability() override;
std::optional<uint64_t> getCopyClassSaturateLinkCapability() 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);
}
std::unique_ptr<uint8_t[]> IoctlHelperPrelim20::createVmBindExtSetPat() {
return std::make_unique<uint8_t[]>(sizeof(prelim_drm_i915_vm_bind_ext_set_pat));
};
static_assert(sizeof(VmBindExtSetPatT) == sizeof(prelim_drm_i915_vm_bind_ext_set_pat), "Invalid size for VmBindExtSetPat");
void IoctlHelperPrelim20::fillVmBindExtSetPat(const std::unique_ptr<uint8_t[]> &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) {
auto prelimVmBindExtSetPat = reinterpret_cast<prelim_drm_i915_vm_bind_ext_set_pat *>(vmBindExtSetPat.get());
void IoctlHelperPrelim20::fillVmBindExtSetPat(VmBindExtSetPatT &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) {
auto prelimVmBindExtSetPat = reinterpret_cast<prelim_drm_i915_vm_bind_ext_set_pat *>(vmBindExtSetPat);
UNRECOVERABLE_IF(!prelimVmBindExtSetPat);
prelimVmBindExtSetPat->base.name = PRELIM_I915_VM_BIND_EXT_SET_PAT;
prelimVmBindExtSetPat->pat_index = patIndex;
prelimVmBindExtSetPat->base.next_extension = nextExtension;
}
std::unique_ptr<uint8_t[]> IoctlHelperPrelim20::createVmBindExtUserFence() {
return std::make_unique<uint8_t[]>(sizeof(prelim_drm_i915_vm_bind_ext_user_fence));
}
static_assert(sizeof(VmBindExtUserFenceT) == sizeof(prelim_drm_i915_vm_bind_ext_user_fence), "Invalid size for VmBindExtUserFence");
void IoctlHelperPrelim20::fillVmBindExtUserFence(const std::unique_ptr<uint8_t[]> &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) {
auto prelimVmBindExtUserFence = reinterpret_cast<prelim_drm_i915_vm_bind_ext_user_fence *>(vmBindExtUserFence.get());
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);
UNRECOVERABLE_IF(!prelimVmBindExtUserFence);
prelimVmBindExtUserFence->base.name = PRELIM_I915_VM_BIND_EXT_USER_FENCE;
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;
}
std::unique_ptr<uint8_t[]> IoctlHelperUpstream::createVmBindExtSetPat() {
return {};
}
void IoctlHelperUpstream::fillVmBindExtSetPat(VmBindExtSetPatT &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) {}
void IoctlHelperUpstream::fillVmBindExtSetPat(const std::unique_ptr<uint8_t[]> &vmBindExtSetPat, uint64_t patIndex, 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) {}
void IoctlHelperUpstream::fillVmBindExtUserFence(VmBindExtUserFenceT &vmBindExtUserFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) {}
std::optional<uint64_t> IoctlHelperUpstream::getCopyClassSaturatePCIECapability() {
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_strings.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());
}
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) {
std::unique_ptr<uint8_t[]> vmBindExtSetPat{};
VmBindExtSetPatT vmBindExtSetPat{};
prelim_drm_i915_vm_bind_ext_set_pat prelimVmBindExtSetPat{};
vmBindExtSetPat.reset(reinterpret_cast<uint8_t *>(&prelimVmBindExtSetPat));
uint64_t expectedPatIndex = 2;
uint64_t expectedNextExtension = 3;
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(expectedPatIndex, prelimVmBindExtSetPat.pat_index);
EXPECT_EQ(expectedNextExtension, prelimVmBindExtSetPat.base.next_extension);
vmBindExtSetPat.release();
}
TEST_F(IoctlPrelimHelperTests, givenValidInputWhenFillVmBindUserFenceThenProperValuesAreSet) {
std::unique_ptr<uint8_t[]> vmBindExtUserFence{};
VmBindExtUserFenceT vmBindExtUserFence{};
prelim_drm_i915_vm_bind_ext_user_fence prelimVmBindExtUserFence{};
vmBindExtUserFence.reset(reinterpret_cast<uint8_t *>(&prelimVmBindExtUserFence));
uint64_t expectedAddress = 0xdead;
uint64_t expectedValue = 0xc0de;
uint64_t expectedNextExtension = 1234;
uint64_t expectedSize = sizeof(prelimVmBindExtUserFence.base) + sizeof(uint64_t) * 3;
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(expectedAddress, prelimVmBindExtUserFence.addr);
EXPECT_EQ(expectedValue, prelimVmBindExtUserFence.val);
EXPECT_EQ(expectedNextExtension, prelimVmBindExtUserFence.base.next_extension);
EXPECT_EQ(expectedSize, sizeof(prelimVmBindExtUserFence));
vmBindExtUserFence.release();
}
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));
}
TEST(IoctlHelperTestsUpstream, whenCreateVmBindSetPatThenNullptrIsReturned) {
TEST(IoctlHelperTestsUpstream, whenFillVmBindSetPatThenNothingThrows) {
IoctlHelperUpstream ioctlHelper{};
EXPECT_EQ(nullptr, ioctlHelper.createVmBindExtSetPat());
}
TEST(IoctlHelperTestsUpstream, whenCreateVmBindUserFenceThenNullptrIsReturned) {
IoctlHelperUpstream ioctlHelper{};
EXPECT_EQ(nullptr, ioctlHelper.createVmBindExtUserFence());
}
TEST(IoctlHelperTestsUpstream, givenNullptrWhenFillVmBindSetPatThenNothingThrows) {
IoctlHelperUpstream ioctlHelper{};
auto vmBindExtSetPat = ioctlHelper.createVmBindExtSetPat();
VmBindExtSetPatT vmBindExtSetPat{};
EXPECT_NO_THROW(ioctlHelper.fillVmBindExtSetPat(vmBindExtSetPat, 0u, 0u));
}
TEST(IoctlHelperTestsUpstream, givenNullptrWhenFillVmBindUserFenceThenNothingThrows) {
TEST(IoctlHelperTestsUpstream, whenFillVmBindUserFenceThenNothingThrows) {
IoctlHelperUpstream ioctlHelper{};
auto vmBindExtUserFence = ioctlHelper.createVmBindExtUserFence();
VmBindExtUserFenceT vmBindExtUserFence{};
EXPECT_NO_THROW(ioctlHelper.fillVmBindExtUserFence(vmBindExtUserFence, 0u, 0u, 0u));
}