mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2024-11-15 13:57:57 -07:00
65af90669b
It's a relatively big commit (less big with -w), but it's hard to test any of this separately... The basic problem is that in netplay or movies, the state of the CPU must be deterministic, including when the game receives notification that the GPU has processed FIFO data. Dual core mode notifies the game whenever the GPU thread actually gets around to doing the work, so it isn't deterministic. Single core mode is because it notifies the game 'instantly' (after processing the data synchronously), but it's too slow for many systems and games. My old dc-netplay branch worked as follows: everything worked as normal except the state of the CP registers was a lie, and the CPU thread only delivered results when idle detection triggered (waiting for the GPU if they weren't ready at that point). Usually, a game is idle iff all the work for the frame has been done, except for a small amount of work depending on the GPU result, so neither the CPU or the GPU waiting on the other affected performance much. However, it's possible that the game could be waiting for some earlier interrupt, and any of several games which, for whatever reason, never went into a detectable idle (even when I tried to improve the detection) would never receive results at all. (The current method should have better compatibility, but it also has slightly higher overhead and breaks some other things, so I want to reimplement this, hopefully with less impact on the code, in the future.) With this commit, the basic idea is that the CPU thread acts as if the work has been done instantly, like single core mode, but actually hands it off asynchronously to the GPU thread (after backing up some data that the game might change in memory before it's actually done). Since the work isn't done, any feedback from the GPU to the CPU, such as real XFB/EFB copies (virtual are OK), EFB pokes, performance queries, etc. is broken; but most games work with these options disabled, and there is no need to try to detect what the CPU thread is doing. Technically: when the flag g_use_deterministic_gpu_thread (currently stuck on) is on, the CPU thread calls RunGpu like in single core mode. This function synchronously copies the data from the FIFO to the internal video buffer and updates the CP registers, interrupts, etc. However, instead of the regular ReadDataFromFifo followed by running the opcode decoder, it runs ReadDataFromFifoOnCPU -> OpcodeDecoder_Preprocess, which relatively quickly scans through the FIFO data, detects SetFinish calls etc., which are immediately fired, and saves certain associated data from memory (e.g. display lists) in AuxBuffers (a parallel stream to the main FIFO, which is a bit slow at the moment), before handing the data off to the GPU thread to actually render. That makes up the bulk of this commit. In various circumstances, including the aforementioned EFB pokes and performance queries as well as swap requests (i.e. the end of a frame - we don't want the CPU potentially pumping out frames too quickly and the GPU falling behind*), SyncGPU is called to wait for actual completion. The overhead mainly comes from OpcodeDecoder_Preprocess (which is, again, synchronous), as well as the actual copying. Currently, display lists and such are escrowed from main memory even though they usually won't change over the course of a frame, and textures are not even though they might, resulting in a small chance of graphical glitches. When the texture locking (i.e. fault on write) code lands, I can make this all correct and maybe a little faster. * This suggests an alternate determinism method of just delaying results until a short time before the end of each frame. For all I know this might mostly work - I haven't tried it - but if any significant work hinges on the competion of render to texture etc., the frame will be missed.
128 lines
2.4 KiB
C++
128 lines
2.4 KiB
C++
// Copyright 2013 Dolphin Emulator Project
|
|
// Licensed under GPLv2
|
|
// Refer to the license.txt file included.
|
|
|
|
#pragma once
|
|
|
|
#include "VideoCommon/VertexManagerBase.h"
|
|
|
|
extern u8* g_video_buffer_read_ptr;
|
|
|
|
#if _M_SSE >= 0x301 && !(defined __GNUC__ && !defined __SSSE3__)
|
|
#include <tmmintrin.h>
|
|
#endif
|
|
|
|
__forceinline void DataSkip(u32 skip)
|
|
{
|
|
g_video_buffer_read_ptr += skip;
|
|
}
|
|
|
|
// probably unnecessary
|
|
template <int count>
|
|
__forceinline void DataSkip()
|
|
{
|
|
g_video_buffer_read_ptr += count;
|
|
}
|
|
|
|
template <typename T>
|
|
__forceinline T DataPeek(int _uOffset, u8** bufp = &g_video_buffer_read_ptr)
|
|
{
|
|
auto const result = Common::FromBigEndian(*reinterpret_cast<T*>(*bufp + _uOffset));
|
|
return result;
|
|
}
|
|
|
|
// TODO: kill these
|
|
__forceinline u8 DataPeek8(int _uOffset)
|
|
{
|
|
return DataPeek<u8>(_uOffset);
|
|
}
|
|
|
|
__forceinline u16 DataPeek16(int _uOffset)
|
|
{
|
|
return DataPeek<u16>(_uOffset);
|
|
}
|
|
|
|
__forceinline u32 DataPeek32(int _uOffset)
|
|
{
|
|
return DataPeek<u32>(_uOffset);
|
|
}
|
|
|
|
template <typename T>
|
|
__forceinline T DataRead(u8** bufp = &g_video_buffer_read_ptr)
|
|
{
|
|
auto const result = DataPeek<T>(0, bufp);
|
|
*bufp += sizeof(T);
|
|
return result;
|
|
}
|
|
|
|
class DataReader
|
|
{
|
|
public:
|
|
inline DataReader() : buffer(g_video_buffer_read_ptr), offset(0) {}
|
|
inline ~DataReader() { g_video_buffer_read_ptr += offset; }
|
|
template <typename T> inline T Read()
|
|
{
|
|
const T result = Common::FromBigEndian(*(T*)(buffer + offset));
|
|
offset += sizeof(T);
|
|
return result;
|
|
}
|
|
private:
|
|
u8 *buffer;
|
|
int offset;
|
|
};
|
|
|
|
// TODO: kill these
|
|
__forceinline u8 DataReadU8()
|
|
{
|
|
return DataRead<u8>();
|
|
}
|
|
|
|
__forceinline s8 DataReadS8()
|
|
{
|
|
return DataRead<s8>();
|
|
}
|
|
|
|
__forceinline u16 DataReadU16()
|
|
{
|
|
return DataRead<u16>();
|
|
}
|
|
|
|
__forceinline u32 DataReadU32()
|
|
{
|
|
return DataRead<u32>();
|
|
}
|
|
|
|
__forceinline u32 DataReadU32Unswapped()
|
|
{
|
|
u32 tmp = *(u32*)g_video_buffer_read_ptr;
|
|
g_video_buffer_read_ptr += 4;
|
|
return tmp;
|
|
}
|
|
|
|
__forceinline u8* DataGetPosition()
|
|
{
|
|
return g_video_buffer_read_ptr;
|
|
}
|
|
|
|
template <typename T>
|
|
__forceinline void DataWrite(T data)
|
|
{
|
|
*(T*)VertexManager::s_pCurBufferPointer = data;
|
|
VertexManager::s_pCurBufferPointer += sizeof(T);
|
|
}
|
|
|
|
class DataWriter
|
|
{
|
|
public:
|
|
inline DataWriter() : buffer(VertexManager::s_pCurBufferPointer), offset(0) {}
|
|
inline ~DataWriter() { VertexManager::s_pCurBufferPointer += offset; }
|
|
template <typename T> inline void Write(T data)
|
|
{
|
|
*(T*)(buffer+offset) = data;
|
|
offset += sizeof(T);
|
|
}
|
|
private:
|
|
u8 *buffer;
|
|
int offset;
|
|
};
|