0
0
Fork 0
This repository has been archived on 2024-10-12. You can view files and clone it, but cannot push or open issues or pull requests.
ryujinx-final/Ryujinx.Graphics.Gpu/Engine/MethodReport.cs

137 lines
5 KiB
C#
Raw Normal View History

2019-10-13 06:02:07 +00:00
using Ryujinx.Common;
using Ryujinx.Graphics.GAL;
using Ryujinx.Graphics.Gpu.Memory;
2019-10-13 06:02:07 +00:00
using Ryujinx.Graphics.Gpu.State;
using System;
using System.Runtime.InteropServices;
namespace Ryujinx.Graphics.Gpu.Engine
{
partial class Methods
{
private const int NsToTicksFractionNumerator = 384;
2020-01-01 15:39:09 +00:00
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>
2019-11-22 02:46:14 +00:00
private void Report(GpuState state, int argument)
2019-10-13 06:02:07 +00:00
{
SemaphoreOperation op = (SemaphoreOperation)(argument & 3);
2019-10-13 06:02:07 +00:00
ReportCounterType type = (ReportCounterType)((argument >> 23) & 0x1f);
switch (op)
2019-10-13 06:02:07 +00:00
{
case SemaphoreOperation.Release: ReleaseSemaphore(state); break;
case SemaphoreOperation.Counter: ReportCounter(state, type); break;
2019-10-13 06:02:07 +00:00
}
}
/// <summary>
/// Writes (or Releases) a GPU semaphore value to guest memory.
/// </summary>
/// <param name="state">Current GPU state</param>
private void ReleaseSemaphore(GpuState state)
2019-10-13 06:02:07 +00:00
{
var rs = state.Get<SemaphoreState>(MethodOffset.ReportState);
2019-10-13 06:02:07 +00:00
2019-11-22 02:46:14 +00:00
_context.MemoryAccessor.Write(rs.Address.Pack(), rs.Payload);
2019-10-13 06:02:07 +00:00
_context.AdvanceSequence();
}
/// <summary>
/// Packed GPU counter data (including GPU timestamp) in memory.
/// </summary>
2019-10-13 06:02:07 +00:00
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>
2019-11-22 02:46:14 +00:00
private void ReportCounter(GpuState state, ReportCounterType type)
2019-10-13 06:02:07 +00:00
{
CounterData counterData = new CounterData();
var rs = state.Get<SemaphoreState>(MethodOffset.ReportState);
2019-10-13 06:02:07 +00:00
ulong gpuVa = rs.Address.Pack();
2019-10-13 06:02:07 +00:00
ulong ticks = ConvertNanosecondsToTicks((ulong)PerformanceCounter.ElapsedNanoseconds);
2019-10-13 06:02:07 +00:00
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;
2019-10-13 06:02:07 +00:00
}
ICounterEvent counter = null;
EventHandler<ulong> resultHandler = (object evt, ulong result) =>
{
counterData.Counter = result;
counterData.Timestamp = ticks;
2019-10-13 06:02:07 +00:00
Span<CounterData> counterDataSpan = MemoryMarshal.CreateSpan(ref counterData, 1);
2019-10-13 06:02:07 +00:00
Span<byte> data = MemoryMarshal.Cast<CounterData, byte>(counterDataSpan);
2019-10-13 06:02:07 +00:00
if (counter?.Invalid != true)
{
_context.MemoryAccessor.Write(gpuVa, data);
}
};
2019-10-13 06:02:07 +00:00
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);
2019-10-13 06:02:07 +00:00
}
/// <summary>
/// Converts a nanoseconds timestamp value to Maxwell time ticks.
/// </summary>
2020-01-01 15:39:09 +00:00
/// <remarks>
/// The frequency is 614400000 Hz.
/// </remarks>
/// <param name="nanoseconds">Timestamp in nanoseconds</param>
/// <returns>Maxwell ticks</returns>
2019-10-13 06:02:07 +00:00
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.
2020-01-01 15:39:09 +00:00
ulong divided = nanoseconds / NsToTicksFractionDenominator;
2019-10-13 06:02:07 +00:00
2020-01-01 15:39:09 +00:00
ulong rounded = divided * NsToTicksFractionDenominator;
2019-10-13 06:02:07 +00:00
2020-01-01 15:39:09 +00:00
ulong errorBias = (nanoseconds - rounded) * NsToTicksFractionNumerator / NsToTicksFractionDenominator;
2019-10-13 06:02:07 +00:00
2020-01-01 15:39:09 +00:00
return divided * NsToTicksFractionNumerator + errorBias;
2019-10-13 06:02:07 +00:00
}
}
}