summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--src/common/address_space.h105
-rw-r--r--src/common/address_space.inc319
-rw-r--r--src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp8
3 files changed, 237 insertions, 195 deletions
diff --git a/src/common/address_space.h b/src/common/address_space.h
index 5b3832f07..bf649018c 100644
--- a/src/common/address_space.h
+++ b/src/common/address_space.h
@@ -23,9 +23,29 @@ template <typename VaType, VaType UnmappedVa, typename PaType, PaType UnmappedPa
bool PaContigSplit, size_t AddressSpaceBits, typename ExtraBlockInfo = EmptyStruct>
requires AddressSpaceValid<VaType, AddressSpaceBits>
class FlatAddressSpaceMap {
-private:
- std::function<void(VaType, VaType)>
- unmapCallback{}; //!< Callback called when the mappings in an region have changed
+public:
+ /// The maximum VA that this AS can technically reach
+ static constexpr VaType VaMaximum{(1ULL << (AddressSpaceBits - 1)) +
+ ((1ULL << (AddressSpaceBits - 1)) - 1)};
+
+ explicit FlatAddressSpaceMap(VaType va_limit,
+ std::function<void(VaType, VaType)> unmap_callback = {});
+
+ FlatAddressSpaceMap() = default;
+
+ void Map(VaType virt, PaType phys, VaType size, ExtraBlockInfo extra_info = {}) {
+ std::scoped_lock lock(block_mutex);
+ MapLocked(virt, phys, size, extra_info);
+ }
+
+ void Unmap(VaType virt, VaType size) {
+ std::scoped_lock lock(block_mutex);
+ UnmapLocked(virt, size);
+ }
+
+ VaType GetVALimit() const {
+ return va_limit;
+ }
protected:
/**
@@ -33,68 +53,55 @@ protected:
* another block with a different phys address is hit
*/
struct Block {
- VaType virt{UnmappedVa}; //!< VA of the block
- PaType phys{UnmappedPa}; //!< PA of the block, will increase 1-1 with VA until a new block
- //!< is encountered
- [[no_unique_address]] ExtraBlockInfo extraInfo;
+ /// VA of the block
+ VaType virt{UnmappedVa};
+ /// PA of the block, will increase 1-1 with VA until a new block is encountered
+ PaType phys{UnmappedPa};
+ [[no_unique_address]] ExtraBlockInfo extra_info;
Block() = default;
- Block(VaType virt_, PaType phys_, ExtraBlockInfo extraInfo_)
- : virt(virt_), phys(phys_), extraInfo(extraInfo_) {}
+ Block(VaType virt_, PaType phys_, ExtraBlockInfo extra_info_)
+ : virt(virt_), phys(phys_), extra_info(extra_info_) {}
- constexpr bool Valid() {
+ bool Valid() const {
return virt != UnmappedVa;
}
- constexpr bool Mapped() {
+ bool Mapped() const {
return phys != UnmappedPa;
}
- constexpr bool Unmapped() {
+ bool Unmapped() const {
return phys == UnmappedPa;
}
- bool operator<(const VaType& pVirt) const {
- return virt < pVirt;
+ bool operator<(const VaType& p_virt) const {
+ return virt < p_virt;
}
};
- std::mutex blockMutex;
- std::vector<Block> blocks{Block{}};
-
/**
* @brief Maps a PA range into the given AS region
- * @note blockMutex MUST be locked when calling this
+ * @note block_mutex MUST be locked when calling this
*/
- void MapLocked(VaType virt, PaType phys, VaType size, ExtraBlockInfo extraInfo);
+ void MapLocked(VaType virt, PaType phys, VaType size, ExtraBlockInfo extra_info);
/**
* @brief Unmaps the given range and merges it with other unmapped regions
- * @note blockMutex MUST be locked when calling this
+ * @note block_mutex MUST be locked when calling this
*/
void UnmapLocked(VaType virt, VaType size);
-public:
- static constexpr VaType VaMaximum{(1ULL << (AddressSpaceBits - 1)) +
- ((1ULL << (AddressSpaceBits - 1)) -
- 1)}; //!< The maximum VA that this AS can technically reach
-
- VaType vaLimit{VaMaximum}; //!< A soft limit on the maximum VA of the AS
-
- FlatAddressSpaceMap(VaType vaLimit, std::function<void(VaType, VaType)> unmapCallback = {});
-
- FlatAddressSpaceMap() = default;
+ std::mutex block_mutex;
+ std::vector<Block> blocks{Block{}};
- void Map(VaType virt, PaType phys, VaType size, ExtraBlockInfo extraInfo = {}) {
- std::scoped_lock lock(blockMutex);
- MapLocked(virt, phys, size, extraInfo);
- }
+ /// a soft limit on the maximum VA of the AS
+ VaType va_limit{VaMaximum};
- void Unmap(VaType virt, VaType size) {
- std::scoped_lock lock(blockMutex);
- UnmapLocked(virt, size);
- }
+private:
+ /// Callback called when the mappings in an region have changed
+ std::function<void(VaType, VaType)> unmap_callback{};
};
/**
@@ -108,14 +115,8 @@ class FlatAllocator
private:
using Base = FlatAddressSpaceMap<VaType, UnmappedVa, bool, false, false, AddressSpaceBits>;
- VaType currentLinearAllocEnd; //!< The end address for the initial linear allocation pass, once
- //!< this reaches the AS limit the slower allocation path will be
- //!< used
-
public:
- VaType vaStart; //!< The base VA of the allocator, no allocations will be below this
-
- FlatAllocator(VaType vaStart, VaType vaLimit = Base::VaMaximum);
+ explicit FlatAllocator(VaType va_start, VaType va_limit = Base::VaMaximum);
/**
* @brief Allocates a region in the AS of the given size and returns its address
@@ -131,5 +132,19 @@ public:
* @brief Frees an AS region so it can be used again
*/
void Free(VaType virt, VaType size);
+
+ VaType GetVAStart() const {
+ return va_start;
+ }
+
+private:
+ /// The base VA of the allocator, no allocations will be below this
+ VaType va_start;
+
+ /**
+ * The end address for the initial linear allocation pass
+ * Once this reaches the AS limit the slower allocation path will be used
+ */
+ VaType current_linear_alloc_end;
};
} // namespace Common
diff --git a/src/common/address_space.inc b/src/common/address_space.inc
index a063782b3..3661b298e 100644
--- a/src/common/address_space.inc
+++ b/src/common/address_space.inc
@@ -30,137 +30,151 @@
FlatAllocator<VaType, UnmappedVa, AddressSpaceBits>
namespace Common {
-MAP_MEMBER_CONST()::FlatAddressSpaceMap(VaType vaLimit_,
- std::function<void(VaType, VaType)> unmapCallback_)
- : unmapCallback(std::move(unmapCallback_)), vaLimit(vaLimit_) {
- if (vaLimit > VaMaximum)
+MAP_MEMBER_CONST()::FlatAddressSpaceMap(VaType va_limit_,
+ std::function<void(VaType, VaType)> unmap_callback_)
+ : va_limit{va_limit_}, unmap_callback{std::move(unmap_callback_)} {
+ if (va_limit > VaMaximum) {
UNREACHABLE_MSG("Invalid VA limit!");
+ }
}
-MAP_MEMBER(void)::MapLocked(VaType virt, PaType phys, VaType size, ExtraBlockInfo extraInfo) {
- VaType virtEnd{virt + size};
+MAP_MEMBER(void)::MapLocked(VaType virt, PaType phys, VaType size, ExtraBlockInfo extra_info) {
+ VaType virt_end{virt + size};
- if (virtEnd > vaLimit)
- UNREACHABLE_MSG("Trying to map a block past the VA limit: virtEnd: 0x{:X}, vaLimit: 0x{:X}",
- virtEnd, vaLimit);
+ if (virt_end > va_limit) {
+ UNREACHABLE_MSG(
+ "Trying to map a block past the VA limit: virt_end: 0x{:X}, va_limit: 0x{:X}", virt_end,
+ va_limit);
+ }
- auto blockEndSuccessor{std::lower_bound(blocks.begin(), blocks.end(), virtEnd)};
- if (blockEndSuccessor == blocks.begin())
- UNREACHABLE_MSG("Trying to map a block before the VA start: virtEnd: 0x{:X}", virtEnd);
+ auto block_end_successor{std::lower_bound(blocks.begin(), blocks.end(), virt_end)};
+ if (block_end_successor == blocks.begin()) {
+ UNREACHABLE_MSG("Trying to map a block before the VA start: virt_end: 0x{:X}", virt_end);
+ }
- auto blockEndPredecessor{std::prev(blockEndSuccessor)};
+ auto block_end_predecessor{std::prev(block_end_successor)};
- if (blockEndSuccessor != blocks.end()) {
+ if (block_end_successor != blocks.end()) {
// We have blocks in front of us, if one is directly in front then we don't have to add a
// tail
- if (blockEndSuccessor->virt != virtEnd) {
+ if (block_end_successor->virt != virt_end) {
PaType tailPhys{[&]() -> PaType {
if constexpr (!PaContigSplit) {
- return blockEndPredecessor
- ->phys; // Always propagate unmapped regions rather than calculating offset
+ // Always propagate unmapped regions rather than calculating offset
+ return block_end_predecessor->phys;
} else {
- if (blockEndPredecessor->Unmapped())
- return blockEndPredecessor->phys; // Always propagate unmapped regions
- // rather than calculating offset
- else
- return blockEndPredecessor->phys + virtEnd - blockEndPredecessor->virt;
+ if (block_end_predecessor->Unmapped()) {
+ // Always propagate unmapped regions rather than calculating offset
+ return block_end_predecessor->phys;
+ } else {
+ return block_end_predecessor->phys + virt_end - block_end_predecessor->virt;
+ }
}
}()};
- if (blockEndPredecessor->virt >= virt) {
+ if (block_end_predecessor->virt >= virt) {
// If this block's start would be overlapped by the map then reuse it as a tail
// block
- blockEndPredecessor->virt = virtEnd;
- blockEndPredecessor->phys = tailPhys;
- blockEndPredecessor->extraInfo = blockEndPredecessor->extraInfo;
+ block_end_predecessor->virt = virt_end;
+ block_end_predecessor->phys = tailPhys;
+ block_end_predecessor->extra_info = block_end_predecessor->extra_info;
// No longer predecessor anymore
- blockEndSuccessor = blockEndPredecessor--;
+ block_end_successor = block_end_predecessor--;
} else {
// Else insert a new one and we're done
- blocks.insert(blockEndSuccessor,
- {Block(virt, phys, extraInfo),
- Block(virtEnd, tailPhys, blockEndPredecessor->extraInfo)});
- if (unmapCallback)
- unmapCallback(virt, size);
+ blocks.insert(block_end_successor,
+ {Block(virt, phys, extra_info),
+ Block(virt_end, tailPhys, block_end_predecessor->extra_info)});
+ if (unmap_callback) {
+ unmap_callback(virt, size);
+ }
return;
}
}
} else {
- // blockEndPredecessor will always be unmapped as blocks has to be terminated by an unmapped
- // chunk
- if (blockEndPredecessor != blocks.begin() && blockEndPredecessor->virt >= virt) {
+ // block_end_predecessor will always be unmapped as blocks has to be terminated by an
+ // unmapped chunk
+ if (block_end_predecessor != blocks.begin() && block_end_predecessor->virt >= virt) {
// Move the unmapped block start backwards
- blockEndPredecessor->virt = virtEnd;
+ block_end_predecessor->virt = virt_end;
// No longer predecessor anymore
- blockEndSuccessor = blockEndPredecessor--;
+ block_end_successor = block_end_predecessor--;
} else {
// Else insert a new one and we're done
- blocks.insert(blockEndSuccessor,
- {Block(virt, phys, extraInfo), Block(virtEnd, UnmappedPa, {})});
- if (unmapCallback)
- unmapCallback(virt, size);
+ blocks.insert(block_end_successor,
+ {Block(virt, phys, extra_info), Block(virt_end, UnmappedPa, {})});
+ if (unmap_callback) {
+ unmap_callback(virt, size);
+ }
return;
}
}
- auto blockStartSuccessor{blockEndSuccessor};
+ auto block_start_successor{block_end_successor};
// Walk the block vector to find the start successor as this is more efficient than another
// binary search in most scenarios
- while (std::prev(blockStartSuccessor)->virt >= virt)
- blockStartSuccessor--;
+ while (std::prev(block_start_successor)->virt >= virt) {
+ block_start_successor--;
+ }
// Check that the start successor is either the end block or something in between
- if (blockStartSuccessor->virt > virtEnd) {
- UNREACHABLE_MSG("Unsorted block in AS map: virt: 0x{:X}", blockStartSuccessor->virt);
- } else if (blockStartSuccessor->virt == virtEnd) {
+ if (block_start_successor->virt > virt_end) {
+ UNREACHABLE_MSG("Unsorted block in AS map: virt: 0x{:X}", block_start_successor->virt);
+ } else if (block_start_successor->virt == virt_end) {
// We need to create a new block as there are none spare that we would overwrite
- blocks.insert(blockStartSuccessor, Block(virt, phys, extraInfo));
+ blocks.insert(block_start_successor, Block(virt, phys, extra_info));
} else {
// Erase overwritten blocks
- if (auto eraseStart{std::next(blockStartSuccessor)}; eraseStart != blockEndSuccessor)
- blocks.erase(eraseStart, blockEndSuccessor);
+ if (auto eraseStart{std::next(block_start_successor)}; eraseStart != block_end_successor) {
+ blocks.erase(eraseStart, block_end_successor);
+ }
// Reuse a block that would otherwise be overwritten as a start block
- blockStartSuccessor->virt = virt;
- blockStartSuccessor->phys = phys;
- blockStartSuccessor->extraInfo = extraInfo;
+ block_start_successor->virt = virt;
+ block_start_successor->phys = phys;
+ block_start_successor->extra_info = extra_info;
}
- if (unmapCallback)
- unmapCallback(virt, size);
+ if (unmap_callback) {
+ unmap_callback(virt, size);
+ }
}
MAP_MEMBER(void)::UnmapLocked(VaType virt, VaType size) {
- VaType virtEnd{virt + size};
+ VaType virt_end{virt + size};
- if (virtEnd > vaLimit)
- UNREACHABLE_MSG("Trying to map a block past the VA limit: virtEnd: 0x{:X}, vaLimit: 0x{:X}",
- virtEnd, vaLimit);
+ if (virt_end > va_limit) {
+ UNREACHABLE_MSG(
+ "Trying to map a block past the VA limit: virt_end: 0x{:X}, va_limit: 0x{:X}", virt_end,
+ va_limit);
+ }
- auto blockEndSuccessor{std::lower_bound(blocks.begin(), blocks.end(), virtEnd)};
- if (blockEndSuccessor == blocks.begin())
- UNREACHABLE_MSG("Trying to unmap a block before the VA start: virtEnd: 0x{:X}", virtEnd);
+ auto block_end_successor{std::lower_bound(blocks.begin(), blocks.end(), virt_end)};
+ if (block_end_successor == blocks.begin()) {
+ UNREACHABLE_MSG("Trying to unmap a block before the VA start: virt_end: 0x{:X}", virt_end);
+ }
- auto blockEndPredecessor{std::prev(blockEndSuccessor)};
+ auto block_end_predecessor{std::prev(block_end_successor)};
- auto walkBackToPredecessor{[&](auto iter) {
- while (iter->virt >= virt)
+ auto walk_back_to_predecessor{[&](auto iter) {
+ while (iter->virt >= virt) {
iter--;
+ }
return iter;
}};
- auto eraseBlocksWithEndUnmapped{[&](auto unmappedEnd) {
- auto blockStartPredecessor{walkBackToPredecessor(unmappedEnd)};
- auto blockStartSuccessor{std::next(blockStartPredecessor)};
+ auto erase_blocks_with_end_unmapped{[&](auto unmappedEnd) {
+ auto block_start_predecessor{walk_back_to_predecessor(unmappedEnd)};
+ auto block_start_successor{std::next(block_start_predecessor)};
auto eraseEnd{[&]() {
- if (blockStartPredecessor->Unmapped()) {
+ if (block_start_predecessor->Unmapped()) {
// If the start predecessor is unmapped then we can erase everything in our region
// and be done
return std::next(unmappedEnd);
@@ -174,158 +188,171 @@ MAP_MEMBER(void)::UnmapLocked(VaType virt, VaType size) {
// We can't have two unmapped regions after each other
if (eraseEnd != blocks.end() &&
- (eraseEnd == blockStartSuccessor ||
- (blockStartPredecessor->Unmapped() && eraseEnd->Unmapped())))
+ (eraseEnd == block_start_successor ||
+ (block_start_predecessor->Unmapped() && eraseEnd->Unmapped()))) {
UNREACHABLE_MSG("Multiple contiguous unmapped regions are unsupported!");
+ }
- blocks.erase(blockStartSuccessor, eraseEnd);
+ blocks.erase(block_start_successor, eraseEnd);
}};
// We can avoid any splitting logic if these are the case
- if (blockEndPredecessor->Unmapped()) {
- if (blockEndPredecessor->virt > virt)
- eraseBlocksWithEndUnmapped(blockEndPredecessor);
+ if (block_end_predecessor->Unmapped()) {
+ if (block_end_predecessor->virt > virt) {
+ erase_blocks_with_end_unmapped(block_end_predecessor);
+ }
- if (unmapCallback)
- unmapCallback(virt, size);
+ if (unmap_callback) {
+ unmap_callback(virt, size);
+ }
return; // The region is unmapped, bail out early
- } else if (blockEndSuccessor->virt == virtEnd && blockEndSuccessor->Unmapped()) {
- eraseBlocksWithEndUnmapped(blockEndSuccessor);
+ } else if (block_end_successor->virt == virt_end && block_end_successor->Unmapped()) {
+ erase_blocks_with_end_unmapped(block_end_successor);
- if (unmapCallback)
- unmapCallback(virt, size);
+ if (unmap_callback) {
+ unmap_callback(virt, size);
+ }
return; // The region is unmapped here and doesn't need splitting, bail out early
- } else if (blockEndSuccessor == blocks.end()) {
+ } else if (block_end_successor == blocks.end()) {
// This should never happen as the end should always follow an unmapped block
UNREACHABLE_MSG("Unexpected Memory Manager state!");
- } else if (blockEndSuccessor->virt != virtEnd) {
+ } else if (block_end_successor->virt != virt_end) {
// If one block is directly in front then we don't have to add a tail
// The previous block is mapped so we will need to add a tail with an offset
PaType tailPhys{[&]() {
- if constexpr (PaContigSplit)
- return blockEndPredecessor->phys + virtEnd - blockEndPredecessor->virt;
- else
- return blockEndPredecessor->phys;
+ if constexpr (PaContigSplit) {
+ return block_end_predecessor->phys + virt_end - block_end_predecessor->virt;
+ } else {
+ return block_end_predecessor->phys;
+ }
}()};
- if (blockEndPredecessor->virt >= virt) {
+ if (block_end_predecessor->virt >= virt) {
// If this block's start would be overlapped by the unmap then reuse it as a tail block
- blockEndPredecessor->virt = virtEnd;
- blockEndPredecessor->phys = tailPhys;
+ block_end_predecessor->virt = virt_end;
+ block_end_predecessor->phys = tailPhys;
// No longer predecessor anymore
- blockEndSuccessor = blockEndPredecessor--;
+ block_end_successor = block_end_predecessor--;
} else {
- blocks.insert(blockEndSuccessor,
+ blocks.insert(block_end_successor,
{Block(virt, UnmappedPa, {}),
- Block(virtEnd, tailPhys, blockEndPredecessor->extraInfo)});
- if (unmapCallback)
- unmapCallback(virt, size);
+ Block(virt_end, tailPhys, block_end_predecessor->extra_info)});
+ if (unmap_callback) {
+ unmap_callback(virt, size);
+ }
- return; // The previous block is mapped and ends before
+ // The previous block is mapped and ends before
+ return;
}
}
// Walk the block vector to find the start predecessor as this is more efficient than another
// binary search in most scenarios
- auto blockStartPredecessor{walkBackToPredecessor(blockEndSuccessor)};
- auto blockStartSuccessor{std::next(blockStartPredecessor)};
+ auto block_start_predecessor{walk_back_to_predecessor(block_end_successor)};
+ auto block_start_successor{std::next(block_start_predecessor)};
- if (blockStartSuccessor->virt > virtEnd) {
- UNREACHABLE_MSG("Unsorted block in AS map: virt: 0x{:X}", blockStartSuccessor->virt);
- } else if (blockStartSuccessor->virt == virtEnd) {
+ if (block_start_successor->virt > virt_end) {
+ UNREACHABLE_MSG("Unsorted block in AS map: virt: 0x{:X}", block_start_successor->virt);
+ } else if (block_start_successor->virt == virt_end) {
// There are no blocks between the start and the end that would let us skip inserting a new
// one for head
// The previous block is may be unmapped, if so we don't need to insert any unmaps after it
- if (blockStartPredecessor->Mapped())
- blocks.insert(blockStartSuccessor, Block(virt, UnmappedPa, {}));
- } else if (blockStartPredecessor->Unmapped()) {
+ if (block_start_predecessor->Mapped()) {
+ blocks.insert(block_start_successor, Block(virt, UnmappedPa, {}));
+ }
+ } else if (block_start_predecessor->Unmapped()) {
// If the previous block is unmapped
- blocks.erase(blockStartSuccessor, blockEndPredecessor);
+ blocks.erase(block_start_successor, block_end_predecessor);
} else {
// Erase overwritten blocks, skipping the first one as we have written the unmapped start
// block there
- if (auto eraseStart{std::next(blockStartSuccessor)}; eraseStart != blockEndSuccessor)
- blocks.erase(eraseStart, blockEndSuccessor);
+ if (auto eraseStart{std::next(block_start_successor)}; eraseStart != block_end_successor) {
+ blocks.erase(eraseStart, block_end_successor);
+ }
// Add in the unmapped block header
- blockStartSuccessor->virt = virt;
- blockStartSuccessor->phys = UnmappedPa;
+ block_start_successor->virt = virt;
+ block_start_successor->phys = UnmappedPa;
}
- if (unmapCallback)
- unmapCallback(virt, size);
+ if (unmap_callback)
+ unmap_callback(virt, size);
}
-ALLOC_MEMBER_CONST()::FlatAllocator(VaType vaStart_, VaType vaLimit_)
- : Base(vaLimit_), currentLinearAllocEnd(vaStart_), vaStart(vaStart_) {}
+ALLOC_MEMBER_CONST()::FlatAllocator(VaType va_start_, VaType va_limit_)
+ : Base{va_limit_}, va_start{va_start_}, current_linear_alloc_end{va_start_} {}
ALLOC_MEMBER(VaType)::Allocate(VaType size) {
- std::scoped_lock lock(this->blockMutex);
+ std::scoped_lock lock(this->block_mutex);
- VaType allocStart{UnmappedVa};
- VaType allocEnd{currentLinearAllocEnd + size};
+ VaType alloc_start{UnmappedVa};
+ VaType alloc_end{current_linear_alloc_end + size};
// Avoid searching backwards in the address space if possible
- if (allocEnd >= currentLinearAllocEnd && allocEnd <= this->vaLimit) {
- auto allocEndSuccessor{
- std::lower_bound(this->blocks.begin(), this->blocks.end(), allocEnd)};
- if (allocEndSuccessor == this->blocks.begin())
+ if (alloc_end >= current_linear_alloc_end && alloc_end <= this->va_limit) {
+ auto alloc_end_successor{
+ std::lower_bound(this->blocks.begin(), this->blocks.end(), alloc_end)};
+ if (alloc_end_successor == this->blocks.begin()) {
UNREACHABLE_MSG("First block in AS map is invalid!");
+ }
- auto allocEndPredecessor{std::prev(allocEndSuccessor)};
- if (allocEndPredecessor->virt <= currentLinearAllocEnd) {
- allocStart = currentLinearAllocEnd;
+ auto alloc_end_predecessor{std::prev(alloc_end_successor)};
+ if (alloc_end_predecessor->virt <= current_linear_alloc_end) {
+ alloc_start = current_linear_alloc_end;
} else {
// Skip over fixed any mappings in front of us
- while (allocEndSuccessor != this->blocks.end()) {
- if (allocEndSuccessor->virt - allocEndPredecessor->virt < size ||
- allocEndPredecessor->Mapped()) {
- allocStart = allocEndPredecessor->virt;
+ while (alloc_end_successor != this->blocks.end()) {
+ if (alloc_end_successor->virt - alloc_end_predecessor->virt < size ||
+ alloc_end_predecessor->Mapped()) {
+ alloc_start = alloc_end_predecessor->virt;
break;
}
- allocEndPredecessor = allocEndSuccessor++;
+ alloc_end_predecessor = alloc_end_successor++;
// Use the VA limit to calculate if we can fit in the final block since it has no
// successor
- if (allocEndSuccessor == this->blocks.end()) {
- allocEnd = allocEndPredecessor->virt + size;
+ if (alloc_end_successor == this->blocks.end()) {
+ alloc_end = alloc_end_predecessor->virt + size;
- if (allocEnd >= allocEndPredecessor->virt && allocEnd <= this->vaLimit)
- allocStart = allocEndPredecessor->virt;
+ if (alloc_end >= alloc_end_predecessor->virt && alloc_end <= this->va_limit) {
+ alloc_start = alloc_end_predecessor->virt;
+ }
}
}
}
}
- if (allocStart != UnmappedVa) {
- currentLinearAllocEnd = allocStart + size;
+ if (alloc_start != UnmappedVa) {
+ current_linear_alloc_end = alloc_start + size;
} else { // If linear allocation overflows the AS then find a gap
- if (this->blocks.size() <= 2)
+ if (this->blocks.size() <= 2) {
UNREACHABLE_MSG("Unexpected allocator state!");
+ }
- auto searchPredecessor{this->blocks.begin()};
- auto searchSuccessor{std::next(searchPredecessor)};
+ auto search_predecessor{this->blocks.begin()};
+ auto search_successor{std::next(search_predecessor)};
- while (searchSuccessor != this->blocks.end() &&
- (searchSuccessor->virt - searchPredecessor->virt < size ||
- searchPredecessor->Mapped())) {
- searchPredecessor = searchSuccessor++;
+ while (search_successor != this->blocks.end() &&
+ (search_successor->virt - search_predecessor->virt < size ||
+ search_predecessor->Mapped())) {
+ search_predecessor = search_successor++;
}
- if (searchSuccessor != this->blocks.end())
- allocStart = searchPredecessor->virt;
- else
+ if (search_successor != this->blocks.end()) {
+ alloc_start = search_predecessor->virt;
+ } else {
return {}; // AS is full
+ }
}
- this->MapLocked(allocStart, true, size, {});
- return allocStart;
+ this->MapLocked(alloc_start, true, size, {});
+ return alloc_start;
}
ALLOC_MEMBER(void)::AllocateFixed(VaType virt, VaType size) {
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
index b48f7fcaf..7a95f5305 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
@@ -472,16 +472,16 @@ void nvhost_as_gpu::GetVARegionsImpl(IoctlGetVaRegions& params) {
params.regions = std::array<VaRegion, 2>{
VaRegion{
- .offset = vm.small_page_allocator->vaStart << VM::PAGE_SIZE_BITS,
+ .offset = vm.small_page_allocator->GetVAStart() << VM::PAGE_SIZE_BITS,
.page_size = VM::YUZU_PAGESIZE,
._pad0_{},
- .pages = vm.small_page_allocator->vaLimit - vm.small_page_allocator->vaStart,
+ .pages = vm.small_page_allocator->GetVALimit() - vm.small_page_allocator->GetVAStart(),
},
VaRegion{
- .offset = vm.big_page_allocator->vaStart << vm.big_page_size_bits,
+ .offset = vm.big_page_allocator->GetVAStart() << vm.big_page_size_bits,
.page_size = vm.big_page_size,
._pad0_{},
- .pages = vm.big_page_allocator->vaLimit - vm.big_page_allocator->vaStart,
+ .pages = vm.big_page_allocator->GetVALimit() - vm.big_page_allocator->GetVAStart(),
},
};
}