mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-20 15:48:43 +02:00
* Initial implementation. Still pending better valid-overlap handling, disposed pool, compressed format flush fix. * Very messy backend resource cache. * Oops * Dispose -> Release * Improve Release/Dispose. * More rule refinement. * View compatibility levels as an enum - you can always know if a view is only copy compatible. * General cleanup. Use locking on the resource cache, as it is likely to be used by other threads in future. * Rename resource cache to resource pool. * Address some of the smaller nits. * Fix regression with MK8 lens flare Texture flushes done the old way should trigger memory tracking. * Use TextureCreateInfo as a key. It now implements IEquatable and generates a hashcode based on width/height. * Fix size change for compressed+non-compressed view combos. Before, this could set either the compressed or non compressed texture with a size with the wrong size, depending on which texture had its size changed. This caused exceptions when flushing the texture. Now it correctly takes the block size into account, assuming that these textures are only related because a pixel in the non-compressed texture represents a block in the compressed one. * Implement JD's suggestion for HashCode Combine Co-authored-by: jduncanator <1518948+jduncanator@users.noreply.github.com> * Address feedback * Address feedback. Co-authored-by: jduncanator <1518948+jduncanator@users.noreply.github.com>
94 lines
3.7 KiB
C#
94 lines
3.7 KiB
C#
using Ryujinx.Cpu;
|
|
using System;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace Ryujinx.Graphics.Gpu.Memory
|
|
{
|
|
/// <summary>
|
|
/// Represents physical memory, accessible from the GPU.
|
|
/// This is actually working CPU virtual addresses, of memory mapped on the application process.
|
|
/// </summary>
|
|
class PhysicalMemory
|
|
{
|
|
public const int PageSize = Cpu.MemoryManager.PageSize;
|
|
|
|
private readonly Cpu.MemoryManager _cpuMemory;
|
|
|
|
/// <summary>
|
|
/// Creates a new instance of the physical memory.
|
|
/// </summary>
|
|
/// <param name="cpuMemory">CPU memory manager of the application process</param>
|
|
public PhysicalMemory(Cpu.MemoryManager cpuMemory)
|
|
{
|
|
_cpuMemory = cpuMemory;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a span of data from the application process.
|
|
/// </summary>
|
|
/// <param name="address">Start address of the range</param>
|
|
/// <param name="size">Size in bytes to be range</param>
|
|
/// <returns>A read only span of the data at the specified memory location</returns>
|
|
public ReadOnlySpan<byte> GetSpan(ulong address, int size)
|
|
{
|
|
return _cpuMemory.GetSpan(address, size);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a writable region from the application process.
|
|
/// </summary>
|
|
/// <param name="address">Start address of the range</param>
|
|
/// <param name="size">Size in bytes to be range</param>
|
|
/// <returns>A writable region with the data at the specified memory location</returns>
|
|
public WritableRegion GetWritableRegion(ulong address, int size)
|
|
{
|
|
return _cpuMemory.GetWritableRegion(address, size);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads data from the application process.
|
|
/// </summary>
|
|
/// <typeparam name="T">Type of the structure</typeparam>
|
|
/// <param name="gpuVa">Address to read from</param>
|
|
/// <returns>The data at the specified memory location</returns>
|
|
public T Read<T>(ulong address) where T : unmanaged
|
|
{
|
|
return MemoryMarshal.Cast<byte, T>(GetSpan(address, Unsafe.SizeOf<T>()))[0];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes data to the application process.
|
|
/// </summary>
|
|
/// <param name="address">Address to write into</param>
|
|
/// <param name="data">Data to be written</param>
|
|
public void Write(ulong address, ReadOnlySpan<byte> data)
|
|
{
|
|
_cpuMemory.Write(address, data);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes data to the application process, without any tracking.
|
|
/// </summary>
|
|
/// <param name="address">Address to write into</param>
|
|
/// <param name="data">Data to be written</param>
|
|
public void WriteUntracked(ulong address, ReadOnlySpan<byte> data)
|
|
{
|
|
_cpuMemory.WriteUntracked(address, data);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if a specified virtual memory region has been modified by the CPU since the last call.
|
|
/// </summary>
|
|
/// <param name="address">CPU virtual address of the region</param>
|
|
/// <param name="size">Size of the region</param>
|
|
/// <param name="name">Resource name</param>
|
|
/// <param name="modifiedRanges">Optional array where the modified ranges should be written</param>
|
|
/// <returns>The number of modified ranges</returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public int QueryModified(ulong address, ulong size, ResourceName name, (ulong, ulong)[] modifiedRanges = null)
|
|
{
|
|
return _cpuMemory.QueryModified(address, size, (int)name, modifiedRanges);
|
|
}
|
|
}
|
|
} |