mirror of
https://github.com/RPCS3/rpcs3.git
synced 2025-04-20 03:25:16 +00:00
Merge pull request #212 from unknownbrackets/perf
Improve memory access performance a little
This commit is contained in:
Hykem
commit
82e47a5c53
4 changed files with 108 additions and 79 deletions
|
|
@ -3,7 +3,9 @@
|
|||
|
||||
u8 PPCDecoder::DecodeMemory(const u64 address)
|
||||
{
|
||||
Decode(Memory.Read32(address));
|
||||
u32 instr;
|
||||
Memory.Read32ByAddr(address, &instr);
|
||||
Decode(instr);
|
||||
|
||||
return 4;
|
||||
}
|
||||
|
|
@ -90,32 +90,17 @@ bool MemoryBlock::IsMyAddress(const u64 addr)
|
|||
return mem && addr >= GetStartAddr() && addr < GetEndAddr();
|
||||
}
|
||||
|
||||
__forceinline const u8 MemoryBlock::FastRead8(const u64 addr) const
|
||||
template <typename T>
|
||||
__forceinline const T MemoryBlock::FastRead(const u64 addr) const
|
||||
{
|
||||
return *GetMem(addr);
|
||||
}
|
||||
|
||||
__forceinline const u16 MemoryBlock::FastRead16(const u64 addr) const
|
||||
{
|
||||
volatile const u16 data = *(u16*)GetMem(addr);
|
||||
volatile const T data = *(const T *)GetMem(addr);
|
||||
return re(data);
|
||||
}
|
||||
|
||||
__forceinline const u32 MemoryBlock::FastRead32(const u64 addr) const
|
||||
template <>
|
||||
__forceinline const u128 MemoryBlock::FastRead<u128>(const u64 addr) const
|
||||
{
|
||||
volatile const u32 data = *(u32*)GetMem(addr);
|
||||
return re(data);
|
||||
}
|
||||
|
||||
__forceinline const u64 MemoryBlock::FastRead64(const u64 addr) const
|
||||
{
|
||||
volatile const u64 data = *(u64*)GetMem(addr);
|
||||
return re(data);
|
||||
}
|
||||
|
||||
__forceinline const u128 MemoryBlock::FastRead128(const u64 addr)
|
||||
{
|
||||
volatile const u128 data = *(u128*)GetMem(addr);
|
||||
volatile const u128 data = *(const u128 *)GetMem(addr);
|
||||
u128 ret;
|
||||
ret.lo = re(data.hi);
|
||||
ret.hi = re(data.lo);
|
||||
|
|
@ -131,7 +116,7 @@ bool MemoryBlock::Read8(const u64 addr, u8* value)
|
|||
}
|
||||
|
||||
//*value = std::atomic_load((volatile std::atomic<u8>*)GetMem(FixAddr(addr)));
|
||||
*value = FastRead8(FixAddr(addr));
|
||||
*value = FastRead<u8>(FixAddr(addr));
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -144,7 +129,7 @@ bool MemoryBlock::Read16(const u64 addr, u16* value)
|
|||
}
|
||||
|
||||
//se_t<u16>::func(*value, std::atomic_load((volatile std::atomic<u16>*)GetMem(FixAddr(addr))));
|
||||
*value = FastRead16(FixAddr(addr));
|
||||
*value = FastRead<u16>(FixAddr(addr));
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -157,7 +142,7 @@ bool MemoryBlock::Read32(const u64 addr, u32* value)
|
|||
}
|
||||
|
||||
//se_t<u32>::func(*value, std::atomic_load((volatile std::atomic<u32>*)GetMem(FixAddr(addr))));
|
||||
*value = FastRead32(FixAddr(addr));
|
||||
*value = FastRead<u32>(FixAddr(addr));
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -170,7 +155,7 @@ bool MemoryBlock::Read64(const u64 addr, u64* value)
|
|||
}
|
||||
|
||||
//se_t<u64>::func(*value, std::atomic_load((volatile std::atomic<u64>*)GetMem(FixAddr(addr))));
|
||||
*value = FastRead64(FixAddr(addr));
|
||||
*value = FastRead<u64>(FixAddr(addr));
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -185,31 +170,18 @@ bool MemoryBlock::Read128(const u64 addr, u128* value)
|
|||
//u64 f_addr = FixAddr(addr);
|
||||
//se_t<u64>::func(value->lo, std::atomic_load((volatile std::atomic<u64>*)GetMem(f_addr)));
|
||||
//se_t<u64>::func(value->hi, std::atomic_load((volatile std::atomic<u64>*)GetMem(f_addr + 8)));
|
||||
*value = FastRead128(FixAddr(addr));
|
||||
*value = FastRead<u128>(FixAddr(addr));
|
||||
return true;
|
||||
}
|
||||
|
||||
__forceinline void MemoryBlock::FastWrite8(const u64 addr, const u8 value)
|
||||
template <typename T>
|
||||
__forceinline void MemoryBlock::FastWrite(const u64 addr, const T value)
|
||||
{
|
||||
*GetMem(addr) = value;
|
||||
*(T *)GetMem(addr) = re(value);
|
||||
}
|
||||
|
||||
__forceinline void MemoryBlock::FastWrite16(const u64 addr, const u16 value)
|
||||
{
|
||||
*(u16*)GetMem(addr) = re(value);
|
||||
}
|
||||
|
||||
__forceinline void MemoryBlock::FastWrite32(const u64 addr, const u32 value)
|
||||
{
|
||||
*(u32*)GetMem(addr) = re(value);
|
||||
}
|
||||
|
||||
__forceinline void MemoryBlock::FastWrite64(const u64 addr, const u64 value)
|
||||
{
|
||||
*(u64*)GetMem(addr) = re(value);
|
||||
}
|
||||
|
||||
__forceinline void MemoryBlock::FastWrite128(const u64 addr, const u128 value)
|
||||
template <>
|
||||
__forceinline void MemoryBlock::FastWrite<u128>(const u64 addr, const u128 value)
|
||||
{
|
||||
u128 res;
|
||||
res.lo = re(value.hi);
|
||||
|
|
@ -222,7 +194,7 @@ bool MemoryBlock::Write8(const u64 addr, const u8 value)
|
|||
if(!IsMyAddress(addr) || IsLocked(addr)) return false;
|
||||
|
||||
//std::atomic_store((std::atomic<u8>*)GetMem(FixAddr(addr)), value);
|
||||
FastWrite8(FixAddr(addr), value);
|
||||
FastWrite<u8>(FixAddr(addr), value);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -233,7 +205,7 @@ bool MemoryBlock::Write16(const u64 addr, const u16 value)
|
|||
//u16 re_value;
|
||||
//se_t<u16>::func(re_value, value);
|
||||
//std::atomic_store((std::atomic<u16>*)GetMem(FixAddr(addr)), re_value);
|
||||
FastWrite16(FixAddr(addr), value);
|
||||
FastWrite<u16>(FixAddr(addr), value);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -244,7 +216,7 @@ bool MemoryBlock::Write32(const u64 addr, const u32 value)
|
|||
//u32 re_value;
|
||||
//se_t<u32>::func(re_value, value);
|
||||
//std::atomic_store((std::atomic<u32>*)GetMem(FixAddr(addr)), re_value);
|
||||
FastWrite32(FixAddr(addr), value);
|
||||
FastWrite<u32>(FixAddr(addr), value);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -255,7 +227,7 @@ bool MemoryBlock::Write64(const u64 addr, const u64 value)
|
|||
//u64 re_value;
|
||||
//se_t<u64>::func(re_value, value);
|
||||
//std::atomic_store((std::atomic<u64>*)GetMem(FixAddr(addr)), re_value);
|
||||
FastWrite64(FixAddr(addr), value);
|
||||
FastWrite<u64>(FixAddr(addr), value);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -269,7 +241,7 @@ bool MemoryBlock::Write128(const u64 addr, const u128 value)
|
|||
//std::atomic_store((std::atomic<u64>*)GetMem(f_addr), re_value);
|
||||
//se_t<u64>::func(re_value, value.hi);
|
||||
//std::atomic_store((std::atomic<u64>*)GetMem(f_addr + 8), re_value);
|
||||
FastWrite128(FixAddr(addr), value);
|
||||
FastWrite<u128>(FixAddr(addr), value);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -498,35 +470,35 @@ bool MemoryBase::Write128NN(u64 addr, const u128 data)
|
|||
u8 MemoryBase::Read8(u64 addr)
|
||||
{
|
||||
u8 res;
|
||||
GetMemByAddr(addr).Read8(addr, &res);
|
||||
Read8ByAddr(addr, &res);
|
||||
return res;
|
||||
}
|
||||
|
||||
u16 MemoryBase::Read16(u64 addr)
|
||||
{
|
||||
u16 res;
|
||||
GetMemByAddr(addr).Read16(addr, &res);
|
||||
Read16ByAddr(addr, &res);
|
||||
return res;
|
||||
}
|
||||
|
||||
u32 MemoryBase::Read32(u64 addr)
|
||||
{
|
||||
u32 res;
|
||||
GetMemByAddr(addr).Read32(addr, &res);
|
||||
Read32ByAddr(addr, &res);
|
||||
return res;
|
||||
}
|
||||
|
||||
u64 MemoryBase::Read64(u64 addr)
|
||||
{
|
||||
u64 res;
|
||||
GetMemByAddr(addr).Read64(addr, &res);
|
||||
Read64ByAddr(addr, &res);
|
||||
return res;
|
||||
}
|
||||
|
||||
u128 MemoryBase::Read128(u64 addr)
|
||||
{
|
||||
u128 res;
|
||||
GetMemByAddr(addr).Read128(addr, &res);
|
||||
Read128ByAddr(addr, &res);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
|
@ -655,9 +627,11 @@ bool VirtualMemoryBlock::Read16(const u64 addr, u16* value)
|
|||
|
||||
bool VirtualMemoryBlock::Read32(const u64 addr, u32* value)
|
||||
{
|
||||
u64 realAddr;
|
||||
*value = Memory.Read32(realAddr = getRealAddr(addr));
|
||||
return realAddr != 0;
|
||||
u64 realAddr = getRealAddr(addr);
|
||||
if (realAddr == 0)
|
||||
return false;
|
||||
*value = Memory.Read32(realAddr);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool VirtualMemoryBlock::Read64(const u64 addr, u64* value)
|
||||
|
|
|
|||
|
|
@ -105,14 +105,70 @@ public:
|
|||
|
||||
MemoryBlock& GetMemByAddr(const u64 addr)
|
||||
{
|
||||
for(uint i=0; i<MemoryBlocks.size(); ++i)
|
||||
for (auto block : MemoryBlocks)
|
||||
{
|
||||
if(MemoryBlocks[i]->IsMyAddress(addr)) return *MemoryBlocks[i];
|
||||
if (block->IsMyAddress(addr))
|
||||
return *block;
|
||||
}
|
||||
|
||||
return NullMem;
|
||||
}
|
||||
|
||||
bool Read8ByAddr(const u64 addr, u8 *value)
|
||||
{
|
||||
for (auto block : MemoryBlocks)
|
||||
{
|
||||
if (block->Read8(addr, value))
|
||||
return true;
|
||||
}
|
||||
|
||||
return NullMem.Read8(addr, value);
|
||||
}
|
||||
|
||||
bool Read16ByAddr(const u64 addr, u16 *value)
|
||||
{
|
||||
for (auto block : MemoryBlocks)
|
||||
{
|
||||
if (block->Read16(addr, value))
|
||||
return true;
|
||||
}
|
||||
|
||||
return NullMem.Read16(addr, value);
|
||||
}
|
||||
|
||||
bool Read32ByAddr(const u64 addr, u32 *value)
|
||||
{
|
||||
for (auto block : MemoryBlocks)
|
||||
{
|
||||
if (block->Read32(addr, value))
|
||||
return true;
|
||||
}
|
||||
|
||||
return NullMem.Read32(addr, value);
|
||||
}
|
||||
|
||||
bool Read64ByAddr(const u64 addr, u64 *value)
|
||||
{
|
||||
for (auto block : MemoryBlocks)
|
||||
{
|
||||
if (block->Read64(addr, value))
|
||||
return true;
|
||||
}
|
||||
|
||||
return NullMem.Read64(addr, value);
|
||||
}
|
||||
|
||||
bool Read128ByAddr(const u64 addr, u128 *value)
|
||||
{
|
||||
for (auto block : MemoryBlocks)
|
||||
{
|
||||
if (block->Read128(addr, value))
|
||||
return true;
|
||||
}
|
||||
|
||||
return NullMem.Read128(addr, value);
|
||||
}
|
||||
|
||||
u8* GetMemFromAddr(const u64 addr)
|
||||
{
|
||||
return GetMemByAddr(addr).GetMemFromAddr(addr);
|
||||
|
|
@ -126,9 +182,9 @@ public:
|
|||
u64 RealToVirtualAddr(const void* addr)
|
||||
{
|
||||
const u64 raddr = (u64)addr;
|
||||
for(u32 i=0; i<MemoryBlocks.size(); ++i)
|
||||
for (auto block : MemoryBlocks)
|
||||
{
|
||||
MemoryBlock& b = *MemoryBlocks[i];
|
||||
MemoryBlock& b = *block;
|
||||
const u64 baddr = (u64)b.GetMem();
|
||||
|
||||
if(raddr >= baddr && raddr < baddr + b.GetSize())
|
||||
|
|
@ -188,9 +244,10 @@ public:
|
|||
|
||||
bool IsGoodAddr(const u64 addr)
|
||||
{
|
||||
for(uint i=0; i<MemoryBlocks.size(); ++i)
|
||||
for (auto block : MemoryBlocks)
|
||||
{
|
||||
if(MemoryBlocks[i]->IsMyAddress(addr)) return true;
|
||||
if (block->IsMyAddress(addr))
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
|
|
@ -198,10 +255,11 @@ public:
|
|||
|
||||
bool IsGoodAddr(const u64 addr, const u32 size)
|
||||
{
|
||||
for(uint i=0; i<MemoryBlocks.size(); ++i)
|
||||
const u64 end = addr + size - 1;
|
||||
for (auto block : MemoryBlocks)
|
||||
{
|
||||
if( MemoryBlocks[i]->IsMyAddress(addr) &&
|
||||
MemoryBlocks[i]->IsMyAddress(addr + size - 1) ) return true;
|
||||
if (block->IsMyAddress(addr) && block->IsMyAddress(end))
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
|
|
@ -214,9 +272,9 @@ public:
|
|||
|
||||
ConLog.Write("Closing memory...");
|
||||
|
||||
for(uint i=0; i<MemoryBlocks.size(); ++i)
|
||||
for (auto block : MemoryBlocks)
|
||||
{
|
||||
MemoryBlocks[i]->Delete();
|
||||
block->Delete();
|
||||
}
|
||||
|
||||
MemoryBlocks.clear();
|
||||
|
|
|
|||
|
|
@ -105,11 +105,8 @@ public:
|
|||
virtual bool IsMyAddress(const u64 addr);
|
||||
virtual bool IsLocked(const u64 addr) { return false; }
|
||||
|
||||
__forceinline const u8 FastRead8(const u64 addr) const;
|
||||
__forceinline const u16 FastRead16(const u64 addr) const;
|
||||
__forceinline const u32 FastRead32(const u64 addr) const;
|
||||
__forceinline const u64 FastRead64(const u64 addr) const;
|
||||
__forceinline const u128 FastRead128(const u64 addr);
|
||||
template <typename T>
|
||||
__forceinline const T FastRead(const u64 addr) const;
|
||||
|
||||
virtual bool Read8(const u64 addr, u8* value);
|
||||
virtual bool Read16(const u64 addr, u16* value);
|
||||
|
|
@ -117,11 +114,8 @@ public:
|
|||
virtual bool Read64(const u64 addr, u64* value);
|
||||
virtual bool Read128(const u64 addr, u128* value);
|
||||
|
||||
__forceinline void FastWrite8(const u64 addr, const u8 value);
|
||||
__forceinline void FastWrite16(const u64 addr, const u16 value);
|
||||
__forceinline void FastWrite32(const u64 addr, const u32 value);
|
||||
__forceinline void FastWrite64(const u64 addr, const u64 value);
|
||||
__forceinline void FastWrite128(const u64 addr, const u128 value);
|
||||
template <typename T>
|
||||
__forceinline void FastWrite(const u64 addr, const T value);
|
||||
|
||||
virtual bool Write8(const u64 addr, const u8 value);
|
||||
virtual bool Write16(const u64 addr, const u16 value);
|
||||
|
|
@ -187,6 +181,7 @@ public:
|
|||
|
||||
class NullMemoryBlock : public MemoryBlock
|
||||
{
|
||||
public:
|
||||
virtual bool IsNULL() { return true; }
|
||||
virtual bool IsMyAddress(const u64 addr) { return true; }
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue