Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix: Removind address_mapper.h 

Related-To: NEO-14718
Signed-off-by: Aleksandra Nizio <aleksandra.nizio@intel.com>
This commit is contained in:
Aleksandra Nizio 2025-05-27 18:27:32 +00:00 committed by Compute-Runtime-Automation
parent 1484e43bb7
commit 1dfc9227c4
9 changed files with 1 additions and 256 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
shared/source/aub/aub_center.h
View File

@ -8,7 +8,6 @@
#pragma once
#include "shared/source/aub/aub_subcapture.h"
#include "shared/source/helpers/options.h"
#include "shared/source/memory_manager/address_mapper.h"
#include "shared/source/memory_manager/physical_address_allocator.h"
#include "aubstream/aub_manager.h"

1
shared/source/command_stream/command_stream_receiver_simulated_common_hw_base.inl
View File

@ -17,7 +17,6 @@
#include "shared/source/helpers/aligned_memory.h"
#include "shared/source/helpers/basic_math.h"
#include "shared/source/helpers/hardware_context_controller.h"
#include "shared/source/memory_manager/address_mapper.h"
#include "shared/source/memory_manager/memory_manager.h"
#include "shared/source/os_interface/os_context.h"

3
shared/source/command_stream/tbx_command_stream_receiver_hw.h
View File

@ -9,7 +9,6 @@
#include "shared/source/command_stream/command_stream_receiver_simulated_hw.h"
#include "shared/source/command_stream/tbx_command_stream_receiver.h"
#include "shared/source/command_stream/wait_status.h"
#include "shared/source/memory_manager/address_mapper.h"
#include "shared/source/memory_manager/page_table.h"
#include <array>
@ -101,8 +100,6 @@ class TbxCommandStreamReceiverHw : public CommandStreamReceiverSimulatedHw<GfxFa
std::unique_ptr<PhysicalAddressAllocator> physicalAddressAllocator;
std::unique_ptr<std::conditional<is64bit, PML4, PDPE>::type> ppgtt;
std::unique_ptr<PDPE> ggtt;
// remap CPU VA -> GGTT VA
AddressMapper gttRemap;
std::set<GraphicsAllocation *> allocationsForDownload = {};

74
shared/source/command_stream/tbx_command_stream_receiver_hw.inl
View File

