From e3ede4bb926b03732067e7f4d7cd6b712bab0722 Mon Sep 17 00:00:00 2001 From: Mateusz Jablonski Date: Wed, 7 Dec 2022 12:49:56 +0000 Subject: [PATCH] Correct naming in memadvise flags Signed-off-by: Mateusz Jablonski --- level_zero/core/source/cmdlist/cmdlist_hw.inl | 20 ++--- .../memory/cpu_page_fault_memory_manager.cpp | 4 +- .../sources/cmdlist/test_cmdlist_1.cpp | 76 +++++++++---------- .../source/memory_manager/memadvise_flags.h | 38 +++++----- .../os_interface/linux/drm_allocation.cpp | 12 +-- .../linux/drm_memory_manager_tests.cpp | 8 +- .../linux/drm_with_prelim_tests.cpp | 12 +-- 7 files changed, 86 insertions(+), 84 deletions(-) diff --git a/level_zero/core/source/cmdlist/cmdlist_hw.inl b/level_zero/core/source/cmdlist/cmdlist_hw.inl index e45be62b38..d370119d7d 100644 --- a/level_zero/core/source/cmdlist/cmdlist_hw.inl +++ b/level_zero/core/source/cmdlist/cmdlist_hw.inl @@ -878,7 +878,7 @@ ze_result_t CommandListCoreFamily::appendMemAdvise(ze_device_hand const void *ptr, size_t size, ze_memory_advice_t advice) { NEO::MemAdviseFlags flags; - flags.memadvise_flags = 0; + flags.allFlags = 0; auto allocData = device->getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr); if (allocData) { @@ -890,22 +890,22 @@ ze_result_t CommandListCoreFamily::appendMemAdvise(ze_device_hand switch (advice) { case ZE_MEMORY_ADVICE_SET_READ_MOSTLY: - flags.read_only = 1; + flags.readOnly = 1; break; case ZE_MEMORY_ADVICE_CLEAR_READ_MOSTLY: - flags.read_only = 0; + flags.readOnly = 0; break; case ZE_MEMORY_ADVICE_SET_PREFERRED_LOCATION: - flags.device_preferred_location = 1; + flags.devicePreferredLocation = 1; break; case ZE_MEMORY_ADVICE_CLEAR_PREFERRED_LOCATION: - flags.device_preferred_location = 0; + flags.devicePreferredLocation = 0; break; case ZE_MEMORY_ADVICE_BIAS_CACHED: - flags.cached_memory = 1; + flags.cachedMemory = 1; break; case ZE_MEMORY_ADVICE_BIAS_UNCACHED: - flags.cached_memory = 0; + flags.cachedMemory = 0; break; case ZE_MEMORY_ADVICE_SET_NON_ATOMIC_MOSTLY: case ZE_MEMORY_ADVICE_CLEAR_NON_ATOMIC_MOSTLY: @@ -917,10 +917,10 @@ ze_result_t CommandListCoreFamily::appendMemAdvise(ze_device_hand auto pageFaultManager = memoryManager->getPageFaultManager(); if (pageFaultManager) { /* If Read Only and Device Preferred Hints have been cleared, then cpu_migration of Shared memory can be re-enabled*/ - if (flags.cpu_migration_blocked) { - if (flags.read_only == 0 && flags.device_preferred_location == 0) { + if (flags.cpuMigrationBlocked) { + if (flags.readOnly == 0 && flags.devicePreferredLocation == 0) { pageFaultManager->protectCPUMemoryAccess(const_cast(ptr), size); - flags.cpu_migration_blocked = 0; + flags.cpuMigrationBlocked = 0; } } /* Given MemAdvise hints, use different gpu Domain Handler for the Page Fault Handling */ diff --git a/level_zero/core/source/memory/cpu_page_fault_memory_manager.cpp b/level_zero/core/source/memory/cpu_page_fault_memory_manager.cpp index b9aa79a675..87f602e152 100644 --- a/level_zero/core/source/memory/cpu_page_fault_memory_manager.cpp +++ b/level_zero/core/source/memory/cpu_page_fault_memory_manager.cpp @@ -50,9 +50,9 @@ void transferAndUnprotectMemoryWithHints(NEO::PageFaultManager *pageFaultHandler NEO::SvmAllocationData *allocData = deviceImp->getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(allocPtr); if (deviceImp->memAdviseSharedAllocations.find(allocData) != deviceImp->memAdviseSharedAllocations.end()) { - if (deviceImp->memAdviseSharedAllocations[allocData].read_only && deviceImp->memAdviseSharedAllocations[allocData].device_preferred_location) { + if (deviceImp->memAdviseSharedAllocations[allocData].readOnly && deviceImp->memAdviseSharedAllocations[allocData].devicePreferredLocation) { migration = false; - deviceImp->memAdviseSharedAllocations[allocData].cpu_migration_blocked = 1; + deviceImp->memAdviseSharedAllocations[allocData].cpuMigrationBlocked = 1; } } if (migration) { diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp index e18f46860c..4e20871ef7 100644 --- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp +++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp @@ -262,11 +262,11 @@ TEST_F(CommandListCreate, givenValidPtrThenAppendMemAdviseSetAndClearReadMostlyT auto allocData = device->getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr); L0::DeviceImp *deviceImp = static_cast((L0::Device::fromHandle(device))); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.read_only); + EXPECT_EQ(1, flags.readOnly); res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_CLEAR_READ_MOSTLY); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(0, flags.read_only); + EXPECT_EQ(0, flags.readOnly); res = context->freeMem(ptr); ASSERT_EQ(res, ZE_RESULT_SUCCESS); @@ -294,11 +294,11 @@ TEST_F(CommandListCreate, givenValidPtrThenAppendMemAdviseSetAndClearPreferredLo auto allocData = device->getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr); L0::DeviceImp *deviceImp = static_cast((L0::Device::fromHandle(device))); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.device_preferred_location); + EXPECT_EQ(1, flags.devicePreferredLocation); res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_CLEAR_PREFERRED_LOCATION); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(0, flags.device_preferred_location); + EXPECT_EQ(0, flags.devicePreferredLocation); res = context->freeMem(ptr); ASSERT_EQ(res, ZE_RESULT_SUCCESS); @@ -326,11 +326,11 @@ TEST_F(CommandListCreate, givenValidPtrWhenAppendMemAdviseSetAndClearNonAtomicMo auto allocData = device->getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr); L0::DeviceImp *deviceImp = static_cast((L0::Device::fromHandle(device))); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(0, flags.non_atomic); + EXPECT_EQ(0, flags.nonAtomic); res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_CLEAR_NON_ATOMIC_MOSTLY); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(0, flags.non_atomic); + EXPECT_EQ(0, flags.nonAtomic); res = context->freeMem(ptr); ASSERT_EQ(res, ZE_RESULT_SUCCESS); @@ -358,14 +358,14 @@ TEST_F(CommandListCreate, givenValidPtrThenAppendMemAdviseSetAndClearCachingThen auto allocData = device->getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr); L0::DeviceImp *deviceImp = static_cast((L0::Device::fromHandle(device))); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.cached_memory); + EXPECT_EQ(1, flags.cachedMemory); auto memoryManager = static_cast(device->getDriverHandle()->getMemoryManager()); - EXPECT_EQ(1, memoryManager->memAdviseFlags.cached_memory); + EXPECT_EQ(1, memoryManager->memAdviseFlags.cachedMemory); res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_BIAS_UNCACHED); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(0, flags.cached_memory); - EXPECT_EQ(0, memoryManager->memAdviseFlags.cached_memory); + EXPECT_EQ(0, flags.cachedMemory); + EXPECT_EQ(0, memoryManager->memAdviseFlags.cachedMemory); res = context->freeMem(ptr); ASSERT_EQ(res, ZE_RESULT_SUCCESS); @@ -394,18 +394,18 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerThenAppend auto allocData = device->getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr); flags = deviceImp->memAdviseSharedAllocations[allocData]; - flags.cpu_migration_blocked = 1; + flags.cpuMigrationBlocked = 1; deviceImp->memAdviseSharedAllocations[allocData] = flags; res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_SET_READ_MOSTLY); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.read_only); + EXPECT_EQ(1, flags.readOnly); res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_SET_PREFERRED_LOCATION); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.device_preferred_location); + EXPECT_EQ(1, flags.devicePreferredLocation); res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_CLEAR_READ_MOSTLY); EXPECT_EQ(ZE_RESULT_SUCCESS, res); @@ -413,9 +413,9 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerThenAppend res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_CLEAR_PREFERRED_LOCATION); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(0, flags.read_only); - EXPECT_EQ(0, flags.device_preferred_location); - EXPECT_EQ(0, flags.cpu_migration_blocked); + EXPECT_EQ(0, flags.readOnly); + EXPECT_EQ(0, flags.devicePreferredLocation); + EXPECT_EQ(0, flags.cpuMigrationBlocked); res = context->freeMem(ptr); ASSERT_EQ(res, ZE_RESULT_SUCCESS); @@ -447,12 +447,12 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerThenGpuDom res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_SET_READ_MOSTLY); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.read_only); + EXPECT_EQ(1, flags.readOnly); res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_SET_PREFERRED_LOCATION); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.device_preferred_location); + EXPECT_EQ(1, flags.devicePreferredLocation); auto handlerWithHints = L0::transferAndUnprotectMemoryWithHints; @@ -486,12 +486,12 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerAndGpuDoma res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_SET_READ_MOSTLY); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.read_only); + EXPECT_EQ(1, flags.readOnly); res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_SET_PREFERRED_LOCATION); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.device_preferred_location); + EXPECT_EQ(1, flags.devicePreferredLocation); auto handlerWithHints = L0::transferAndUnprotectMemoryWithHints; @@ -502,7 +502,7 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerAndGpuDoma pageData.domain = NEO::PageFaultManager::AllocationDomain::Gpu; mockPageFaultManager->gpuDomainHandler(mockPageFaultManager, ptr, pageData); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.cpu_migration_blocked); + EXPECT_EQ(1, flags.cpuMigrationBlocked); res = context->freeMem(ptr); ASSERT_EQ(res, ZE_RESULT_SUCCESS); @@ -532,7 +532,7 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerAndGpuDoma res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_SET_READ_MOSTLY); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.read_only); + EXPECT_EQ(1, flags.readOnly); auto handlerWithHints = L0::transferAndUnprotectMemoryWithHints; @@ -543,30 +543,30 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerAndGpuDoma pageData.domain = NEO::PageFaultManager::AllocationDomain::Gpu; mockPageFaultManager->gpuDomainHandler(mockPageFaultManager, ptr, pageData); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(0, flags.cpu_migration_blocked); + EXPECT_EQ(0, flags.cpuMigrationBlocked); res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_CLEAR_READ_MOSTLY); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(0, flags.read_only); + EXPECT_EQ(0, flags.readOnly); res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_SET_PREFERRED_LOCATION); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.device_preferred_location); + EXPECT_EQ(1, flags.devicePreferredLocation); mockPageFaultManager->gpuDomainHandler(mockPageFaultManager, ptr, pageData); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(0, flags.cpu_migration_blocked); + EXPECT_EQ(0, flags.cpuMigrationBlocked); res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_CLEAR_PREFERRED_LOCATION); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(0, flags.device_preferred_location); + EXPECT_EQ(0, flags.devicePreferredLocation); mockPageFaultManager->gpuDomainHandler(mockPageFaultManager, ptr, pageData); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(0, flags.cpu_migration_blocked); + EXPECT_EQ(0, flags.cpuMigrationBlocked); res = context->freeMem(ptr); ASSERT_EQ(res, ZE_RESULT_SUCCESS); @@ -601,7 +601,7 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerAndGpuDoma res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_SET_READ_MOSTLY); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.read_only); + EXPECT_EQ(1, flags.readOnly); auto handlerWithHints = L0::transferAndUnprotectMemoryWithHints; @@ -614,7 +614,7 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerAndGpuDoma pageData.domain = NEO::PageFaultManager::AllocationDomain::Gpu; mockPageFaultManager->gpuDomainHandler(mockPageFaultManager, ptr, pageData); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(0, flags.cpu_migration_blocked); + EXPECT_EQ(0, flags.cpuMigrationBlocked); std::string output = testing::internal::GetCapturedStdout(); // stop capturing @@ -656,7 +656,7 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerAndGpuDoma res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_BIAS_CACHED); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.cached_memory); + EXPECT_EQ(1, flags.cachedMemory); auto handlerWithHints = L0::transferAndUnprotectMemoryWithHints; @@ -667,7 +667,7 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerAndGpuDoma pageData.domain = NEO::PageFaultManager::AllocationDomain::Gpu; mockPageFaultManager->gpuDomainHandler(mockPageFaultManager, ptr, pageData); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(0, flags.cpu_migration_blocked); + EXPECT_EQ(0, flags.cpuMigrationBlocked); res = context->freeMem(ptr); ASSERT_EQ(res, ZE_RESULT_SUCCESS); @@ -697,12 +697,12 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerAndGpuDoma res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_SET_READ_MOSTLY); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.read_only); + EXPECT_EQ(1, flags.readOnly); res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_SET_PREFERRED_LOCATION); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.device_preferred_location); + EXPECT_EQ(1, flags.devicePreferredLocation); auto handlerWithHints = L0::transferAndUnprotectMemoryWithHints; @@ -713,7 +713,7 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerAndGpuDoma pageData.domain = NEO::PageFaultManager::AllocationDomain::Cpu; mockPageFaultManager->gpuDomainHandler(mockPageFaultManager, ptr, pageData); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(0, flags.cpu_migration_blocked); + EXPECT_EQ(0, flags.cpuMigrationBlocked); res = context->freeMem(ptr); ASSERT_EQ(res, ZE_RESULT_SUCCESS); @@ -743,12 +743,12 @@ TEST_F(CommandListMemAdvisePageFault, givenInvalidPtrAndPageFaultHandlerAndGpuDo res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_SET_READ_MOSTLY); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.read_only); + EXPECT_EQ(1, flags.readOnly); res = commandList->appendMemAdvise(device, ptr, size, ZE_MEMORY_ADVICE_SET_PREFERRED_LOCATION); EXPECT_EQ(ZE_RESULT_SUCCESS, res); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(1, flags.device_preferred_location); + EXPECT_EQ(1, flags.devicePreferredLocation); auto handlerWithHints = L0::transferAndUnprotectMemoryWithHints; @@ -760,7 +760,7 @@ TEST_F(CommandListMemAdvisePageFault, givenInvalidPtrAndPageFaultHandlerAndGpuDo void *alloc = reinterpret_cast(0x1); mockPageFaultManager->gpuDomainHandler(mockPageFaultManager, alloc, pageData); flags = deviceImp->memAdviseSharedAllocations[allocData]; - EXPECT_EQ(0, flags.cpu_migration_blocked); + EXPECT_EQ(0, flags.cpuMigrationBlocked); res = context->freeMem(ptr); ASSERT_EQ(res, ZE_RESULT_SUCCESS); diff --git a/shared/source/memory_manager/memadvise_flags.h b/shared/source/memory_manager/memadvise_flags.h index cc358322da..524bdf9c9f 100644 --- a/shared/source/memory_manager/memadvise_flags.h +++ b/shared/source/memory_manager/memadvise_flags.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2021 Intel Corporation + * Copyright (C) 2021-2022 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -11,23 +11,25 @@ namespace NEO { -typedef union MemAdviseFlagsTag { - uint8_t memadvise_flags; /* all memadvise_flags */ - struct - { - uint8_t read_only : 1, /* ZE_MEMORY_ADVICE_SET_READ_MOSTLY or ZE_MEMORY_ADVICE_CLEAR_READ_MOSTLY */ - device_preferred_location : 1, /* ZE_MEMORY_ADVICE_SET_PREFERRED_LOCATION or ZE_MEMORY_ADVICE_CLEAR_PREFERRED_LOCATION */ - non_atomic : 1, /* ZE_MEMORY_ADVICE_SET_NON_ATOMIC_MOSTLY or ZE_MEMORY_ADVICE_CLEAR_NON_ATOMIC_MOSTLY */ - cached_memory : 1, /* ZE_MEMORY_ADVICE_BIAS_CACHED or ZE_MEMORY_ADVICE_BIAS_UNCACHED */ - cpu_migration_blocked : 1, /* ZE_MEMORY_ADVICE_SET_READ_MOSTLY and ZE_MEMORY_ADVICE_SET_PREFERRED_LOCATION */ - reserved2 : 1, - reserved1 : 1, - reserved0 : 1; +struct MemAdviseFlags { + union { + uint8_t allFlags; /* all memAdvise flags */ + struct + { + uint8_t readOnly : 1; /* ZE_MEMORY_ADVICE_SET_READ_MOSTLY or ZE_MEMORY_ADVICE_CLEAR_READ_MOSTLY */ + uint8_t devicePreferredLocation : 1; /* ZE_MEMORY_ADVICE_SET_PREFERRED_LOCATION or ZE_MEMORY_ADVICE_CLEAR_PREFERRED_LOCATION */ + uint8_t nonAtomic : 1; /* ZE_MEMORY_ADVICE_SET_NON_ATOMIC_MOSTLY or ZE_MEMORY_ADVICE_CLEAR_NON_ATOMIC_MOSTLY */ + uint8_t cachedMemory : 1; /* ZE_MEMORY_ADVICE_BIAS_CACHED or ZE_MEMORY_ADVICE_BIAS_UNCACHED */ + uint8_t cpuMigrationBlocked : 1; /* ZE_MEMORY_ADVICE_SET_READ_MOSTLY and ZE_MEMORY_ADVICE_SET_PREFERRED_LOCATION */ + uint8_t reserved2 : 1; + uint8_t reserved1 : 1; + uint8_t reserved0 : 1; + }; }; - MemAdviseFlagsTag() { - memadvise_flags = 0; - cached_memory = 1; + MemAdviseFlags() { + allFlags = 0; + cachedMemory = 1; } -} MemAdviseFlags; - +}; +static_assert(sizeof(MemAdviseFlags) == sizeof(uint8_t), ""); } // namespace NEO diff --git a/shared/source/os_interface/linux/drm_allocation.cpp b/shared/source/os_interface/linux/drm_allocation.cpp index 39a2910b12..12df5eca94 100644 --- a/shared/source/os_interface/linux/drm_allocation.cpp +++ b/shared/source/os_interface/linux/drm_allocation.cpp @@ -297,26 +297,26 @@ bool DrmAllocation::shouldAllocationPageFault(const Drm *drm) { bool DrmAllocation::setMemAdvise(Drm *drm, MemAdviseFlags flags) { bool success = true; - if (flags.cached_memory != enabledMemAdviseFlags.cached_memory) { - CachePolicy memType = flags.cached_memory ? CachePolicy::WriteBack : CachePolicy::Uncached; + if (flags.cachedMemory != enabledMemAdviseFlags.cachedMemory) { + CachePolicy memType = flags.cachedMemory ? CachePolicy::WriteBack : CachePolicy::Uncached; setCachePolicy(memType); } auto ioctlHelper = drm->getIoctlHelper(); - if (flags.non_atomic != enabledMemAdviseFlags.non_atomic) { + if (flags.nonAtomic != enabledMemAdviseFlags.nonAtomic) { for (auto bo : bufferObjects) { if (bo != nullptr) { - success &= ioctlHelper->setVmBoAdvise(bo->peekHandle(), ioctlHelper->getAtomicAdvise(flags.non_atomic), nullptr); + success &= ioctlHelper->setVmBoAdvise(bo->peekHandle(), ioctlHelper->getAtomicAdvise(flags.nonAtomic), nullptr); } } } - if (flags.device_preferred_location != enabledMemAdviseFlags.device_preferred_location) { + if (flags.devicePreferredLocation != enabledMemAdviseFlags.devicePreferredLocation) { MemoryClassInstance region{}; for (auto handleId = 0u; handleId < EngineLimits::maxHandleCount; handleId++) { auto bo = bufferObjects[handleId]; if (bo != nullptr) { - if (flags.device_preferred_location) { + if (flags.devicePreferredLocation) { region.memoryClass = ioctlHelper->getDrmParamValue(DrmParam::MemoryClassDevice); region.memoryInstance = handleId; } else { diff --git a/shared/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp b/shared/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp index 74c7d382df..39633c0b33 100644 --- a/shared/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp +++ b/shared/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp @@ -3856,16 +3856,16 @@ TEST_F(DrmAllocationTests, givenDrmAllocationWhenSetMemAdviseWithCachePolicyIsCa EXPECT_EQ(CachePolicy::WriteBack, bo.peekCachePolicy()); MemAdviseFlags memAdviseFlags{}; - EXPECT_TRUE(memAdviseFlags.cached_memory); + EXPECT_TRUE(memAdviseFlags.cachedMemory); for (auto cached : {true, false, true}) { - memAdviseFlags.cached_memory = cached; + memAdviseFlags.cachedMemory = cached; EXPECT_TRUE(allocation.setMemAdvise(&drm, memAdviseFlags)); EXPECT_EQ(cached ? CachePolicy::WriteBack : CachePolicy::Uncached, bo.peekCachePolicy()); - EXPECT_EQ(memAdviseFlags.memadvise_flags, allocation.enabledMemAdviseFlags.memadvise_flags); + EXPECT_EQ(memAdviseFlags.allFlags, allocation.enabledMemAdviseFlags.allFlags); } } @@ -4291,7 +4291,7 @@ TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenSetMemAdviseIsCalledThenUp for (auto isCached : {false, true}) { MemAdviseFlags flags{}; - flags.cached_memory = isCached; + flags.cachedMemory = isCached; EXPECT_TRUE(memoryManager.setMemAdvise(&drmAllocation, flags, rootDeviceIndex)); EXPECT_EQ(isCached ? CachePolicy::WriteBack : CachePolicy::Uncached, bo.peekCachePolicy()); diff --git a/shared/test/unit_test/os_interface/linux/drm_with_prelim_tests.cpp b/shared/test/unit_test/os_interface/linux/drm_with_prelim_tests.cpp index d9cfe3c526..6ff1b72ea0 100644 --- a/shared/test/unit_test/os_interface/linux/drm_with_prelim_tests.cpp +++ b/shared/test/unit_test/os_interface/linux/drm_with_prelim_tests.cpp @@ -241,12 +241,12 @@ TEST_F(IoctlHelperPrelimFixture, givenDrmAllocationWhenSetMemAdviseFailsThenDont allocation.bufferObjects[0] = &bo; MemAdviseFlags memAdviseFlags{}; - memAdviseFlags.non_atomic = 1; + memAdviseFlags.nonAtomic = 1; allocation.setMemAdvise(drm.get(), memAdviseFlags); EXPECT_EQ(1u, drm->ioctlCallsCount); - EXPECT_NE(memAdviseFlags.memadvise_flags, allocation.enabledMemAdviseFlags.memadvise_flags); + EXPECT_NE(memAdviseFlags.allFlags, allocation.enabledMemAdviseFlags.allFlags); } TEST_F(IoctlHelperPrelimFixture, givenDrmAllocationWhenSetMemAdviseWithNonAtomicIsCalledThenUpdateTheCorrespondingVmAdviceForBufferObject) { @@ -258,10 +258,10 @@ TEST_F(IoctlHelperPrelimFixture, givenDrmAllocationWhenSetMemAdviseWithNonAtomic MemAdviseFlags memAdviseFlags{}; for (auto nonAtomic : {true, false}) { - memAdviseFlags.non_atomic = nonAtomic; + memAdviseFlags.nonAtomic = nonAtomic; EXPECT_TRUE(allocation.setMemAdvise(drm.get(), memAdviseFlags)); - EXPECT_EQ(memAdviseFlags.memadvise_flags, allocation.enabledMemAdviseFlags.memadvise_flags); + EXPECT_EQ(memAdviseFlags.allFlags, allocation.enabledMemAdviseFlags.allFlags); } EXPECT_EQ(2u, drm->ioctlCallsCount); } @@ -275,10 +275,10 @@ TEST_F(IoctlHelperPrelimFixture, givenDrmAllocationWhenSetMemAdviseWithDevicePre MemAdviseFlags memAdviseFlags{}; for (auto devicePreferredLocation : {true, false}) { - memAdviseFlags.device_preferred_location = devicePreferredLocation; + memAdviseFlags.devicePreferredLocation = devicePreferredLocation; EXPECT_TRUE(allocation.setMemAdvise(drm.get(), memAdviseFlags)); - EXPECT_EQ(memAdviseFlags.memadvise_flags, allocation.enabledMemAdviseFlags.memadvise_flags); + EXPECT_EQ(memAdviseFlags.allFlags, allocation.enabledMemAdviseFlags.allFlags); } EXPECT_EQ(2u, drm->ioctlCallsCount); }