mirror of
https://github.com/ryujinx-mirror/ryujinx.git
synced 2024-12-05 04:57:55 +01:00
111534a74e
* Remove GPU MemoryAccessor * Update outdated XML doc * Update more outdated stuff
133 lines
4.8 KiB
C#
133 lines
4.8 KiB
C#
using Ryujinx.Common;
|
|
using Ryujinx.Graphics.GAL;
|
|
using Ryujinx.Graphics.Gpu.Memory;
|
|
using Ryujinx.Graphics.Gpu.State;
|
|
using System;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace Ryujinx.Graphics.Gpu.Engine
|
|
{
|
|
partial class Methods
|
|
{
|
|
private const int NsToTicksFractionNumerator = 384;
|
|
private const int NsToTicksFractionDenominator = 625;
|
|
|
|
private readonly CounterCache _counterCache = new CounterCache();
|
|
|
|
/// <summary>
|
|
/// Writes a GPU counter to guest memory.
|
|
/// </summary>
|
|
/// <param name="state">Current GPU state</param>
|
|
/// <param name="argument">Method call argument</param>
|
|
private void Report(GpuState state, int argument)
|
|
{
|
|
SemaphoreOperation op = (SemaphoreOperation)(argument & 3);
|
|
ReportCounterType type = (ReportCounterType)((argument >> 23) & 0x1f);
|
|
|
|
switch (op)
|
|
{
|
|
case SemaphoreOperation.Release: ReleaseSemaphore(state); break;
|
|
case SemaphoreOperation.Counter: ReportCounter(state, type); break;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes (or Releases) a GPU semaphore value to guest memory.
|
|
/// </summary>
|
|
/// <param name="state">Current GPU state</param>
|
|
private void ReleaseSemaphore(GpuState state)
|
|
{
|
|
var rs = state.Get<SemaphoreState>(MethodOffset.ReportState);
|
|
|
|
_context.MemoryManager.Write(rs.Address.Pack(), rs.Payload);
|
|
|
|
_context.AdvanceSequence();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Packed GPU counter data (including GPU timestamp) in memory.
|
|
/// </summary>
|
|
private struct CounterData
|
|
{
|
|
public ulong Counter;
|
|
public ulong Timestamp;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes a GPU counter to guest memory.
|
|
/// This also writes the current timestamp value.
|
|
/// </summary>
|
|
/// <param name="state">Current GPU state</param>
|
|
/// <param name="type">Counter to be written to memory</param>
|
|
private void ReportCounter(GpuState state, ReportCounterType type)
|
|
{
|
|
var rs = state.Get<SemaphoreState>(MethodOffset.ReportState);
|
|
|
|
ulong gpuVa = rs.Address.Pack();
|
|
|
|
ulong ticks = ConvertNanosecondsToTicks((ulong)PerformanceCounter.ElapsedNanoseconds);
|
|
|
|
if (GraphicsConfig.FastGpuTime)
|
|
{
|
|
// Divide by some amount to report time as if operations were performed faster than they really are.
|
|
// This can prevent some games from switching to a lower resolution because rendering is too slow.
|
|
ticks /= 256;
|
|
}
|
|
|
|
ICounterEvent counter = null;
|
|
|
|
EventHandler<ulong> resultHandler = (object evt, ulong result) =>
|
|
{
|
|
CounterData counterData = new CounterData();
|
|
|
|
counterData.Counter = result;
|
|
counterData.Timestamp = ticks;
|
|
|
|
if (counter?.Invalid != true)
|
|
{
|
|
_context.MemoryManager.Write(gpuVa, counterData);
|
|
}
|
|
};
|
|
|
|
switch (type)
|
|
{
|
|
case ReportCounterType.Zero:
|
|
resultHandler(null, 0);
|
|
break;
|
|
case ReportCounterType.SamplesPassed:
|
|
counter = _context.Renderer.ReportCounter(CounterType.SamplesPassed, resultHandler);
|
|
break;
|
|
case ReportCounterType.PrimitivesGenerated:
|
|
counter = _context.Renderer.ReportCounter(CounterType.PrimitivesGenerated, resultHandler);
|
|
break;
|
|
case ReportCounterType.TransformFeedbackPrimitivesWritten:
|
|
counter = _context.Renderer.ReportCounter(CounterType.TransformFeedbackPrimitivesWritten, resultHandler);
|
|
break;
|
|
}
|
|
|
|
_counterCache.AddOrUpdate(gpuVa, counter);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Converts a nanoseconds timestamp value to Maxwell time ticks.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The frequency is 614400000 Hz.
|
|
/// </remarks>
|
|
/// <param name="nanoseconds">Timestamp in nanoseconds</param>
|
|
/// <returns>Maxwell ticks</returns>
|
|
private static ulong ConvertNanosecondsToTicks(ulong nanoseconds)
|
|
{
|
|
// We need to divide first to avoid overflows.
|
|
// We fix up the result later by calculating the difference and adding
|
|
// that to the result.
|
|
ulong divided = nanoseconds / NsToTicksFractionDenominator;
|
|
|
|
ulong rounded = divided * NsToTicksFractionDenominator;
|
|
|
|
ulong errorBias = (nanoseconds - rounded) * NsToTicksFractionNumerator / NsToTicksFractionDenominator;
|
|
|
|
return divided * NsToTicksFractionNumerator + errorBias;
|
|
}
|
|
}
|
|
} |