The-Homebrew-Cloud/dolphin
2
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-02-13 07:49:19 +01:00
Code Issues Packages Projects Releases Wiki Activity

JitRegCache: Encapsulate behavior of X64CachedReg

Browse Source
This commit is contained in:
MerryMage 2018-09-30 13:14:00 +01:00
parent dd41bab365
commit ff0a6b8331
2 changed files with 62 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
Source/Core/Core/PowerPC/Jit64/JitRegCache.cpp
View File

@ -26,13 +26,7 @@ RegCache::RegCache(Jit64& jit) : m_jit{jit}
void RegCache::Start() void RegCache::Start()
{ {
for (auto& xreg : m_xregs) m_xregs.fill({});
{
xreg.free = true;
xreg.dirty = false;
xreg.locked = false;
xreg.ppcReg = static_cast<size_t>(INVALID_REG);
}
for (size_t i = 0; i < m_regs.size(); i++) for (size_t i = 0; i < m_regs.size(); i++)
{ {
m_regs[i] = PPCCachedReg{GetDefaultLocation(i)}; m_regs[i] = PPCCachedReg{GetDefaultLocation(i)};
@ -44,9 +38,7 @@ void RegCache::DiscardRegContentsIfCached(size_t preg)
if (m_regs[preg].IsBound()) if (m_regs[preg].IsBound())
{ {
X64Reg xr = m_regs[preg].Location().GetSimpleReg(); X64Reg xr = m_regs[preg].Location().GetSimpleReg();
m_xregs[xr].free = true; m_xregs[xr].Flushed();
m_xregs[xr].dirty = false;
m_xregs[xr].ppcReg = static_cast<size_t>(INVALID_REG);
m_regs[preg].Flushed(); m_regs[preg].Flushed();
} }
} }
@ -60,8 +52,10 @@ void RegCache::Flush(FlushMode mode, BitSet32 regsToFlush)
{ {
for (size_t i = 0; i < m_xregs.size(); i++) for (size_t i = 0; i < m_xregs.size(); i++)
{ {
if (m_xregs[i].locked) if (m_xregs[i].IsLocked())
{
PanicAlert("Someone forgot to unlock X64 reg %zu", i); PanicAlert("Someone forgot to unlock X64 reg %zu", i);
}
} }
for (unsigned int i : regsToFlush) for (unsigned int i : regsToFlush)
@ -93,9 +87,10 @@ void RegCache::FlushR(X64Reg reg)
{ {
if (reg >= m_xregs.size()) if (reg >= m_xregs.size())
PanicAlert("Flushing non existent reg"); PanicAlert("Flushing non existent reg");
if (!m_xregs[reg].free) ASSERT(!m_xregs[reg].IsLocked());
if (!m_xregs[reg].IsFree())
{ {
StoreFromRegister(m_xregs[reg].ppcReg); StoreFromRegister(m_xregs[reg].Contents());
} }
} }
@ -131,9 +126,9 @@ int RegCache::SanityCheck() const
case PPCCachedReg::LocationType::Bound: case PPCCachedReg::LocationType::Bound:
{ {
Gen::X64Reg simple = m_regs[i].Location().GetSimpleReg(); Gen::X64Reg simple = m_regs[i].Location().GetSimpleReg();
if (m_xregs[simple].locked) if (m_xregs[simple].IsLocked())
return 1; return 1;
if (m_xregs[simple].ppcReg != i) if (m_xregs[simple].Contents() != i)
return 2; return 2;
break; break;
} }
@ -152,7 +147,7 @@ void RegCache::KillImmediate(size_t preg, bool doLoad, bool makeDirty)
case PPCCachedReg::LocationType::SpeculativeImmediate: case PPCCachedReg::LocationType::SpeculativeImmediate:
break; break;
case PPCCachedReg::LocationType::Bound: case PPCCachedReg::LocationType::Bound:
m_xregs[RX(preg)].dirty |= makeDirty; m_xregs[RX(preg)].MakeDirty(makeDirty);
break; break;
case PPCCachedReg::LocationType::Immediate: case PPCCachedReg::LocationType::Immediate:
BindToRegister(preg, doLoad, makeDirty); BindToRegister(preg, doLoad, makeDirty);
@ -165,14 +160,11 @@ void RegCache::BindToRegister(size_t i, bool doLoad, bool makeDirty)
if (!m_regs[i].IsBound()) if (!m_regs[i].IsBound())
{ {
X64Reg xr = GetFreeXReg(); X64Reg xr = GetFreeXReg();
if (m_xregs[xr].dirty) if (m_xregs[xr].IsDirty())
PanicAlert("Xreg already dirty"); PanicAlert("Xreg already dirty");
if (m_xregs[xr].locked) if (m_xregs[xr].IsLocked())
PanicAlert("GetFreeXReg returned locked register"); PanicAlert("GetFreeXReg returned locked register");
m_xregs[xr].free = false; m_xregs[xr].BoundTo(i, makeDirty || m_regs[i].IsAway());
m_xregs[xr].ppcReg = i;
m_xregs[xr].dirty = makeDirty || m_regs[i].IsAway();
if (doLoad) if (doLoad)
LoadRegister(i, xr); LoadRegister(i, xr);
for (size_t j = 0; j < m_regs.size(); j++) for (size_t j = 0; j < m_regs.size(); j++)
@ -188,10 +180,10 @@ void RegCache::BindToRegister(size_t i, bool doLoad, bool makeDirty)
{ {
// reg location must be simplereg; memory locations // reg location must be simplereg; memory locations
// and immediates are taken care of above. // and immediates are taken care of above.
m_xregs[RX(i)].dirty |= makeDirty; m_xregs[RX(i)].MakeDirty(makeDirty);
} }
if (m_xregs[RX(i)].locked) if (m_xregs[RX(i)].IsLocked())
{ {
PanicAlert("Seriously WTF, this reg should have been flushed"); PanicAlert("Seriously WTF, this reg should have been flushed");
} }
@ -209,13 +201,9 @@ void RegCache::StoreFromRegister(size_t i, FlushMode mode)
case PPCCachedReg::LocationType::Bound: case PPCCachedReg::LocationType::Bound:
{ {
X64Reg xr = RX(i); X64Reg xr = RX(i);
doStore = m_xregs[xr].dirty; doStore = m_xregs[xr].IsDirty();
if (mode == FlushMode::All) if (mode == FlushMode::All)
{ m_xregs[xr].Flushed();
m_xregs[xr].free = true;
m_xregs[xr].ppcReg = static_cast<size_t>(INVALID_REG);
m_xregs[xr].dirty = false;
}
break; break;
} }
case PPCCachedReg::LocationType::Immediate: case PPCCachedReg::LocationType::Immediate:
@ -252,12 +240,12 @@ void RegCache::UnlockAll()
void RegCache::UnlockAllX() void RegCache::UnlockAllX()
{ {
for (auto& xreg : m_xregs) for (auto& xreg : m_xregs)
xreg.locked = false; xreg.Unlock();
} }
bool RegCache::IsFreeX(size_t xreg) const bool RegCache::IsFreeX(size_t xreg) const
{ {
return m_xregs[xreg].free && !m_xregs[xreg].locked; return m_xregs[xreg].IsFree();
} }
X64Reg RegCache::GetFreeXReg() X64Reg RegCache::GetFreeXReg()
@ -267,7 +255,7 @@ X64Reg RegCache::GetFreeXReg()
for (size_t i = 0; i < aCount; i++) for (size_t i = 0; i < aCount; i++)
{ {
X64Reg xr = aOrder[i]; X64Reg xr = aOrder[i];
if (!m_xregs[xr].locked && m_xregs[xr].free) if (m_xregs[xr].IsFree())
{ {
return xr; return xr;
} }
@ -281,8 +269,8 @@ X64Reg RegCache::GetFreeXReg()
for (size_t i = 0; i < aCount; i++) for (size_t i = 0; i < aCount; i++)
{ {
X64Reg xreg = (X64Reg)aOrder[i]; X64Reg xreg = (X64Reg)aOrder[i];
size_t preg = m_xregs[xreg].ppcReg; size_t preg = m_xregs[xreg].Contents();
if (m_xregs[xreg].locked || m_regs[preg].IsLocked()) if (m_xregs[xreg].IsLocked() || m_regs[preg].IsLocked())
continue; continue;
float score = ScoreRegister(xreg); float score = ScoreRegister(xreg);
if (score < min_score) if (score < min_score)
@ -310,7 +298,7 @@ int RegCache::NumFreeRegisters() const
size_t aCount; size_t aCount;
const X64Reg* aOrder = GetAllocationOrder(&aCount); const X64Reg* aOrder = GetAllocationOrder(&aCount);
for (size_t i = 0; i < aCount; i++) for (size_t i = 0; i < aCount; i++)
if (!m_xregs[aOrder[i]].locked && m_xregs[aOrder[i]].free) if (m_xregs[aOrder[i]].IsFree())
count++; count++;
return count; return count;
} }
@ -319,14 +307,14 @@ int RegCache::NumFreeRegisters() const
// means more bad. // means more bad.
float RegCache::ScoreRegister(X64Reg xreg) const float RegCache::ScoreRegister(X64Reg xreg) const
{ {
size_t preg = m_xregs[xreg].ppcReg; size_t preg = m_xregs[xreg].Contents();
float score = 0; float score = 0;
// If it's not dirty, we don't need a store to write it back to the register file, so // If it's not dirty, we don't need a store to write it back to the register file, so
// bias a bit against dirty registers. Testing shows that a bias of 2 seems roughly // bias a bit against dirty registers. Testing shows that a bias of 2 seems roughly
// right: 3 causes too many extra clobbers, while 1 saves very few clobbers relative // right: 3 causes too many extra clobbers, while 1 saves very few clobbers relative
// to the number of extra stores it causes. // to the number of extra stores it causes.
if (m_xregs[xreg].dirty) if (m_xregs[xreg].IsDirty())
score += 2; score += 2;
// If the register isn't actually needed in a physical register for a later instruction, // If the register isn't actually needed in a physical register for a later instruction,

45
Source/Core/Core/PowerPC/Jit64/JitRegCache.h
View File

@ -84,12 +84,39 @@ private:
bool locked = false; bool locked = false;
}; };
struct X64CachedReg class X64CachedReg
{ {
size_t ppcReg; public:
bool dirty; size_t Contents() const { return ppcReg; }
bool free;
bool locked; void BoundTo(size_t ppcReg_, bool dirty_)
{
free = false;
ppcReg = ppcReg_;
dirty = dirty_;
}
void Flushed()
{
ppcReg = static_cast<size_t>(Gen::INVALID_REG);
free = true;
dirty = false;
}
bool IsFree() const { return free && !locked; }
bool IsDirty() const { return dirty; }
void MakeDirty(bool makeDirty = true) { dirty |= makeDirty; }
bool IsLocked() const { return locked; }
void Lock() { locked = true; }
void Unlock() { locked = false; }
private:
size_t ppcReg = static_cast<size_t>(Gen::INVALID_REG);
bool free = true;
bool dirty = false;
bool locked = false;
}; };
class RegCache class RegCache
@ -153,9 +180,9 @@ public:
template <typename T> template <typename T>
void LockX(T x) void LockX(T x)
{ {
if (m_xregs[x].locked) if (m_xregs[x].IsLocked())
PanicAlert("RegCache: x %i already locked!", x); PanicAlert("RegCache: x %i already locked!", x);
m_xregs[x].locked = true; m_xregs[x].Lock();
} }
template <typename T, typename... Args> template <typename T, typename... Args>
void LockX(T first, Args... args) void LockX(T first, Args... args)
@ -167,9 +194,9 @@ public:
template <typename T> template <typename T>
void UnlockX(T x) void UnlockX(T x)
{ {
if (!m_xregs[x].locked) if (!m_xregs[x].IsLocked())
PanicAlert("RegCache: x %i already unlocked!", x); PanicAlert("RegCache: x %i already unlocked!", x);
m_xregs[x].locked = false; m_xregs[x].Unlock();
} }
template <typename T, typename... Args> template <typename T, typename... Args>
void UnlockX(T first, Args... args) void UnlockX(T first, Args... args)