/// <param name="va">Virtual address of the region</param>

/// <param name="size">Size of the region</param>

/// <param name="write">True if the region was written, false if read</param>

}

} \ No newline at end of file

// Call the tracking action, with the pointer's relative offset to the base address.

Operand trackingActionPtr = context.Load(OperandType.I64, Const((ulong)signalStructPtr + rangeBaseOffset + 20));

context.Branch(endLabel);

{

class MemoryEhMeilleure : IDisposable

{

private readonly MemoryBlock _addressSpace;

private readonly MemoryTracking _tracking;

}

/// <inheritdoc/>

{

AssertValidAddressAndSize(va, size);

// We emulate guard pages for software memory access. This makes for an easy transition to

// tracking using host guard pages in future, but also supporting platforms where this is not possible.

/// <remarks>

/// This function also validates that the given range is both valid and mapped, and will throw if it is not.

/// </remarks>

{

AssertValidAddressAndSize(va, size);

// Software table, used for managed memory tracking.

int pages = GetPagesCount(va, size, out _);

public void QueryModified(ulong address, ulong size, Action<ulong, ulong> modifiedAction) => _impl.QueryModified(address, size, modifiedAction);

public void QueryModified(ulong address, ulong size, Action<ulong, ulong> modifiedAction, int sequenceNumber) => _impl.QueryModified(address, size, modifiedAction, sequenceNumber);

public void RegisterAction(ulong address, ulong size, RegionSignal action) => _impl.RegisterAction(address, size, action);

public void SignalWrite() => _impl.SignalWrite();

}

}

public void ForceDirty() => _impl.ForceDirty();

public IRegionHandle GetHandle() => _impl;

public void RegisterAction(RegionSignal action) => _impl.RegisterAction(action);

public void RegisterDirtyEvent(Action action) => _impl.RegisterDirtyEvent(action);

public void Reprotect(bool asDirty = false) => _impl.Reprotect(asDirty);

public void Dispose() => _impl.Dispose();

public void ForceDirty(ulong address, ulong size) => _impl.ForceDirty(address, size);

public void RegisterAction(RegionSignal action) => _impl.RegisterAction(action);

public void QueryModified(Action<ulong, ulong> modifiedAction) => _impl.QueryModified(modifiedAction);

public void QueryModified(ulong address, ulong size, Action<ulong, ulong> modifiedAction) => _impl.QueryModified(address, size, modifiedAction);

public void QueryModified(ulong address, ulong size, Action<ulong, ulong> modifiedAction, int sequenceNumber) => _impl.QueryModified(address, size, modifiedAction, sequenceNumber);

if (_isLinear && _lineCount == 1)

{

}

else

{

{

uint syncpointId = (uint)argument & 0xFFFF;

_context.CreateHostSyncIfNeeded();

_context.Renderer.UpdateCounters(); // Poll the query counters, the game may want an updated result.

_context.Synchronization.IncrementSyncpoint(syncpointId);

protected GpuContext Context;

protected PhysicalMemory PhysicalMemory;

protected T1[] Items;

protected T2[] DescriptorCache;

Size = size;

_memoryTracking = physicalMemory.BeginGranularTracking(address, size);

_modifiedDelegate = RegionModified;

}

InvalidateRangeImpl(mAddress, mSize);

}

protected abstract void InvalidateRangeImpl(ulong address, ulong size);

protected abstract void Delete(T1 item);

/// </summary>

class SamplerPool : Pool<Sampler, SamplerDescriptor>

{

/// <summary>

/// Constructs a new instance of the sampler pool.

/// </summary>

return null;

}

{

SynchronizeMemory();

}

}

/// <summary>

/// Determines if a given texture is "safe" for upscaling from its info.

/// Note that this is different from being compatible - this elilinates targets that would have detrimental effects when scaled.

/// </summary>

/// </summary>

class TexturePool : Pool<Texture, TextureDescriptor>

{

private readonly GpuChannel _channel;

private readonly ConcurrentQueue<Texture> _dereferenceQueue = new ConcurrentQueue<Texture>();

return null;

}

{

SynchronizeMemory();

}

using Ryujinx.Cpu.Tracking;

using Ryujinx.Graphics.GAL;

using Ryujinx.Memory.Range;

if (_useGranular)