@ -144,80 +144,6 @@ void TbxCommandStreamReceiverHw<GfxFamily>::initializeEngine() {
return;
}
DEBUG_BREAK_IF(this->aubManager);
auto csTraits = this->getCsTraits(osContext->getEngineType());
if (engineInfo.pLRCA) {
return;
}
// Global HW Status Page
{
const size_t sizeHWSP = 0x1000;
const size_t alignHWSP = 0x1000;
engineInfo.pGlobalHWStatusPage = alignedMalloc(sizeHWSP, alignHWSP);
engineInfo.ggttHWSP = gttRemap.map(engineInfo.pGlobalHWStatusPage, sizeHWSP);
auto physHWSP = ggtt->map(engineInfo.ggttHWSP, sizeHWSP, this->getGTTBits(), this->getMemoryBankForGtt());
// Write our GHWSP
AubGTTData data = {0};
this->getGTTData(reinterpret_cast<void *>(physHWSP), data);
AUB::reserveAddressGGTT(tbxStream, engineInfo.ggttHWSP, sizeHWSP, physHWSP, data);
tbxStream.writeMMIO(AubMemDump::computeRegisterOffset(csTraits.mmioBase, 0x2080), engineInfo.ggttHWSP);
}
// Allocate the LRCA
const size_t sizeLRCA = csTraits.sizeLRCA;
const size_t alignLRCA = csTraits.alignLRCA;
auto pLRCABase = alignedMalloc(sizeLRCA, alignLRCA);
engineInfo.pLRCA = pLRCABase;
// Initialize the LRCA to a known state
csTraits.initialize(pLRCABase);
// Reserve the RCS ring buffer
engineInfo.sizeRingBuffer = 0x4 * 0x1000;
{
const size_t alignRCS = 0x1000;
engineInfo.pRingBuffer = alignedMalloc(engineInfo.sizeRingBuffer, alignRCS);
engineInfo.ggttRingBuffer = gttRemap.map(engineInfo.pRingBuffer, engineInfo.sizeRingBuffer);
auto physRCS = ggtt->map(engineInfo.ggttRingBuffer, engineInfo.sizeRingBuffer, this->getGTTBits(), this->getMemoryBankForGtt());
AubGTTData data = {0};
this->getGTTData(reinterpret_cast<void *>(physRCS), data);
AUB::reserveAddressGGTT(tbxStream, engineInfo.ggttRingBuffer, engineInfo.sizeRingBuffer, physRCS, data);
}
// Initialize the ring MMIO registers
{
uint32_t ringHead = 0x000;
uint32_t ringTail = 0x000;
auto ringBase = engineInfo.ggttRingBuffer;
auto ringCtrl = (uint32_t)((engineInfo.sizeRingBuffer - 0x1000) | 1);
csTraits.setRingHead(pLRCABase, ringHead);
csTraits.setRingTail(pLRCABase, ringTail);
csTraits.setRingBase(pLRCABase, ringBase);
csTraits.setRingCtrl(pLRCABase, ringCtrl);
}
// Write our LRCA
{
engineInfo.ggttLRCA = gttRemap.map(engineInfo.pLRCA, sizeLRCA);
auto lrcAddressPhys = ggtt->map(engineInfo.ggttLRCA, sizeLRCA, this->getGTTBits(), this->getMemoryBankForGtt());
AubGTTData data = {0};
this->getGTTData(reinterpret_cast<void *>(lrcAddressPhys), data);
AUB::reserveAddressGGTT(tbxStream, engineInfo.ggttLRCA, sizeLRCA, lrcAddressPhys, data);
AUB::addMemoryWrite(
tbxStream,
lrcAddressPhys,
pLRCABase,
sizeLRCA,
this->getAddressSpace(csTraits.aubHintLRCA),
csTraits.aubHintLRCA);
}
DEBUG_BREAK_IF(!engineInfo.pLRCA);
}
template <typename GfxFamily>

2
shared/source/memory_manager/CMakeLists.txt
View File

