piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2024-11-14 21:37:52 -07:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #4104 from degasus/master

Browse Source 
PixelEngine: Cleanup PE Token.
This commit is contained in:
Markus Wick 2016-08-10 13:36:34 +02:00 committed by GitHub
commit 0fecd2f6b0
5 changed files with 77 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/Core/Core/State.cpp
View File

@ -70,7 +70,7 @@ static Common::Event g_compressAndDumpStateSyncEvent;
static std::thread g_save_thread; static std::thread g_save_thread;
// Don't forget to increase this after doing changes on the savestate system // Don't forget to increase this after doing changes on the savestate system
static const u32 STATE_VERSION = 54; // Last changed in PR 3782 static const u32 STATE_VERSION = 55;
// Maps savestate versions to Dolphin versions. // Maps savestate versions to Dolphin versions.
// Versions after 42 don't need to be added to this list, // Versions after 42 don't need to be added to this list,

16
Source/Core/VideoCommon/CommandProcessor.cpp
View File

@ -38,8 +38,6 @@ static u16 m_tokenReg;
static std::atomic<bool> s_interrupt_set; static std::atomic<bool> s_interrupt_set;
static std::atomic<bool> s_interrupt_waiting; static std::atomic<bool> s_interrupt_waiting;
static std::atomic<bool> s_interrupt_token_waiting;
static std::atomic<bool> s_interrupt_finish_waiting;
static bool IsOnThread() static bool IsOnThread()
{ {
@ -65,8 +63,6 @@ void DoState(PointerWrap& p)
p.Do(s_interrupt_set); p.Do(s_interrupt_set);
p.Do(s_interrupt_waiting); p.Do(s_interrupt_waiting);
p.Do(s_interrupt_token_waiting);
p.Do(s_interrupt_finish_waiting);
} }
static inline void WriteLow(volatile u32& _reg, u16 lowbits) static inline void WriteLow(volatile u32& _reg, u16 lowbits)
@ -112,8 +108,6 @@ void Init()
s_interrupt_set.store(false); s_interrupt_set.store(false);
s_interrupt_waiting.store(false); s_interrupt_waiting.store(false);
s_interrupt_finish_waiting.store(false);
s_interrupt_token_waiting.store(false);
et_UpdateInterrupts = CoreTiming::RegisterEvent("CPInterrupt", UpdateInterrupts_Wrapper); et_UpdateInterrupts = CoreTiming::RegisterEvent("CPInterrupt", UpdateInterrupts_Wrapper);
} }
@ -356,16 +350,6 @@ bool IsInterruptWaiting()
return s_interrupt_waiting.load(); return s_interrupt_waiting.load();
} }
void SetInterruptTokenWaiting(bool waiting)
{
s_interrupt_token_waiting.store(waiting);
}
void SetInterruptFinishWaiting(bool waiting)
{
s_interrupt_finish_waiting.store(waiting);
}
void SetCPStatusFromGPU() void SetCPStatusFromGPU()
{ {
// breakpoint // breakpoint

141
Source/Core/VideoCommon/PixelEngine.cpp
View File

@ -4,9 +4,8 @@
// http://www.nvidia.com/object/General_FAQ.html#t6 !!!!! // http://www.nvidia.com/object/General_FAQ.html#t6 !!!!!
#include <atomic> #include <mutex>
#include "Common/Atomic.h"
#include "Common/ChunkFile.h" #include "Common/ChunkFile.h"
#include "Common/CommonTypes.h" #include "Common/CommonTypes.h"
#include "Common/Logging/Log.h" #include "Common/Logging/Log.h"
@ -90,13 +89,18 @@ static UPEDstAlphaConfReg m_DstAlphaConf;
static UPEAlphaModeConfReg m_AlphaModeConf; static UPEAlphaModeConfReg m_AlphaModeConf;
static UPEAlphaReadReg m_AlphaRead; static UPEAlphaReadReg m_AlphaRead;
static UPECtrlReg m_Control; static UPECtrlReg m_Control;
// static u16 m_Token; // token value most recently encountered
static std::atomic<u32> s_signal_token_interrupt; std::mutex s_token_finish_mutex;
static std::atomic<u32> s_signal_finish_interrupt; static u16 s_token;
static u16 s_token_pending;
static bool s_token_interrupt_pending;
static bool s_finish_interrupt_pending;
static bool s_event_raised;
static int et_SetTokenOnMainThread; static bool s_signal_token_interrupt;
static int et_SetFinishOnMainThread; static bool s_signal_finish_interrupt;
static int et_SetTokenFinishOnMainThread;
enum enum
{ {
@ -113,15 +117,18 @@ void DoState(PointerWrap& p)
p.Do(m_AlphaRead); p.Do(m_AlphaRead);
p.DoPOD(m_Control); p.DoPOD(m_Control);
p.Do(s_token);
p.Do(s_token_pending);
p.Do(s_token_interrupt_pending);
p.Do(s_finish_interrupt_pending);
p.Do(s_event_raised);
p.Do(s_signal_token_interrupt); p.Do(s_signal_token_interrupt);
p.Do(s_signal_finish_interrupt); p.Do(s_signal_finish_interrupt);
} }
static void UpdateInterrupts(); static void UpdateInterrupts();
static void UpdateTokenInterrupt(bool active); static void SetTokenFinish_OnMainThread(u64 userdata, s64 cyclesLate);
static void UpdateFinishInterrupt(bool active);
static void SetToken_OnMainThread(u64 userdata, s64 cyclesLate);
static void SetFinish_OnMainThread(u64 userdata, s64 cyclesLate);
void Init() void Init()
{ {
@ -132,11 +139,16 @@ void Init()
m_AlphaModeConf.Hex = 0; m_AlphaModeConf.Hex = 0;
m_AlphaRead.Hex = 0; m_AlphaRead.Hex = 0;
s_signal_token_interrupt.store(0); s_token = 0;
s_signal_finish_interrupt.store(0); s_token_pending = 0;
s_token_interrupt_pending = false;
s_finish_interrupt_pending = false;
s_event_raised = false;
et_SetTokenOnMainThread = CoreTiming::RegisterEvent("SetToken", SetToken_OnMainThread); s_signal_token_interrupt = false;
et_SetFinishOnMainThread = CoreTiming::RegisterEvent("SetFinish", SetFinish_OnMainThread); s_signal_finish_interrupt = false;
et_SetTokenFinishOnMainThread = CoreTiming::RegisterEvent("SetTokenFinish", SetTokenFinish_OnMainThread);
} }
void RegisterMMIO(MMIO::Mapping* mmio, u32 base) void RegisterMMIO(MMIO::Mapping* mmio, u32 base)
@ -191,10 +203,10 @@ void RegisterMMIO(MMIO::Mapping* mmio, u32 base)
UPECtrlReg tmpCtrl(val); UPECtrlReg tmpCtrl(val);
if (tmpCtrl.PEToken) if (tmpCtrl.PEToken)
s_signal_token_interrupt.store(0); s_signal_token_interrupt = false;
if (tmpCtrl.PEFinish) if (tmpCtrl.PEFinish)
s_signal_finish_interrupt.store(0); s_signal_finish_interrupt = false;
m_Control.PETokenEnable = tmpCtrl.PETokenEnable; m_Control.PETokenEnable = tmpCtrl.PETokenEnable;
m_Control.PEFinishEnable = tmpCtrl.PEFinishEnable; m_Control.PEFinishEnable = tmpCtrl.PEFinishEnable;
@ -206,7 +218,8 @@ void RegisterMMIO(MMIO::Mapping* mmio, u32 base)
})); }));
// Token register, readonly. // Token register, readonly.
mmio->Register(base | PE_TOKEN_REG, MMIO::DirectRead<u16>(&CommandProcessor::fifo.PEToken), mmio->Register(base | PE_TOKEN_REG,
MMIO::ComplexRead<u16>([](u32) { return s_token; }),
MMIO::InvalidWrite<u16>()); MMIO::InvalidWrite<u16>());
// BBOX registers, readonly and need to update a flag. // BBOX registers, readonly and need to update a flag.
@ -223,82 +236,78 @@ void RegisterMMIO(MMIO::Mapping* mmio, u32 base)
static void UpdateInterrupts() static void UpdateInterrupts()
{ {
// check if there is a token-interrupt // check if there is a token-interrupt
UpdateTokenInterrupt((s_signal_token_interrupt.load() & m_Control.PETokenEnable) != 0); ProcessorInterface::SetInterrupt(INT_CAUSE_PE_TOKEN,
s_signal_token_interrupt && m_Control.PETokenEnable);
// check if there is a finish-interrupt // check if there is a finish-interrupt
UpdateFinishInterrupt((s_signal_finish_interrupt.load() & m_Control.PEFinishEnable) != 0); ProcessorInterface::SetInterrupt(INT_CAUSE_PE_FINISH,
s_signal_finish_interrupt && m_Control.PEFinishEnable);
} }
static void UpdateTokenInterrupt(bool active) static void SetTokenFinish_OnMainThread(u64 userdata, s64 cyclesLate)
{ {
ProcessorInterface::SetInterrupt(INT_CAUSE_PE_TOKEN, active); std::unique_lock<std::mutex> lk(s_token_finish_mutex);
} s_event_raised = false;
static void UpdateFinishInterrupt(bool active) s_token = s_token_pending;
{
ProcessorInterface::SetInterrupt(INT_CAUSE_PE_FINISH, active);
}
// TODO(mb2): Refactor SetTokenINT_OnMainThread(u64 userdata, int cyclesLate). if (s_token_interrupt_pending)
// Think about the right order between tokenVal and tokenINT... one day maybe.
// Cleanup++
// Called only if BPMEM_PE_TOKEN_INT_ID is ack by GP
static void SetToken_OnMainThread(u64 userdata, s64 cyclesLate)
{
// XXX: No 16-bit atomic store available, so cheat and use 32-bit.
// That's what we've always done. We're counting on fifo.PEToken to be
// 4-byte padded.
Common::AtomicStore(*(volatile u32*)&CommandProcessor::fifo.PEToken, userdata & 0xffff);
INFO_LOG(PIXELENGINE, "VIDEO Backend raises INT_CAUSE_PE_TOKEN (btw, token: %04x)",
CommandProcessor::fifo.PEToken);
if (userdata >> 16)
{ {
s_signal_token_interrupt.store(1); s_token_interrupt_pending = false;
s_signal_token_interrupt = true;
UpdateInterrupts(); UpdateInterrupts();
} }
CommandProcessor::SetInterruptTokenWaiting(false);
if (s_finish_interrupt_pending)
{
s_finish_interrupt_pending = false;
s_signal_finish_interrupt = true;
UpdateInterrupts();
lk.unlock();
Core::FrameUpdateOnCPUThread();
}
} }
static void SetFinish_OnMainThread(u64 userdata, s64 cyclesLate) // Raise the event handler above on the CPU thread.
// s_token_finish_mutex must be locked.
// THIS IS EXECUTED FROM VIDEO THREAD
static void RaiseEvent()
{ {
s_signal_finish_interrupt.store(1); if (s_event_raised)
UpdateInterrupts(); return;
CommandProcessor::SetInterruptFinishWaiting(false);
Core::FrameUpdateOnCPUThread(); s_event_raised = true;
if (!SConfig::GetInstance().bCPUThread || Fifo::UseDeterministicGPUThread())
CoreTiming::ScheduleEvent(0, et_SetTokenFinishOnMainThread, 0);
else
CoreTiming::ScheduleEvent_Threadsafe(0, et_SetTokenFinishOnMainThread, 0);
} }
// SetToken // SetToken
// THIS IS EXECUTED FROM VIDEO THREAD // THIS IS EXECUTED FROM VIDEO THREAD
void SetToken(const u16 _token, const int _bSetTokenAcknowledge) void SetToken(const u16 token, const bool interrupt)
{ {
if (_bSetTokenAcknowledge) // set token INT INFO_LOG(PIXELENGINE, "VIDEO Backend raises INT_CAUSE_PE_TOKEN (btw, token: %04x)", token);
{
s_signal_token_interrupt.store(1);
}
CommandProcessor::SetInterruptTokenWaiting(true); std::lock_guard<std::mutex> lk(s_token_finish_mutex);
if (!SConfig::GetInstance().bCPUThread || Fifo::UseDeterministicGPUThread()) s_token_pending = token;
CoreTiming::ScheduleEvent(0, et_SetTokenOnMainThread, _token | (_bSetTokenAcknowledge << 16)); s_token_interrupt_pending |= interrupt;
else
CoreTiming::ScheduleEvent_Threadsafe(0, et_SetTokenOnMainThread, RaiseEvent();
_token | (_bSetTokenAcknowledge << 16));
} }
// SetFinish // SetFinish
// THIS IS EXECUTED FROM VIDEO THREAD (BPStructs.cpp) when a new frame has been drawn // THIS IS EXECUTED FROM VIDEO THREAD (BPStructs.cpp) when a new frame has been drawn
void SetFinish() void SetFinish()
{ {
CommandProcessor::SetInterruptFinishWaiting(true);
if (!SConfig::GetInstance().bCPUThread || Fifo::UseDeterministicGPUThread())
CoreTiming::ScheduleEvent(0, et_SetFinishOnMainThread, 0);
else
CoreTiming::ScheduleEvent_Threadsafe(0, et_SetFinishOnMainThread, 0);
INFO_LOG(PIXELENGINE, "VIDEO Set Finish"); INFO_LOG(PIXELENGINE, "VIDEO Set Finish");
std::lock_guard<std::mutex> lk(s_token_finish_mutex);
s_finish_interrupt_pending |= true;
RaiseEvent();
} }
UPEAlphaReadReg GetAlphaReadMode() UPEAlphaReadReg GetAlphaReadMode()

