intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-08 14:02:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

Use updated macro names

Browse Source 
Related-To: NEO-6730

Signed-off-by: Naklicki, Mateusz <mateusz.naklicki@intel.com>
This commit is contained in:
Naklicki, Mateusz
2022-03-29 17:48:12 +00:00
committed by Compute-Runtime-Automation
parent cf906030ac
commit bce96e666f
10 changed files with 59 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1409,7 +1409,7 @@ int changeBufferObjectBinding(Drm *drm, OsContext *osContext, uint32_t vmHandleI
if (bind) {
std::unique_lock<std::mutex> lock;
auto vmBindExtSyncFence = ioctlHelper->createVmBindExtSyncFence();
auto vmBindExtUserFence = ioctlHelper->createVmBindExtUserFence();
if (drm->useVMBindImmediate()) {
lock = drm->lockBindFenceMutex();
@@ -1419,8 +1419,8 @@ int changeBufferObjectBinding(Drm *drm, OsContext *osContext, uint32_t vmHandleI
auto address = castToUint64(drm->getFenceAddr(vmHandleId));
auto value = drm->getNextFenceVal(vmHandleId);
ioctlHelper->fillVmBindExtSyncFence(vmBindExtSyncFence, address, value, nextExtension);
vmBind.extensions = castToUint64(vmBindExtSyncFence.get());
ioctlHelper->fillVmBindExtUserFence(vmBindExtUserFence, address, value, nextExtension);
vmBind.extensions = castToUint64(vmBindExtUserFence.get());
}
}

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

@@ -112,8 +112,8 @@ class IoctlHelper {
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[]> createVmBindExtSyncFence() = 0;
virtual void fillVmBindExtSyncFence(const std::unique_ptr<uint8_t[]> &vmBindExtSyncFence, 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> getCopyClassSaturateLinkCapability() = 0;
virtual uint32_t getVmAdviseAtomicAttribute() = 0;
@@ -164,8 +164,8 @@ class IoctlHelperUpstream : public IoctlHelper {
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[]> createVmBindExtSyncFence() override;
void fillVmBindExtSyncFence(const std::unique_ptr<uint8_t[]> &vmBindExtSyncFence, 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> getCopyClassSaturateLinkCapability() override;
uint32_t getVmAdviseAtomicAttribute() override;
@@ -229,8 +229,8 @@ class IoctlHelperPrelim20 : public IoctlHelper {
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[]> createVmBindExtSyncFence() override;
void fillVmBindExtSyncFence(const std::unique_ptr<uint8_t[]> &vmBindExtSyncFence, 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> getCopyClassSaturateLinkCapability() override;
uint32_t getVmAdviseAtomicAttribute() override;

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

@@ -216,7 +216,7 @@ bool IoctlHelperPrelim20::setVmPrefetch(Drm *drm, uint64_t start, uint64_t lengt
}
uint32_t IoctlHelperPrelim20::getDirectSubmissionFlag() {
return PRELIM_I915_CONTEXT_CREATE_FLAGS_ULLS;
return PRELIM_I915_CONTEXT_CREATE_FLAGS_LONG_RUNNING;
}
int32_t IoctlHelperPrelim20::getMemRegionsIoctlVal() {
@@ -449,17 +449,17 @@ void IoctlHelperPrelim20::fillVmBindExtSetPat(const std::unique_ptr<uint8_t[]> &
prelimVmBindExtSetPat->base.next_extension = nextExtension;
}
std::unique_ptr<uint8_t[]> IoctlHelperPrelim20::createVmBindExtSyncFence() {
return std::make_unique<uint8_t[]>(sizeof(prelim_drm_i915_vm_bind_ext_sync_fence));
std::unique_ptr<uint8_t[]> IoctlHelperPrelim20::createVmBindExtUserFence() {
return std::make_unique<uint8_t[]>(sizeof(prelim_drm_i915_vm_bind_ext_user_fence));
}
void IoctlHelperPrelim20::fillVmBindExtSyncFence(const std::unique_ptr<uint8_t[]> &vmBindExtSyncFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) {
auto prelimVmBindExtSyncFence = reinterpret_cast<prelim_drm_i915_vm_bind_ext_sync_fence *>(vmBindExtSyncFence.get());
UNRECOVERABLE_IF(!prelimVmBindExtSyncFence);
prelimVmBindExtSyncFence->base.name = PRELIM_I915_VM_BIND_EXT_SYNC_FENCE;
prelimVmBindExtSyncFence->base.next_extension = nextExtension;
prelimVmBindExtSyncFence->addr = fenceAddress;
prelimVmBindExtSyncFence->val = fenceValue;
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());
UNRECOVERABLE_IF(!prelimVmBindExtUserFence);
prelimVmBindExtUserFence->base.name = PRELIM_I915_VM_BIND_EXT_USER_FENCE;
prelimVmBindExtUserFence->base.next_extension = nextExtension;
prelimVmBindExtUserFence->addr = fenceAddress;
prelimVmBindExtUserFence->val = fenceValue;
}
std::optional<uint64_t> IoctlHelperPrelim20::getCopyClassSaturatePCIECapability() {

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

@@ -200,11 +200,11 @@ std::unique_ptr<uint8_t[]> IoctlHelperUpstream::createVmBindExtSetPat() {
void IoctlHelperUpstream::fillVmBindExtSetPat(const std::unique_ptr<uint8_t[]> &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) {}
std::unique_ptr<uint8_t[]> IoctlHelperUpstream::createVmBindExtSyncFence() {
std::unique_ptr<uint8_t[]> IoctlHelperUpstream::createVmBindExtUserFence() {
return {};
}
void IoctlHelperUpstream::fillVmBindExtSyncFence(const std::unique_ptr<uint8_t[]> &vmBindExtSyncFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) {}
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() {
return std::nullopt;

10
shared/test/common/libult/linux/drm_mock_prelim_context.cpp
View File

@@ -409,9 +409,9 @@ void DrmMockPrelimContext::storeVmBindExtensions(uint64_t ptr, bool bind) {
size_t uuidIndex{0};
auto baseExt = reinterpret_cast<i915_user_extension *>(ptr);
while (baseExt) {
if (baseExt->name == PRELIM_I915_VM_BIND_EXT_SYNC_FENCE) {
const auto *ext = reinterpret_cast<prelim_drm_i915_vm_bind_ext_sync_fence *>(baseExt);
receivedVmBindSyncFence = {ext->addr, ext->val};
if (baseExt->name == PRELIM_I915_VM_BIND_EXT_USER_FENCE) {
const auto *ext = reinterpret_cast<prelim_drm_i915_vm_bind_ext_user_fence *>(baseExt);
receivedVmBindUserFence = {ext->addr, ext->val};
} else if (baseExt->name == PRELIM_I915_VM_BIND_EXT_UUID) {
const auto *ext = reinterpret_cast<prelim_drm_i915_vm_bind_ext_uuid *>(baseExt);
receivedVmBindUuidExt[uuidIndex++] = UuidVmBindExt{ext->uuid_handle, ext->base.next_extension};
@@ -444,8 +444,8 @@ uint32_t DrmPrelimHelper::getStringUuidClass() {
return PRELIM_I915_UUID_CLASS_STRING;
}
uint32_t DrmPrelimHelper::getULLSContextCreateFlag() {
return PRELIM_I915_CONTEXT_CREATE_FLAGS_ULLS;
uint32_t DrmPrelimHelper::getLongRunningContextCreateFlag() {
return PRELIM_I915_CONTEXT_CREATE_FLAGS_LONG_RUNNING;
}
uint32_t DrmPrelimHelper::getRunAloneContextParam() {

7
shared/test/common/libult/linux/drm_mock_prelim_context.h
View File

@@ -55,9 +55,10 @@ struct WaitUserFence {
int64_t timeout{0};
};
struct SyncFenceVmBindExt {
struct UserFenceVmBindExt {
uint64_t addr;
uint64_t val;
uint64_t rsvd;
};
struct UuidVmBindExt {
@@ -87,7 +88,7 @@ struct DrmMockPrelimContext {
size_t vmBindCalled{0};
std::optional<VmBindParams> receivedVmBind{};
std::optional<SyncFenceVmBindExt> receivedVmBindSyncFence{};
std::optional<UserFenceVmBindExt> receivedVmBindUserFence{};
std::optional<UuidVmBindExt> receivedVmBindUuidExt[2]{};
std::optional<uint64_t> receivedVmBindPatIndex{};
int vmBindReturn{0};
@@ -127,7 +128,7 @@ uint32_t getQueryComputeSlicesIoctl();
uint32_t getDistanceInfoQueryId();
uint32_t getComputeEngineClass();
uint32_t getStringUuidClass();
uint32_t getULLSContextCreateFlag();
uint32_t getLongRunningContextCreateFlag();
uint32_t getRunAloneContextParam();
uint32_t getAccContextParam();
uint32_t getAccContextParamSize();

6
shared/test/unit_test/os_interface/linux/drm_query_prelim_tests.cpp
View File

@@ -31,7 +31,7 @@ TEST(DrmQueryTest, givenDirectSubmissionActiveWhenCreateDrmContextThenProperFlag
drm.createDrmContext(0, true, false);
EXPECT_TRUE(drm.receivedContextCreateFlags & DrmPrelimHelper::getULLSContextCreateFlag());
EXPECT_TRUE(drm.receivedContextCreateFlags & DrmPrelimHelper::getLongRunningContextCreateFlag());
}
TEST(DrmQueryTest, givenDirectSubmissionDisabledAndDirectSubmissionDrmContextSetWhenCreateDrmContextThenProperFlagIsSet) {
@@ -44,7 +44,7 @@ TEST(DrmQueryTest, givenDirectSubmissionDisabledAndDirectSubmissionDrmContextSet
drm.createDrmContext(0, false, false);
EXPECT_TRUE(drm.receivedContextCreateFlags & DrmPrelimHelper::getULLSContextCreateFlag());
EXPECT_TRUE(drm.receivedContextCreateFlags & DrmPrelimHelper::getLongRunningContextCreateFlag());
}
TEST(DrmQueryTest, givenDirectSubmissionActiveAndDirectSubmissionDrmContextSetZeroWhenCreateDrmContextThenProperFlagIsNotSet) {
@@ -57,7 +57,7 @@ TEST(DrmQueryTest, givenDirectSubmissionActiveAndDirectSubmissionDrmContextSetZe
drm.createDrmContext(0, true, false);
EXPECT_FALSE(drm.receivedContextCreateFlags & DrmPrelimHelper::getULLSContextCreateFlag());
EXPECT_FALSE(drm.receivedContextCreateFlags & DrmPrelimHelper::getLongRunningContextCreateFlag());
}
TEST(DrmQueryTest, givenCooperativeEngineWhenCreateDrmContextThenRunAloneContextIsRequested) {

6
shared/test/unit_test/os_interface/linux/drm_vm_bind_prelim_tests.cpp
View File

@@ -51,9 +51,9 @@ TEST(DrmVmBindTest, givenBoRequiringExplicitResidencyWhenBindingThenMakeResident
if (requireResidency) {
EXPECT_EQ(DrmPrelimHelper::getImmediateVmBindFlag() | DrmPrelimHelper::getMakeResidentVmBindFlag(), drm.context.receivedVmBind->flags);
ASSERT_TRUE(drm.context.receivedVmBindSyncFence);
EXPECT_EQ(castToUint64(drm.getFenceAddr(vmHandleId)), drm.context.receivedVmBindSyncFence->addr);
EXPECT_EQ(drm.fenceVal[vmHandleId], drm.context.receivedVmBindSyncFence->val);
ASSERT_TRUE(drm.context.receivedVmBindUserFence);
EXPECT_EQ(castToUint64(drm.getFenceAddr(vmHandleId)), drm.context.receivedVmBindUserFence->addr);
EXPECT_EQ(drm.fenceVal[vmHandleId], drm.context.receivedVmBindUserFence->val);
} else {
EXPECT_EQ(DrmPrelimHelper::getImmediateVmBindFlag(), drm.context.receivedVmBind->flags);
}

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

@@ -162,7 +162,7 @@ TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenGetHwConfigIoctlValThenCorrectVal
}
TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenGetDirectSubmissionFlagThenCorrectValueReturned) {
EXPECT_EQ(PRELIM_I915_CONTEXT_CREATE_FLAGS_ULLS, ioctlHelper.getDirectSubmissionFlag());
EXPECT_EQ(PRELIM_I915_CONTEXT_CREATE_FLAGS_LONG_RUNNING, ioctlHelper.getDirectSubmissionFlag());
}
TEST_F(IoctlPrelimHelperTests, givenPrelimsWhenGetMemRegionsIoctlValThenCorrectValueReturned) {
@@ -197,8 +197,8 @@ TEST_F(IoctlPrelimHelperTests, whenCreateVmBindSetPatThenValidPointerIsReturned)
EXPECT_NE(nullptr, ioctlHelper.createVmBindExtSetPat());
}
TEST_F(IoctlPrelimHelperTests, whenCreateVmBindSyncFenceThenValidPointerIsReturned) {
EXPECT_NE(nullptr, ioctlHelper.createVmBindExtSyncFence());
TEST_F(IoctlPrelimHelperTests, whenCreateVmBindUserFenceThenValidPointerIsReturned) {
EXPECT_NE(nullptr, ioctlHelper.createVmBindExtUserFence());
}
TEST_F(IoctlPrelimHelperTests, givenNullptrWhenFillVmBindSetPatThenUnrecoverableIsThrown) {
@@ -206,9 +206,9 @@ TEST_F(IoctlPrelimHelperTests, givenNullptrWhenFillVmBindSetPatThenUnrecoverable
EXPECT_THROW(ioctlHelper.fillVmBindExtSetPat(vmBindExtSetPat, 0u, 0u), std::runtime_error);
}
TEST_F(IoctlPrelimHelperTests, givenNullptrWhenFillVmBindSyncFenceThenUnrecoverableIsThrown) {
std::unique_ptr<uint8_t[]> vmBindExtSyncFence{};
EXPECT_THROW(ioctlHelper.fillVmBindExtSyncFence(vmBindExtSyncFence, 0u, 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) {
@@ -226,21 +226,23 @@ TEST_F(IoctlPrelimHelperTests, givenValidInputWhenFillVmBindSetPatThenProperValu
vmBindExtSetPat.release();
}
TEST_F(IoctlPrelimHelperTests, givenValidInputWhenFillVmBindSyncFenceThenProperValuesAreSet) {
std::unique_ptr<uint8_t[]> vmBindExtSyncFence{};
prelim_drm_i915_vm_bind_ext_sync_fence prelimVmBindExtSyncFence{};
vmBindExtSyncFence.reset(reinterpret_cast<uint8_t *>(&prelimVmBindExtSyncFence));
TEST_F(IoctlPrelimHelperTests, givenValidInputWhenFillVmBindUserFenceThenProperValuesAreSet) {
std::unique_ptr<uint8_t[]> 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;
ioctlHelper.fillVmBindExtSyncFence(vmBindExtSyncFence, expectedAddress, expectedValue, expectedNextExtension);
EXPECT_EQ(static_cast<uint32_t>(PRELIM_I915_VM_BIND_EXT_SYNC_FENCE), prelimVmBindExtSyncFence.base.name);
EXPECT_EQ(expectedAddress, prelimVmBindExtSyncFence.addr);
EXPECT_EQ(expectedValue, prelimVmBindExtSyncFence.val);
EXPECT_EQ(expectedNextExtension, prelimVmBindExtSyncFence.base.next_extension);
uint64_t expectedSize = sizeof(prelimVmBindExtUserFence.base) + sizeof(uint64_t) * 3;
ioctlHelper.fillVmBindExtUserFence(vmBindExtUserFence, expectedAddress, expectedValue, expectedNextExtension);
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));
vmBindExtSyncFence.release();
vmBindExtUserFence.release();
}
TEST_F(IoctlPrelimHelperTests, givenPrelimWhenGettingEuStallPropertiesThenCorrectPropertiesAreReturned) {

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

@@ -289,9 +289,9 @@ TEST(IoctlHelperTestsUpstream, whenCreateVmBindSetPatThenNullptrIsReturned) {
EXPECT_EQ(nullptr, ioctlHelper.createVmBindExtSetPat());
}
TEST(IoctlHelperTestsUpstream, whenCreateVmBindSyncFenceThenNullptrIsReturned) {
TEST(IoctlHelperTestsUpstream, whenCreateVmBindUserFenceThenNullptrIsReturned) {
IoctlHelperUpstream ioctlHelper{};
EXPECT_EQ(nullptr, ioctlHelper.createVmBindExtSyncFence());
EXPECT_EQ(nullptr, ioctlHelper.createVmBindExtUserFence());
}
TEST(IoctlHelperTestsUpstream, givenNullptrWhenFillVmBindSetPatThenNothingThrows) {
@@ -300,10 +300,10 @@ TEST(IoctlHelperTestsUpstream, givenNullptrWhenFillVmBindSetPatThenNothingThrows
EXPECT_NO_THROW(ioctlHelper.fillVmBindExtSetPat(vmBindExtSetPat, 0u, 0u));
}
TEST(IoctlHelperTestsUpstream, givenNullptrWhenFillVmBindSyncFenceThenNothingThrows) {
TEST(IoctlHelperTestsUpstream, givenNullptrWhenFillVmBindUserFenceThenNothingThrows) {
IoctlHelperUpstream ioctlHelper{};
auto vmBindExtSyncFence = ioctlHelper.createVmBindExtSyncFence();
EXPECT_NO_THROW(ioctlHelper.fillVmBindExtSyncFence(vmBindExtSyncFence, 0u, 0u, 0u));
auto vmBindExtUserFence = ioctlHelper.createVmBindExtUserFence();
EXPECT_NO_THROW(ioctlHelper.fillVmBindExtUserFence(vmBindExtUserFence, 0u, 0u, 0u));
}
TEST(IoctlHelperTestsUpstream, whenVmBindIsCalledThenZeroIsReturned) {