etc/pineapple-src
2
1
Fork 1
Code Issues Pull requests Projects Releases Packages Wiki Activity

early-access version 2810

Browse source
This commit is contained in:
pineappleEA 2022-07-01 03:13:52 +02:00
parent eb6a9c8efb
commit 8e068dd8b7
43 changed files with 343 additions and 346 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
README.md
View file

@ -1,7 +1,7 @@
yuzu emulator early access yuzu emulator early access
============= =============
This is the source code for early-access 2808. This is the source code for early-access 2810.
## Legal Notice ## Legal Notice

5
src/common/address_space.cpp
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors // Copyright © 2021 Skyline Team and Contributors (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // Licensed under GPLv3 or any later version
// Refer to the license.txt file included.
#include "common/address_space.inc" #include "common/address_space.inc"

110
src/common/address_space.h
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors // Copyright © 2021 Skyline Team and Contributors (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // Licensed under GPLv3 or any later version
// Refer to the license.txt file included.
#pragma once #pragma once
@ -23,29 +24,9 @@ template <typename VaType, VaType UnmappedVa, typename PaType, PaType UnmappedPa
bool PaContigSplit, size_t AddressSpaceBits, typename ExtraBlockInfo = EmptyStruct> bool PaContigSplit, size_t AddressSpaceBits, typename ExtraBlockInfo = EmptyStruct>
requires AddressSpaceValid<VaType, AddressSpaceBits> requires AddressSpaceValid<VaType, AddressSpaceBits>
class FlatAddressSpaceMap { class FlatAddressSpaceMap {
public: private:
/// The maximum VA that this AS can technically reach std::function<void(VaType, VaType)>
static constexpr VaType VaMaximum{(1ULL << (AddressSpaceBits - 1)) + unmapCallback{}; //!< Callback called when the mappings in an region have changed
((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: protected:
/** /**
@ -53,55 +34,68 @@ protected:
* another block with a different phys address is hit * another block with a different phys address is hit
*/ */
struct Block { struct Block {
/// VA of the block VaType virt{UnmappedVa}; //!< VA of the block
VaType virt{UnmappedVa}; PaType phys{UnmappedPa}; //!< PA of the block, will increase 1-1 with VA until a new block
/// PA of the block, will increase 1-1 with VA until a new block is encountered //!< is encountered
PaType phys{UnmappedPa}; [[no_unique_address]] ExtraBlockInfo extraInfo;
[[no_unique_address]] ExtraBlockInfo extra_info;
Block() = default; Block() = default;
Block(VaType virt_, PaType phys_, ExtraBlockInfo extra_info_) Block(VaType virt_, PaType phys_, ExtraBlockInfo extraInfo_)
: virt(virt_), phys(phys_), extra_info(extra_info_) {} : virt(virt_), phys(phys_), extraInfo(extraInfo_) {}
bool Valid() const { constexpr bool Valid() {
return virt != UnmappedVa; return virt != UnmappedVa;
} }
bool Mapped() const { constexpr bool Mapped() {
return phys != UnmappedPa; return phys != UnmappedPa;
} }
bool Unmapped() const { constexpr bool Unmapped() {
return phys == UnmappedPa; return phys == UnmappedPa;
} }
bool operator<(const VaType& p_virt) const { bool operator<(const VaType& pVirt) const {
return virt < p_virt; return virt < pVirt;
} }
}; };
std::mutex blockMutex;
std::vector<Block> blocks{Block{}};
/** /**
* @brief Maps a PA range into the given AS region * @brief Maps a PA range into the given AS region
* @note block_mutex MUST be locked when calling this * @note blockMutex MUST be locked when calling this
*/ */
void MapLocked(VaType virt, PaType phys, VaType size, ExtraBlockInfo extra_info); void MapLocked(VaType virt, PaType phys, VaType size, ExtraBlockInfo extraInfo);
/** /**
* @brief Unmaps the given range and merges it with other unmapped regions * @brief Unmaps the given range and merges it with other unmapped regions
* @note block_mutex MUST be locked when calling this * @note blockMutex MUST be locked when calling this
*/ */
void UnmapLocked(VaType virt, VaType size); void UnmapLocked(VaType virt, VaType size);
std::mutex block_mutex; public:
std::vector<Block> blocks{Block{}}; static constexpr VaType VaMaximum{(1ULL << (AddressSpaceBits - 1)) +
((1ULL << (AddressSpaceBits - 1)) -
1)}; //!< The maximum VA that this AS can technically reach
/// a soft limit on the maximum VA of the AS VaType vaLimit{VaMaximum}; //!< A soft limit on the maximum VA of the AS
VaType va_limit{VaMaximum};
private: FlatAddressSpaceMap(VaType vaLimit, std::function<void(VaType, VaType)> unmapCallback = {});
/// Callback called when the mappings in an region have changed
std::function<void(VaType, VaType)> unmap_callback{}; FlatAddressSpaceMap() = default;
void Map(VaType virt, PaType phys, VaType size, ExtraBlockInfo extraInfo = {}) {
std::scoped_lock lock(blockMutex);
MapLocked(virt, phys, size, extraInfo);
}
void Unmap(VaType virt, VaType size) {
std::scoped_lock lock(blockMutex);
UnmapLocked(virt, size);
}
}; };
/** /**
@ -115,8 +109,14 @@ class FlatAllocator
private: private:
using Base = FlatAddressSpaceMap<VaType, UnmappedVa, bool, false, false, AddressSpaceBits>; 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: public:
explicit FlatAllocator(VaType virt_start, VaType va_limit = Base::VaMaximum); VaType vaStart; //!< The base VA of the allocator, no allocations will be below this
FlatAllocator(VaType vaStart, VaType vaLimit = Base::VaMaximum);
/** /**
* @brief Allocates a region in the AS of the given size and returns its address * @brief Allocates a region in the AS of the given size and returns its address
@ -132,19 +132,5 @@ public:
* @brief Frees an AS region so it can be used again * @brief Frees an AS region so it can be used again
*/ */
void Free(VaType virt, VaType size); void Free(VaType virt, VaType size);
VaType GetVAStart() const {
return virt_start;
}
private:
/// The base VA of the allocator, no allocations will be below this
VaType virt_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 } // namespace Common

327
src/common/address_space.inc
View file

@ -1,5 +1,5 @@
// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors // SPDX-License-Identifier: GPLv3 or later
// SPDX-License-Identifier: GPL-3.0-or-later // Copyright © 2021 Skyline Team and Contributors (https://github.com/skyline-emu/)
#include "common/address_space.h" #include "common/address_space.h"
#include "common/assert.h" #include "common/assert.h"
@ -30,151 +30,137 @@
FlatAllocator<VaType, UnmappedVa, AddressSpaceBits> FlatAllocator<VaType, UnmappedVa, AddressSpaceBits>
namespace Common { namespace Common {
MAP_MEMBER_CONST()::FlatAddressSpaceMap(VaType va_limit_, MAP_MEMBER_CONST()::FlatAddressSpaceMap(VaType vaLimit_,
std::function<void(VaType, VaType)> unmap_callback_) std::function<void(VaType, VaType)> unmapCallback_)
: va_limit{va_limit_}, unmap_callback{std::move(unmap_callback_)} { : unmapCallback(std::move(unmapCallback_)), vaLimit(vaLimit_) {
if (va_limit > VaMaximum) { if (vaLimit > VaMaximum)
UNREACHABLE_MSG("Invalid VA limit!"); UNREACHABLE_MSG("Invalid VA limit!");
} }
}
MAP_MEMBER(void)::MapLocked(VaType virt, PaType phys, VaType size, ExtraBlockInfo extra_info) { MAP_MEMBER(void)::MapLocked(VaType virt, PaType phys, VaType size, ExtraBlockInfo extraInfo) {
VaType virt_end{virt + size}; VaType virtEnd{virt + size};
if (virt_end > va_limit) { if (virtEnd > vaLimit)
UNREACHABLE_MSG( UNREACHABLE_MSG("Trying to map a block past the VA limit: virtEnd: 0x{:X}, vaLimit: 0x{:X}",
"Trying to map a block past the VA limit: virt_end: 0x{:X}, va_limit: 0x{:X}", virt_end, virtEnd, vaLimit);
va_limit);
}
auto block_end_successor{std::lower_bound(blocks.begin(), blocks.end(), virt_end)}; auto blockEndSuccessor{std::lower_bound(blocks.begin(), blocks.end(), virtEnd)};
if (block_end_successor == blocks.begin()) { if (blockEndSuccessor == blocks.begin())
UNREACHABLE_MSG("Trying to map a block before the VA start: virt_end: 0x{:X}", virt_end); UNREACHABLE_MSG("Trying to map a block before the VA start: virtEnd: 0x{:X}", virtEnd);
}
auto block_end_predecessor{std::prev(block_end_successor)}; auto blockEndPredecessor{std::prev(blockEndSuccessor)};
if (block_end_successor != blocks.end()) { if (blockEndSuccessor != blocks.end()) {
// We have blocks in front of us, if one is directly in front then we don't have to add a // We have blocks in front of us, if one is directly in front then we don't have to add a
// tail // tail
if (block_end_successor->virt != virt_end) { if (blockEndSuccessor->virt != virtEnd) {
PaType tailPhys{[&]() -> PaType { PaType tailPhys{[&]() -> PaType {
if constexpr (!PaContigSplit) { if constexpr (!PaContigSplit) {
// Always propagate unmapped regions rather than calculating offset return blockEndPredecessor
return block_end_predecessor->phys; ->phys; // Always propagate unmapped regions rather than calculating offset
} else { } else {
if (block_end_predecessor->Unmapped()) { if (blockEndPredecessor->Unmapped())
// Always propagate unmapped regions rather than calculating offset return blockEndPredecessor->phys; // Always propagate unmapped regions
return block_end_predecessor->phys; // rather than calculating offset
} else { else
return block_end_predecessor->phys + virt_end - block_end_predecessor->virt; return blockEndPredecessor->phys + virtEnd - blockEndPredecessor->virt;
}
} }
}()}; }()};
if (block_end_predecessor->virt >= virt) { if (blockEndPredecessor->virt >= virt) {
// If this block's start would be overlapped by the map then reuse it as a tail // If this block's start would be overlapped by the map then reuse it as a tail
// block // block
block_end_predecessor->virt = virt_end; blockEndPredecessor->virt = virtEnd;
block_end_predecessor->phys = tailPhys; blockEndPredecessor->phys = tailPhys;
block_end_predecessor->extra_info = block_end_predecessor->extra_info; blockEndPredecessor->extraInfo = blockEndPredecessor->extraInfo;
// No longer predecessor anymore // No longer predecessor anymore
block_end_successor = block_end_predecessor--; blockEndSuccessor = blockEndPredecessor--;
} else { } else {
// Else insert a new one and we're done // Else insert a new one and we're done
blocks.insert(block_end_successor, blocks.insert(blockEndSuccessor,
{Block(virt, phys, extra_info), {Block(virt, phys, extraInfo),
Block(virt_end, tailPhys, block_end_predecessor->extra_info)}); Block(virtEnd, tailPhys, blockEndPredecessor->extraInfo)});
if (unmap_callback) { if (unmapCallback)
unmap_callback(virt, size); unmapCallback(virt, size);
}
return; return;
} }
} }
} else { } else {
// block_end_predecessor will always be unmapped as blocks has to be terminated by an // blockEndPredecessor will always be unmapped as blocks has to be terminated by an unmapped
// unmapped chunk // chunk
if (block_end_predecessor != blocks.begin() && block_end_predecessor->virt >= virt) { if (blockEndPredecessor != blocks.begin() && blockEndPredecessor->virt >= virt) {
// Move the unmapped block start backwards // Move the unmapped block start backwards
block_end_predecessor->virt = virt_end; blockEndPredecessor->virt = virtEnd;
// No longer predecessor anymore // No longer predecessor anymore
block_end_successor = block_end_predecessor--; blockEndSuccessor = blockEndPredecessor--;
} else { } else {
// Else insert a new one and we're done // Else insert a new one and we're done
blocks.insert(block_end_successor, blocks.insert(blockEndSuccessor,
{Block(virt, phys, extra_info), Block(virt_end, UnmappedPa, {})}); {Block(virt, phys, extraInfo), Block(virtEnd, UnmappedPa, {})});
if (unmap_callback) { if (unmapCallback)
unmap_callback(virt, size); unmapCallback(virt, size);
}
return; return;
} }
} }
auto block_start_successor{block_end_successor}; auto blockStartSuccessor{blockEndSuccessor};
// Walk the block vector to find the start successor as this is more efficient than another // Walk the block vector to find the start successor as this is more efficient than another
// binary search in most scenarios // binary search in most scenarios
while (std::prev(block_start_successor)->virt >= virt) { while (std::prev(blockStartSuccessor)->virt >= virt)
block_start_successor--; blockStartSuccessor--;
}
// Check that the start successor is either the end block or something in between // Check that the start successor is either the end block or something in between
if (block_start_successor->virt > virt_end) { if (blockStartSuccessor->virt > virtEnd) {
UNREACHABLE_MSG("Unsorted block in AS map: virt: 0x{:X}", block_start_successor->virt); UNREACHABLE_MSG("Unsorted block in AS map: virt: 0x{:X}", blockStartSuccessor->virt);
} else if (block_start_successor->virt == virt_end) { } else if (blockStartSuccessor->virt == virtEnd) {
// We need to create a new block as there are none spare that we would overwrite // We need to create a new block as there are none spare that we would overwrite
blocks.insert(block_start_successor, Block(virt, phys, extra_info)); blocks.insert(blockStartSuccessor, Block(virt, phys, extraInfo));
} else { } else {
// Erase overwritten blocks // Erase overwritten blocks
if (auto eraseStart{std::next(block_start_successor)}; eraseStart != block_end_successor) { if (auto eraseStart{std::next(blockStartSuccessor)}; eraseStart != blockEndSuccessor)
blocks.erase(eraseStart, block_end_successor); blocks.erase(eraseStart, blockEndSuccessor);
}
// Reuse a block that would otherwise be overwritten as a start block // Reuse a block that would otherwise be overwritten as a start block
block_start_successor->virt = virt; blockStartSuccessor->virt = virt;
block_start_successor->phys = phys; blockStartSuccessor->phys = phys;
block_start_successor->extra_info = extra_info; blockStartSuccessor->extraInfo = extraInfo;
} }
if (unmap_callback) { if (unmapCallback)
unmap_callback(virt, size); unmapCallback(virt, size);
}
} }
MAP_MEMBER(void)::UnmapLocked(VaType virt, VaType size) { MAP_MEMBER(void)::UnmapLocked(VaType virt, VaType size) {
VaType virt_end{virt + size}; VaType virtEnd{virt + size};
if (virt_end > va_limit) { if (virtEnd > vaLimit)
UNREACHABLE_MSG( UNREACHABLE_MSG("Trying to map a block past the VA limit: virtEnd: 0x{:X}, vaLimit: 0x{:X}",
"Trying to map a block past the VA limit: virt_end: 0x{:X}, va_limit: 0x{:X}", virt_end, virtEnd, vaLimit);
va_limit);
}
auto block_end_successor{std::lower_bound(blocks.begin(), blocks.end(), virt_end)}; auto blockEndSuccessor{std::lower_bound(blocks.begin(), blocks.end(), virtEnd)};
if (block_end_successor == blocks.begin()) { if (blockEndSuccessor == blocks.begin())
UNREACHABLE_MSG("Trying to unmap a block before the VA start: virt_end: 0x{:X}", virt_end); UNREACHABLE_MSG("Trying to unmap a block before the VA start: virtEnd: 0x{:X}", virtEnd);
}
auto block_end_predecessor{std::prev(block_end_successor)}; auto blockEndPredecessor{std::prev(blockEndSuccessor)};
auto walk_back_to_predecessor{[&](auto iter) { auto walkBackToPredecessor{[&](auto iter) {
while (iter->virt >= virt) { while (iter->virt >= virt)
iter--; iter--;
}
return iter; return iter;
}}; }};
auto erase_blocks_with_end_unmapped{[&](auto unmappedEnd) { auto eraseBlocksWithEndUnmapped{[&](auto unmappedEnd) {
auto block_start_predecessor{walk_back_to_predecessor(unmappedEnd)}; auto blockStartPredecessor{walkBackToPredecessor(unmappedEnd)};
auto block_start_successor{std::next(block_start_predecessor)}; auto blockStartSuccessor{std::next(blockStartPredecessor)};
auto eraseEnd{[&]() { auto eraseEnd{[&]() {
if (block_start_predecessor->Unmapped()) { if (blockStartPredecessor->Unmapped()) {
// If the start predecessor is unmapped then we can erase everything in our region // If the start predecessor is unmapped then we can erase everything in our region
// and be done // and be done
return std::next(unmappedEnd); return std::next(unmappedEnd);
@ -188,171 +174,158 @@ MAP_MEMBER(void)::UnmapLocked(VaType virt, VaType size) {
// We can't have two unmapped regions after each other // We can't have two unmapped regions after each other
if (eraseEnd != blocks.end() && if (eraseEnd != blocks.end() &&
(eraseEnd == block_start_successor || (eraseEnd == blockStartSuccessor ||
(block_start_predecessor->Unmapped() && eraseEnd->Unmapped()))) { (blockStartPredecessor->Unmapped() && eraseEnd->Unmapped())))
UNREACHABLE_MSG("Multiple contiguous unmapped regions are unsupported!"); UNREACHABLE_MSG("Multiple contiguous unmapped regions are unsupported!");
}
blocks.erase(block_start_successor, eraseEnd); blocks.erase(blockStartSuccessor, eraseEnd);
}}; }};
// We can avoid any splitting logic if these are the case // We can avoid any splitting logic if these are the case
if (block_end_predecessor->Unmapped()) { if (blockEndPredecessor->Unmapped()) {
if (block_end_predecessor->virt > virt) { if (blockEndPredecessor->virt > virt)
erase_blocks_with_end_unmapped(block_end_predecessor); eraseBlocksWithEndUnmapped(blockEndPredecessor);
}
if (unmap_callback) { if (unmapCallback)
unmap_callback(virt, size); unmapCallback(virt, size);
}
return; // The region is unmapped, bail out early return; // The region is unmapped, bail out early
} else if (block_end_successor->virt == virt_end && block_end_successor->Unmapped()) { } else if (blockEndSuccessor->virt == virtEnd && blockEndSuccessor->Unmapped()) {
erase_blocks_with_end_unmapped(block_end_successor); eraseBlocksWithEndUnmapped(blockEndSuccessor);
if (unmap_callback) { if (unmapCallback)
unmap_callback(virt, size); unmapCallback(virt, size);
}
return; // The region is unmapped here and doesn't need splitting, bail out early return; // The region is unmapped here and doesn't need splitting, bail out early
} else if (block_end_successor == blocks.end()) { } else if (blockEndSuccessor == blocks.end()) {
// This should never happen as the end should always follow an unmapped block // This should never happen as the end should always follow an unmapped block
UNREACHABLE_MSG("Unexpected Memory Manager state!"); UNREACHABLE_MSG("Unexpected Memory Manager state!");
} else if (block_end_successor->virt != virt_end) { } else if (blockEndSuccessor->virt != virtEnd) {
// If one block is directly in front then we don't have to add a tail // 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 // The previous block is mapped so we will need to add a tail with an offset
PaType tailPhys{[&]() { PaType tailPhys{[&]() {
if constexpr (PaContigSplit) { if constexpr (PaContigSplit)
return block_end_predecessor->phys + virt_end - block_end_predecessor->virt; return blockEndPredecessor->phys + virtEnd - blockEndPredecessor->virt;
} else { else
return block_end_predecessor->phys; return blockEndPredecessor->phys;
}
}()}; }()};
if (block_end_predecessor->virt >= virt) { if (blockEndPredecessor->virt >= virt) {
// If this block's start would be overlapped by the unmap then reuse it as a tail block // If this block's start would be overlapped by the unmap then reuse it as a tail block
block_end_predecessor->virt = virt_end; blockEndPredecessor->virt = virtEnd;
block_end_predecessor->phys = tailPhys; blockEndPredecessor->phys = tailPhys;
// No longer predecessor anymore // No longer predecessor anymore
block_end_successor = block_end_predecessor--; blockEndSuccessor = blockEndPredecessor--;
} else { } else {
blocks.insert(block_end_successor, blocks.insert(blockEndSuccessor,
{Block(virt, UnmappedPa, {}), {Block(virt, UnmappedPa, {}),
Block(virt_end, tailPhys, block_end_predecessor->extra_info)}); Block(virtEnd, tailPhys, blockEndPredecessor->extraInfo)});
if (unmap_callback) { if (unmapCallback)
unmap_callback(virt, size); unmapCallback(virt, size);
}
// The previous block is mapped and ends before return; // 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 // Walk the block vector to find the start predecessor as this is more efficient than another
// binary search in most scenarios // binary search in most scenarios
auto block_start_predecessor{walk_back_to_predecessor(block_end_successor)}; auto blockStartPredecessor{walkBackToPredecessor(blockEndSuccessor)};
auto block_start_successor{std::next(block_start_predecessor)}; auto blockStartSuccessor{std::next(blockStartPredecessor)};
if (block_start_successor->virt > virt_end) { if (blockStartSuccessor->virt > virtEnd) {
UNREACHABLE_MSG("Unsorted block in AS map: virt: 0x{:X}", block_start_successor->virt); UNREACHABLE_MSG("Unsorted block in AS map: virt: 0x{:X}", blockStartSuccessor->virt);
} else if (block_start_successor->virt == virt_end) { } else if (blockStartSuccessor->virt == virtEnd) {
// There are no blocks between the start and the end that would let us skip inserting a new // There are no blocks between the start and the end that would let us skip inserting a new
// one for head // one for head
// The previous block is may be unmapped, if so we don't need to insert any unmaps after it // The previous block is may be unmapped, if so we don't need to insert any unmaps after it
if (block_start_predecessor->Mapped()) { if (blockStartPredecessor->Mapped())
blocks.insert(block_start_successor, Block(virt, UnmappedPa, {})); blocks.insert(blockStartSuccessor, Block(virt, UnmappedPa, {}));
} } else if (blockStartPredecessor->Unmapped()) {
} else if (block_start_predecessor->Unmapped()) {
// If the previous block is unmapped // If the previous block is unmapped
blocks.erase(block_start_successor, block_end_predecessor); blocks.erase(blockStartSuccessor, blockEndPredecessor);
} else { } else {
// Erase overwritten blocks, skipping the first one as we have written the unmapped start // Erase overwritten blocks, skipping the first one as we have written the unmapped start
// block there // block there
if (auto eraseStart{std::next(block_start_successor)}; eraseStart != block_end_successor) { if (auto eraseStart{std::next(blockStartSuccessor)}; eraseStart != blockEndSuccessor)
blocks.erase(eraseStart, block_end_successor); blocks.erase(eraseStart, blockEndSuccessor);
}
// Add in the unmapped block header // Add in the unmapped block header
block_start_successor->virt = virt; blockStartSuccessor->virt = virt;
block_start_successor->phys = UnmappedPa; blockStartSuccessor->phys = UnmappedPa;
} }
if (unmap_callback) if (unmapCallback)
unmap_callback(virt, size); unmapCallback(virt, size);
} }
ALLOC_MEMBER_CONST()::FlatAllocator(VaType virt_start_, VaType va_limit_) ALLOC_MEMBER_CONST()::FlatAllocator(VaType vaStart_, VaType vaLimit_)
: Base{va_limit_}, virt_start{virt_start_}, current_linear_alloc_end{virt_start_} {} : Base(vaLimit_), currentLinearAllocEnd(vaStart_), vaStart(vaStart_) {}
ALLOC_MEMBER(VaType)::Allocate(VaType size) { ALLOC_MEMBER(VaType)::Allocate(VaType size) {
std::scoped_lock lock(this->block_mutex); std::scoped_lock lock(this->blockMutex);
VaType alloc_start{UnmappedVa}; VaType allocStart{UnmappedVa};
VaType alloc_end{current_linear_alloc_end + size}; VaType allocEnd{currentLinearAllocEnd + size};
// Avoid searching backwards in the address space if possible // Avoid searching backwards in the address space if possible
if (alloc_end >= current_linear_alloc_end && alloc_end <= this->va_limit) { if (allocEnd >= currentLinearAllocEnd && allocEnd <= this->vaLimit) {
auto alloc_end_successor{ auto allocEndSuccessor{
std::lower_bound(this->blocks.begin(), this->blocks.end(), alloc_end)}; std::lower_bound(this->blocks.begin(), this->blocks.end(), allocEnd)};
if (alloc_end_successor == this->blocks.begin()) { if (allocEndSuccessor == this->blocks.begin())
UNREACHABLE_MSG("First block in AS map is invalid!"); UNREACHABLE_MSG("First block in AS map is invalid!");
}
auto alloc_end_predecessor{std::prev(alloc_end_successor)}; auto allocEndPredecessor{std::prev(allocEndSuccessor)};
if (alloc_end_predecessor->virt <= current_linear_alloc_end) { if (allocEndPredecessor->virt <= currentLinearAllocEnd) {
alloc_start = current_linear_alloc_end; allocStart = currentLinearAllocEnd;
} else { } else {
// Skip over fixed any mappings in front of us // Skip over fixed any mappings in front of us
while (alloc_end_successor != this->blocks.end()) { while (allocEndSuccessor != this->blocks.end()) {
if (alloc_end_successor->virt - alloc_end_predecessor->virt < size || if (allocEndSuccessor->virt - allocEndPredecessor->virt < size ||
alloc_end_predecessor->Mapped()) { allocEndPredecessor->Mapped()) {
alloc_start = alloc_end_predecessor->virt; allocStart = allocEndPredecessor->virt;
break; break;
} }
alloc_end_predecessor = alloc_end_successor++; allocEndPredecessor = allocEndSuccessor++;
// Use the VA limit to calculate if we can fit in the final block since it has no // Use the VA limit to calculate if we can fit in the final block since it has no
// successor // successor
if (alloc_end_successor == this->blocks.end()) { if (allocEndSuccessor == this->blocks.end()) {
alloc_end = alloc_end_predecessor->virt + size; allocEnd = allocEndPredecessor->virt + size;
if (alloc_end >= alloc_end_predecessor->virt && alloc_end <= this->va_limit) { if (allocEnd >= allocEndPredecessor->virt && allocEnd <= this->vaLimit)
alloc_start = alloc_end_predecessor->virt; allocStart = allocEndPredecessor->virt;
}
} }
} }
} }
} }
if (alloc_start != UnmappedVa) { if (allocStart != UnmappedVa) {
current_linear_alloc_end = alloc_start + size; currentLinearAllocEnd = allocStart + size;
} else { // If linear allocation overflows the AS then find a gap } 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!"); UNREACHABLE_MSG("Unexpected allocator state!");
auto searchPredecessor{this->blocks.begin()};
auto searchSuccessor{std::next(searchPredecessor)};
while (searchSuccessor != this->blocks.end() &&
(searchSuccessor->virt - searchPredecessor->virt < size ||
searchPredecessor->Mapped())) {
searchPredecessor = searchSuccessor++;
} }
auto search_predecessor{this->blocks.begin()}; if (searchSuccessor != this->blocks.end())
auto search_successor{std::next(search_predecessor)}; allocStart = searchPredecessor->virt;
else
while (search_successor != this->blocks.end() &&
(search_successor->virt - search_predecessor->virt < size ||
search_predecessor->Mapped())) {
search_predecessor = search_successor++;
}
if (search_successor != this->blocks.end()) {
alloc_start = search_predecessor->virt;
} else {
return {}; // AS is full return {}; // AS is full
} }
}
this->MapLocked(alloc_start, true, size, {}); this->MapLocked(allocStart, true, size, {});
return alloc_start; return allocStart;
} }
ALLOC_MEMBER(void)::AllocateFixed(VaType virt, VaType size) { ALLOC_MEMBER(void)::AllocateFixed(VaType virt, VaType size) {

5
src/common/multi_level_page_table.h
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later // Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#pragma once #pragma once

5
src/common/multi_level_page_table.inc
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later // Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#ifdef _WIN32 #ifdef _WIN32
#include <windows.h> #include <windows.h>

2
src/core/cpu_manager.cpp
View file

@ -194,9 +194,11 @@ void CpuManager::PreemptSingleCore(bool from_running_enviroment) {
{ {
auto& scheduler = system.Kernel().Scheduler(current_core); auto& scheduler = system.Kernel().Scheduler(current_core);
scheduler.Reload(scheduler.GetSchedulerCurrentThread()); scheduler.Reload(scheduler.GetSchedulerCurrentThread());
if (!scheduler.IsIdle()) {
idle_count = 0; idle_count = 0;
} }
} }
}
void CpuManager::ShutdownThread() { void CpuManager::ShutdownThread() {
auto& kernel = system.Kernel(); auto& kernel = system.Kernel();

5
src/core/hle/kernel/k_scheduler.h
View file

@ -55,6 +55,11 @@ public:
return idle_thread; return idle_thread;
} }
/// Returns true if the scheduler is idle
[[nodiscard]] bool IsIdle() const {
return GetSchedulerCurrentThread() == idle_thread;
}
/// Gets the timestamp for the last context switch in ticks. /// Gets the timestamp for the last context switch in ticks.
[[nodiscard]] u64 GetLastContextSwitchTicks() const; [[nodiscard]] u64 GetLastContextSwitchTicks() const;

7
src/core/hle/service/nvdrv/core/container.cpp
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: 2022 yuzu Emulator Project // SPDX-FileCopyrightText: 2022 yuzu emulator team and Skyline Team and Contributors
// SPDX-FileCopyrightText: 2022 Skyline Team and Contributors // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#include "core/hle/service/nvdrv/core/container.h" #include "core/hle/service/nvdrv/core/container.h"
#include "core/hle/service/nvdrv/core/nvmap.h" #include "core/hle/service/nvdrv/core/nvmap.h"

7
src/core/hle/service/nvdrv/core/container.h
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: 2022 yuzu Emulator Project // SPDX-FileCopyrightText: 2022 yuzu emulator team and Skyline Team and Contributors
// SPDX-FileCopyrightText: 2022 Skyline Team and Contributors // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#pragma once #pragma once

7
src/core/hle/service/nvdrv/core/nvmap.cpp
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: 2022 yuzu Emulator Project // SPDX-FileCopyrightText: 2022 yuzu emulator team and Skyline Team and Contributors
// SPDX-FileCopyrightText: 2022 Skyline Team and Contributors // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#include "common/alignment.h" #include "common/alignment.h"
#include "common/assert.h" #include "common/assert.h"

7
src/core/hle/service/nvdrv/core/nvmap.h
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: 2022 yuzu Emulator Project // SPDX-FileCopyrightText: 2022 yuzu emulator team and Skyline Team and Contributors
// SPDX-FileCopyrightText: 2022 Skyline Team and Contributors // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#pragma once #pragma once

7
src/core/hle/service/nvdrv/core/syncpoint_manager.cpp
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: 2022 yuzu Emulator Project // SPDX-FileCopyrightText: 2022 yuzu emulator team and Skyline Team and Contributors
// SPDX-FileCopyrightText: 2022 Skyline Team and Contributors // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#include "common/assert.h" #include "common/assert.h"
#include "core/hle/service/nvdrv/core/syncpoint_manager.h" #include "core/hle/service/nvdrv/core/syncpoint_manager.h"

7
src/core/hle/service/nvdrv/core/syncpoint_manager.h
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: 2022 yuzu Emulator Project // SPDX-FileCopyrightText: 2022 yuzu emulator team and Skyline Team and Contributors
// SPDX-FileCopyrightText: 2022 Skyline Team and Contributors // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#pragma once #pragma once

15
src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // SPDX-FileCopyrightText: 2021 yuzu emulator team, Skyline Team and Contributors
// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#include <cstring> #include <cstring>
#include <utility> #include <utility>
@ -472,16 +473,16 @@ void nvhost_as_gpu::GetVARegionsImpl(IoctlGetVaRegions& params) {
params.regions = std::array<VaRegion, 2>{ params.regions = std::array<VaRegion, 2>{
VaRegion{ VaRegion{
.offset = vm.small_page_allocator->GetVAStart() << VM::PAGE_SIZE_BITS, .offset = vm.small_page_allocator->vaStart << VM::PAGE_SIZE_BITS,
.page_size = VM::PAGE_SIZE, .page_size = VM::PAGE_SIZE,
._pad0_{}, ._pad0_{},
.pages = vm.small_page_allocator->GetVALimit() - vm.small_page_allocator->GetVAStart(), .pages = vm.small_page_allocator->vaLimit - vm.small_page_allocator->vaStart,
}, },
VaRegion{ VaRegion{
.offset = vm.big_page_allocator->GetVAStart() << vm.big_page_size_bits, .offset = vm.big_page_allocator->vaStart << vm.big_page_size_bits,
.page_size = vm.big_page_size, .page_size = vm.big_page_size,
._pad0_{}, ._pad0_{},
.pages = vm.big_page_allocator->GetVALimit() - vm.big_page_allocator->GetVAStart(), .pages = vm.big_page_allocator->vaLimit - vm.big_page_allocator->vaStart,
}, },
}; };
} }

7
src/core/hle/service/nvdrv/devices/nvhost_as_gpu.h
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // SPDX-FileCopyrightText: 2021 yuzu emulator team, Skyline Team and Contributors
// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#pragma once #pragma once

7
src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // SPDX-FileCopyrightText: 2021 yuzu emulator team, Skyline Team and Contributors
// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#include <bit> #include <bit>
#include <cstdlib> #include <cstdlib>

7
src/core/hle/service/nvdrv/devices/nvhost_ctrl.h
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // SPDX-FileCopyrightText: 2021 yuzu emulator team, Skyline Team and Contributors
// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#pragma once #pragma once

8
src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.cpp
View file

@ -47,15 +47,21 @@ std::size_t WriteVectors(std::vector<u8>& dst, const std::vector<T>& src, std::s
} // Anonymous namespace } // Anonymous namespace
std::unordered_map<DeviceFD, u32> nvhost_nvdec_common::fd_to_id{}; std::unordered_map<DeviceFD, u32> nvhost_nvdec_common::fd_to_id{};
std::deque<u32> nvhost_nvdec_common::syncpts_accumulated{};
nvhost_nvdec_common::nvhost_nvdec_common(Core::System& system_, NvCore::Container& core_, nvhost_nvdec_common::nvhost_nvdec_common(Core::System& system_, NvCore::Container& core_,
NvCore::ChannelType channel_type_) NvCore::ChannelType channel_type_)
: nvdevice{system_}, core{core_}, syncpoint_manager{core.GetSyncpointManager()}, : nvdevice{system_}, core{core_}, syncpoint_manager{core.GetSyncpointManager()},
nvmap{core.GetNvMapFile()}, channel_type{channel_type_} { nvmap{core.GetNvMapFile()}, channel_type{channel_type_} {
if (syncpts_accumulated.empty()) {
channel_syncpoint = syncpoint_manager.AllocateSyncpoint(false); channel_syncpoint = syncpoint_manager.AllocateSyncpoint(false);
} else {
channel_syncpoint = syncpts_accumulated.front();
syncpts_accumulated.pop_front();
}
} }
nvhost_nvdec_common::~nvhost_nvdec_common() { nvhost_nvdec_common::~nvhost_nvdec_common() {
syncpoint_manager.FreeSyncpoint(channel_syncpoint); syncpts_accumulated.push_back(channel_syncpoint);
} }
NvResult nvhost_nvdec_common::SetNVMAPfd(const std::vector<u8>& input) { NvResult nvhost_nvdec_common::SetNVMAPfd(const std::vector<u8>& input) {

3
src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.h
View file

@ -3,6 +3,7 @@
#pragma once #pragma once
#include <deque>
#include <vector> #include <vector>
#include "common/common_types.h" #include "common/common_types.h"
#include "common/swap.h" #include "common/swap.h"
@ -127,6 +128,8 @@ protected:
NvCore::NvMap& nvmap; NvCore::NvMap& nvmap;
NvCore::ChannelType channel_type; NvCore::ChannelType channel_type;
std::array<u32, MaxSyncPoints> device_syncpoints{}; std::array<u32, MaxSyncPoints> device_syncpoints{};
static std::deque<u32> syncpts_accumulated;
}; };
}; // namespace Devices }; // namespace Devices
} // namespace Service::Nvidia } // namespace Service::Nvidia

7
src/core/hle/service/nvdrv/nvdata.h
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // SPDX-FileCopyrightText: 2021 yuzu emulator team and Skyline Team and Contributors
// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#pragma once #pragma once

7
src/core/hle/service/nvdrv/nvdrv.cpp
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // SPDX-FileCopyrightText: 2021 yuzu emulator team and Skyline Team and Contributors
// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#include <utility> #include <utility>

7
src/core/hle/service/nvdrv/nvdrv.h
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // SPDX-FileCopyrightText: 2021 yuzu emulator team and Skyline Team and Contributors
// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#pragma once #pragma once

7
src/core/hle/service/nvdrv/nvdrv_interface.cpp
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // SPDX-FileCopyrightText: 2021 yuzu emulator team and Skyline Team and Contributors
// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#include <cinttypes> #include <cinttypes>
#include "common/logging/log.h" #include "common/logging/log.h"

5
src/video_core/control/channel_state.cpp
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2022 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later // Licensed under GPLv3 or any later version
// Refer to the license.txt file included.
#include "common/assert.h" #include "common/assert.h"
#include "video_core/control/channel_state.h" #include "video_core/control/channel_state.h"

5
src/video_core/control/channel_state.h
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2022 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later // Licensed under GPLv3 or any later version
// Refer to the license.txt file included.
#pragma once #pragma once

3
src/video_core/control/channel_state_cache.cpp
View file

@ -1,6 +1,3 @@
// SPDX-FileCopyrightText: 2022 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#include "video_core/control/channel_state_cache.inc" #include "video_core/control/channel_state_cache.inc"
namespace VideoCommon { namespace VideoCommon {

5
src/video_core/control/channel_state_cache.h
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2022 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later // Licensed under GPLv3 or any later version
// Refer to the license.txt file included.
#pragma once #pragma once

2
src/video_core/control/channel_state_cache.inc
View file

@ -1,5 +1,3 @@
// SPDX-FileCopyrightText: 2022 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#include <algorithm> #include <algorithm>

5
src/video_core/control/scheduler.cpp
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later // Licensed under GPLv3 or any later version
// Refer to the license.txt file included.
#include <memory> #include <memory>

5
src/video_core/control/scheduler.h
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later // Licensed under GPLv3 or any later version
// Refer to the license.txt file included.
#pragma once #pragma once

19
src/video_core/engines/puller.cpp
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2022 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later // Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "common/assert.h" #include "common/assert.h"
#include "common/logging/log.h" #include "common/logging/log.h"
@ -73,21 +74,13 @@ void Puller::ProcessSemaphoreTriggerMethod() {
const auto op = const auto op =
static_cast<GpuSemaphoreOperation>(regs.semaphore_trigger & semaphoreOperationMask); static_cast<GpuSemaphoreOperation>(regs.semaphore_trigger & semaphoreOperationMask);
if (op == GpuSemaphoreOperation::WriteLong) { if (op == GpuSemaphoreOperation::WriteLong) {
struct Block {
u32 sequence;
u32 zeros = 0;
u64 timestamp;
};
const GPUVAddr sequence_address{regs.semaphore_address.SemaphoreAddress()}; const GPUVAddr sequence_address{regs.semaphore_address.SemaphoreAddress()};
const u32 payload = regs.semaphore_sequence; const u32 payload = regs.semaphore_sequence;
std::function<void()> operation([this, sequence_address, payload] { std::function<void()> operation([this, sequence_address, payload] {
Block block{}; memory_manager.Write<u64>(sequence_address + sizeof(u64), gpu.GetTicks());
block.sequence = payload; memory_manager.Write<u64>(sequence_address, payload);
block.timestamp = gpu.GetTicks();
memory_manager.WriteBlockUnsafe(sequence_address, &block, sizeof(block));
}); });
rasterizer->SyncOperation(std::move(operation)); rasterizer->SignalFence(std::move(operation));
} else { } else {
do { do {
const u32 word{memory_manager.Read<u32>(regs.semaphore_address.SemaphoreAddress())}; const u32 word{memory_manager.Read<u32>(regs.semaphore_address.SemaphoreAddress())};

5
src/video_core/engines/puller.h
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2022 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later // Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#pragma once #pragma once

5
src/video_core/host1x/control.cpp
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // Copyright 2022 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later // Licensed under GPLv3 or any later version
// Refer to the license.txt file included.
#include "common/assert.h" #include "common/assert.h"
#include "video_core/host1x/control.h" #include "video_core/host1x/control.h"

7
src/video_core/host1x/control.h
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // SPDX-FileCopyrightText: 2021 yuzu emulator team and Skyline Team and Contributors
// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#pragma once #pragma once

5
src/video_core/host1x/host1x.cpp
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // Copyright 2022 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later // Licensed under GPLv3 or any later version
// Refer to the license.txt file included.
#include "core/core.h" #include "core/core.h"
#include "video_core/host1x/host1x.h" #include "video_core/host1x/host1x.h"

5
src/video_core/host1x/host1x.h
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // Copyright 2022 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later // Licensed under GPLv3 or any later version
// Refer to the license.txt file included.
#pragma once #pragma once

5
src/video_core/host1x/syncpoint_manager.cpp
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later // Licensed under GPLv3 or any later version
// Refer to the license.txt file included.
#include "common/microprofile.h" #include "common/microprofile.h"
#include "video_core/host1x/syncpoint_manager.h" #include "video_core/host1x/syncpoint_manager.h"

5
src/video_core/host1x/syncpoint_manager.h
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later // Licensed under GPLv3 or any later version
// Refer to the license.txt file included.
#pragma once #pragma once

3
src/video_core/renderer_vulkan/vk_texture_cache.cpp
View file

@ -1475,7 +1475,7 @@ bool Image::BlitScaleHelper(bool scale_up) {
}; };
const VkExtent2D extent{ const VkExtent2D extent{
.width = std::max(scaled_width, info.size.width), .width = std::max(scaled_width, info.size.width),
.height = std::max(scaled_height, info.size.width), .height = std::max(scaled_height, info.size.height),
}; };
auto* view_ptr = blit_view.get(); auto* view_ptr = blit_view.get();
@ -1772,7 +1772,6 @@ void Framebuffer::CreateFramebuffer(TextureCacheRuntime& runtime,
s32 num_layers = 1; s32 num_layers = 1;
const auto& resolution = runtime.resolution; const auto& resolution = runtime.resolution;
is_rescaled |= resolution.active;
u32 width = 0; u32 width = 0;
u32 height = 0; u32 height = 0;

5
src/video_core/texture_cache/texture_cache.cpp
View file

@ -1,5 +1,6 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later // Licensed under GPLv3 or any later version
// Refer to the license.txt file included.
#include "video_core/control/channel_state_cache.inc" #include "video_core/control/channel_state_cache.inc"
#include "video_core/texture_cache/texture_cache_base.h" #include "video_core/texture_cache/texture_cache_base.h"

7
src/video_core/texture_cache/texture_cache.h
View file

@ -1,5 +1,7 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // SPDX-FileCopyrightText: 2021 yuzu emulator team
// SPDX-License-Identifier: GPL-3.0-or-later // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#pragma once #pragma once
@ -355,6 +357,7 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
(maxwell3d->regs.render_area.width * up_scale) >> down_shift, (maxwell3d->regs.render_area.width * up_scale) >> down_shift,
(maxwell3d->regs.render_area.height * up_scale) >> down_shift, (maxwell3d->regs.render_area.height * up_scale) >> down_shift,
}; };
render_targets.is_rescaled = is_rescaling;
flags[Dirty::DepthBiasGlobal] = true; flags[Dirty::DepthBiasGlobal] = true;
} }

6
src/video_core/texture_cache/texture_cache_base.h
View file

@ -1,5 +1,7 @@
// SPDX-FileCopyrightText: 2021 yuzu Emulator Project // SPDX-FileCopyrightText: 2021 yuzu emulator team
// SPDX-License-Identifier: GPL-3.0-or-later // (https://github.com/skyline-emu/)
// SPDX-License-Identifier: GPL-3.0-or-later Licensed under GPLv3
// or any later version Refer to the license.txt file included.
#pragma once #pragma once