2
Source/Core/VideoCommon/PixelEngine.h
View File

@ -61,7 +61,7 @@ void DoState(PointerWrap& p);
void RegisterMMIO(MMIO::Mapping* mmio, u32 base); void RegisterMMIO(MMIO::Mapping* mmio, u32 base);
// gfx backend support // gfx backend support
void SetToken(const u16 _token, const int _bSetTokenAcknowledge); void SetToken(const u16 token, const bool interrupt);
void SetFinish(); void SetFinish();
UPEAlphaReadReg GetAlphaReadMode(); UPEAlphaReadReg GetAlphaReadMode();

5
Source/Core/VideoCommon/VideoBackendBase.h
View File

@ -43,11 +43,6 @@ struct SCPFifoStruct
volatile u32 CPReadPointer; volatile u32 CPReadPointer;
volatile u32 CPBreakpoint; volatile u32 CPBreakpoint;
volatile u32 SafeCPReadPointer; volatile u32 SafeCPReadPointer;
// Super Monkey Ball Adventure require this.
// Because the read&check-PEToken-loop stays in its JITed block I suppose.
// So no possiblity to ack the Token irq by the scheduler until some sort of PPC watchdog do its
// mess.
volatile u16 PEToken;
volatile u32 bFF_GPLinkEnable; volatile u32 bFF_GPLinkEnable;
volatile u32 bFF_GPReadEnable; volatile u32 bFF_GPReadEnable;