{

_memoryTrackingGranular = physicalMemory.BeginGranularTracking(address, size, baseHandles);

}

else

{

handle.Dispose();

}

}

}

_externalFlushDelegate = new RegionSignal(ExternalFlush);

}

/// <summary>

/// Called when part of the memory for this buffer has been unmapped.

/// Calls are from non-GPU threads.

/// </summary>

namespace Ryujinx.Graphics.Gpu.Memory

{

class GpuRegionHandle : IRegionHandle

{

private readonly CpuRegionHandle[] _cpuRegionHandles;

public ulong Size => throw new NotSupportedException();

public ulong EndAddress => throw new NotSupportedException();

public GpuRegionHandle(CpuRegionHandle[] cpuRegionHandles)

{

_cpuRegionHandles = cpuRegionHandles;

}

public void Dispose()

{

foreach (var regionHandle in _cpuRegionHandles)

}

}

public void RegisterAction(RegionSignal action)

{

foreach (var regionHandle in _cpuRegionHandles)

}

}

public void Reprotect(bool asDirty = false)

{

foreach (var regionHandle in _cpuRegionHandles)

}

}

public void ForceDirty()

{

foreach (var regionHandle in _cpuRegionHandles)

}

/// <summary>

/// Writes data to GPU mapped memory without write tracking.

/// </summary>

/// <param name="va">GPU virtual address to write the data into</param>

}

/// <summary>

/// Gets a span of data from the application process.

/// </summary>

/// <param name="address">Start address of the range</param>

}

/// <summary>

/// Writes data to the application process.

/// </summary>

/// <param name="address">Address to write into</param>

throw new NotImplementedException();

}

{

throw new NotImplementedException();

}

Assert.AreEqual(singlePages[1], combinedHandles.ElementAt(9));

Assert.AreEqual(singlePages[2], combinedHandles.ElementAt(10));

}

}

}

handle.Dispose();

}

}

}

throw new NotImplementedException();

}

{

// Only the ARM Memory Manager has tracking for now.

}

/// <param name="va">Virtual address of the region</param>

/// <param name="size">Size of the region</param>

/// <param name="write">True if the region was written, false if read</param>

/// <summary>

/// Reprotect a region of virtual memory for tracking.

public abstract void Signal(ulong address, ulong size, bool write);

/// <summary>

/// Split this region into two, around the specified address.

/// This region is updated to end at the split address, and a new region is created to represent past that point.

/// </summary>

void ForceDirty();

void Reprotect(bool asDirty = false);

void RegisterAction(RegionSignal action);

}

}

/// <summary>

/// Signal that a virtual memory event happened at the given location.

/// </summary>

/// <param name="address">Virtual address accessed</param>

/// <param name="size">Size of the region affected in bytes</param>

/// <param name="write">Whether the region was written to or read</param>

/// <returns>True if the event triggered any tracking regions, false otherwise</returns>

{

// Look up the virtual region using the region list.

// Signal up the chain to relevant handles.

int count = _virtualRegions.FindOverlapsNonOverlapping(address, size, ref overlaps);

{

if (!_memoryManager.IsMapped(address))

{

for (int i = 0; i < count; i++)

{

VirtualRegion region = overlaps[i];

}

}

}

}

public void Dispose()

{

foreach (var handle in _handles)

private object _preActionLock = new object();

private RegionSignal _preAction; // Action to perform before a read or write. This will block the memory access.

private readonly List<VirtualRegion> _regions;

private readonly MemoryTracking _tracking;

private bool _disposed;

/// <summary>

/// Signal that a memory action occurred within this handle's virtual regions.

/// </summary>

/// <param name="write">Whether the region was written to or read</param>

internal void Signal(ulong address, ulong size, bool write, ref IList<RegionHandle> handleIterable)

{

// If this handle was already unmapped (even if just partially),

}

/// <summary>

/// Force this handle to be dirty, without reprotecting.

/// </summary>

public void ForceDirty()

}

/// <summary>

/// Register an action to perform when the region is written to.

/// This action will not be removed when it is called - it is called each time the dirty flag is set.

/// </summary>

}

}

public void QueryModified(Action<ulong, ulong> modifiedAction)

{

if (!Dirty)

UpdateProtection();

}

/// <summary>

/// Signal that this region has been mapped or unmapped.

/// </summary>