@ -6,8 +6,6 @@
set(NEO_CORE_MEMORY_MANAGER
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/address_mapper.cpp
${CMAKE_CURRENT_SOURCE_DIR}/address_mapper.h
${CMAKE_CURRENT_SOURCE_DIR}/allocations_list.h
${CMAKE_CURRENT_SOURCE_DIR}/allocations_list.cpp
${CMAKE_CURRENT_SOURCE_DIR}/allocation_type.h

67
shared/source/memory_manager/address_mapper.cpp
View File

@ -1,67 +0,0 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/memory_manager/address_mapper.h"
#include "shared/source/helpers/aligned_memory.h"
#include <inttypes.h>
#include <iostream>
namespace NEO {
AddressMapper::AddressMapper() : nextPage(1) {
}
AddressMapper::~AddressMapper() {
for (auto &m : mapping)
delete m;
}
uint32_t AddressMapper::map(void *vm, size_t size) {
void *aligned = alignDown(vm, MemoryConstants::pageSize);
size_t alignedSize = alignSizeWholePage(vm, size);
auto it = mapping.begin();
for (; it != mapping.end(); it++) {
if ((*it)->vm == aligned) {
if ((*it)->size == alignedSize) {
return (*it)->ggtt;
}
break;
}
}
if (it != mapping.end()) {
delete *it;
mapping.erase(it);
}
uint32_t numPages = static_cast<uint32_t>(alignedSize / MemoryConstants::pageSize);
auto tmp = nextPage.fetch_add(numPages);
MapInfo *m = new MapInfo;
m->vm = aligned;
m->size = alignedSize;
m->ggtt = static_cast<uint32_t>(tmp * MemoryConstants::pageSize);
mapping.push_back(m);
return m->ggtt;
}
void AddressMapper::unmap(void *vm) {
void *aligned = alignDown(vm, MemoryConstants::pageSize);
auto it = mapping.begin();
for (; it != mapping.end(); it++) {
if ((*it)->vm == aligned) {
break;
}
}
if (it != mapping.end()) {
delete *it;
mapping.erase(it);
}
}
} // namespace NEO

34
shared/source/memory_manager/address_mapper.h
View File

@ -1,34 +0,0 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include <atomic>
#include <cstddef>
#include <vector>
namespace NEO {
class AddressMapper {
public:
AddressMapper();
~AddressMapper();
// maps to continuous region
uint32_t map(void *vm, size_t size);
// unmaps
void unmap(void *vm);
protected:
struct MapInfo {
void *vm;
size_t size;
uint32_t ggtt;
};
std::vector<MapInfo *> mapping;
std::atomic<uint32_t> nextPage;
};
} // namespace NEO

3
shared/test/unit_test/memory_manager/CMakeLists.txt
View File

@ -1,12 +1,11 @@
#
# Copyright (C) 2020-2023 Intel Corporation
# Copyright (C) 2020-2025 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
target_sources(neo_shared_tests PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/address_mapper_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/alignment_selector_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/deferrable_allocation_deletion_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/deferred_deleter_tests.cpp

72
shared/test/unit_test/memory_manager/address_mapper_tests.cpp
View File

@ -1,72 +0,0 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/aligned_memory.h"
#include "shared/source/memory_manager/address_mapper.h"
#include "shared/test/common/test_macros/test.h"
#include "gtest/gtest.h"
#include <memory>
using namespace NEO;
class AddressMapperFixture {
public:
void setUp() {
mapper = new AddressMapper();
}
void tearDown() {
delete mapper;
}
AddressMapper *mapper;
};
using AddressMapperTests = Test<AddressMapperFixture>;
TEST_F(AddressMapperTests, GivenAlignedPointersWhenMappingThenPointersAreAligned) {
uint32_t m1 = mapper->map((void *)0x1000, MemoryConstants::pageSize);
EXPECT_EQ(0x1000u, m1);
uint32_t m2 = mapper->map((void *)0x3000, MemoryConstants::pageSize);
EXPECT_EQ(0x2000u, m2);
uint32_t m3 = mapper->map((void *)0x1000, MemoryConstants::pageSize);
EXPECT_EQ(0x1000u, m3);
}
TEST_F(AddressMapperTests, GivenUnalignedPointersWhenMappingThenPointersAreAligned) {
void *vm1 = (void *)(0x1100);
void *vm2 = (void *)(0x4100);
uint32_t m1 = mapper->map(vm1, MemoryConstants::pageSize);
EXPECT_EQ(0x1000u, m1);
uint32_t m2 = mapper->map(vm2, MemoryConstants::pageSize);
EXPECT_EQ(0x3000u, m2);
uint32_t m3 = mapper->map(vm1, MemoryConstants::pageSize);
EXPECT_EQ(0x1000u, m3);
}
TEST_F(AddressMapperTests, WhenResizingThenPointerIsAligned) {
uint32_t m1 = mapper->map((void *)0x1000, MemoryConstants::pageSize);
EXPECT_EQ(0x1000u, m1);
uint32_t m2 = mapper->map((void *)0x1000, 2 * MemoryConstants::pageSize);
EXPECT_EQ(0x2000u, m2);
}
TEST_F(AddressMapperTests, WhenUnmappingThenMappingWorksCorrectly) {
mapper->unmap((void *)0x1000);
uint32_t m1 = mapper->map((void *)0x2000, MemoryConstants::pageSize);
EXPECT_EQ(0x1000u, m1);
// no crash expected
mapper->unmap((void *)0x1000);
mapper->unmap((void *)0x2000);
uint32_t m2 = mapper->map((void *)0x2000, MemoryConstants::pageSize);
EXPECT_NE(m1, m2);
EXPECT_EQ(0x2000u, m2);
}