From d6fa301ab1fd2e7c69ecc262062b09ebaf1fa688 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 15 Jan 2022 23:12:03 -0800 Subject: [PATCH 1/6] softgpu: Track CLUTs as states for binning. This way we can have multiple CLUTs in process at once, which helps. --- GPU/Software/BinManager.cpp | 14 ++++++++++++-- GPU/Software/BinManager.h | 9 ++++++++- GPU/Software/FuncId.cpp | 2 +- GPU/Software/FuncId.h | 7 +++++++ GPU/Software/Sampler.cpp | 10 ++++------ GPU/Software/SamplerX86.cpp | 10 ++++++---- GPU/Software/SoftGpu.cpp | 2 ++ GPU/Software/TransformUnit.cpp | 4 ++++ GPU/Software/TransformUnit.h | 1 + 9 files changed, 45 insertions(+), 14 deletions(-) diff --git a/GPU/Software/BinManager.cpp b/GPU/Software/BinManager.cpp index 36981c6e8f..80744e4069 100644 --- a/GPU/Software/BinManager.cpp +++ b/GPU/Software/BinManager.cpp @@ -86,7 +86,7 @@ static inline void DrawBinItem(const BinItem &item, const RasterizerState &state class DrawBinItemsTask : public Task { public: - DrawBinItemsTask(BinWaitable *notify, BinQueue &items, std::atomic &status, const BinQueue &states) + DrawBinItemsTask(BinWaitable *notify, BinQueue &items, std::atomic &status, const BinQueue &states) : notify_(notify), items_(items), status_(status), states_(states) { } @@ -114,7 +114,7 @@ private: BinWaitable *notify_; BinQueue &items_; std::atomic &status_; - const BinQueue &states_; + const BinQueue &states_; }; BinManager::BinManager() { @@ -137,6 +137,7 @@ void BinManager::UpdateState() { Flush(); stateIndex_ = (int)states_.Push(RasterizerState()); ComputeRasterizerState(&states_[stateIndex_]); + states_[stateIndex_].samplerID.cached.clut = cluts_[clutIndex_].readable; DrawingCoords scissorTL(gstate.getScissorX1(), gstate.getScissorY1()); DrawingCoords scissorBR(gstate.getScissorX2(), gstate.getScissorY2()); @@ -165,6 +166,13 @@ void BinManager::UpdateState() { } } +void BinManager::UpdateClut(void *src) { + if (cluts_.Full()) + Flush(); + clutIndex_ = (int)cluts_.Push(BinClut()); + memcpy(cluts_[clutIndex_].readable, src, sizeof(BinClut)); +} + void BinManager::AddTriangle(const VertexData &v0, const VertexData &v1, const VertexData &v2) { Vec2 d01((int)v0.screenpos.x - (int)v1.screenpos.x, (int)v0.screenpos.y - (int)v1.screenpos.y); Vec2 d02((int)v0.screenpos.x - (int)v2.screenpos.x, (int)v0.screenpos.y - (int)v2.screenpos.y); @@ -310,6 +318,8 @@ void BinManager::Flush() { queue_.Reset(); while (states_.Size() > 1) states_.SkipNext(); + while (cluts_.Size() > 1) + cluts_.SkipNext(); queueRange_.x1 = 0x7FFFFFFF; queueRange_.y1 = 0x7FFFFFFF; diff --git a/GPU/Software/BinManager.h b/GPU/Software/BinManager.h index 4d32ea0335..88a17c9075 100644 --- a/GPU/Software/BinManager.h +++ b/GPU/Software/BinManager.h @@ -143,12 +143,17 @@ struct BinQueue { std::atomic size_; }; +union BinClut { + uint8_t readable[1024]; +}; + class BinManager { public: BinManager(); ~BinManager(); void UpdateState(); + void UpdateClut(void *src); const Rasterizer::RasterizerState &State() { return states_[stateIndex_]; @@ -166,8 +171,10 @@ public: private: static constexpr int MAX_POSSIBLE_TASKS = 64; - BinQueue states_; + BinQueue states_; int stateIndex_; + BinQueue cluts_; + int clutIndex_; BinCoords scissor_; BinQueue queue_; BinCoords queueRange_; diff --git a/GPU/Software/FuncId.cpp b/GPU/Software/FuncId.cpp index c6c0d37c5d..d03195e7bf 100644 --- a/GPU/Software/FuncId.cpp +++ b/GPU/Software/FuncId.cpp @@ -22,7 +22,7 @@ #include "GPU/GPUState.h" #include "GPU/Software/FuncId.h" -static_assert(sizeof(SamplerID) == sizeof(SamplerID::fullKey) + sizeof(SamplerID::cached), "Bad sampler ID size"); +static_assert(sizeof(SamplerID) == sizeof(SamplerID::fullKey) + sizeof(SamplerID::cached) + sizeof(SamplerID::pad), "Bad sampler ID size"); static_assert(sizeof(PixelFuncID) == sizeof(PixelFuncID::fullKey) + sizeof(PixelFuncID::cached), "Bad pixel func ID size"); static inline GEComparison OptimizeRefByteCompare(GEComparison func, u8 ref) { diff --git a/GPU/Software/FuncId.h b/GPU/Software/FuncId.h index 22a531fe7b..0d18ac4a05 100644 --- a/GPU/Software/FuncId.h +++ b/GPU/Software/FuncId.h @@ -173,8 +173,15 @@ struct SamplerID { } sizes[8]; uint32_t texBlendColor; uint32_t clutFormat; + union { + uint8_t *clut; + uint16_t *clut16; + uint32_t *clut32; + }; } cached; + uint32_t pad; + union { uint32_t fullKey; struct { diff --git a/GPU/Software/Sampler.cpp b/GPU/Software/Sampler.cpp index 0ee39e61b8..387f039957 100644 --- a/GPU/Software/Sampler.cpp +++ b/GPU/Software/Sampler.cpp @@ -35,8 +35,6 @@ using namespace Math3D; using namespace Rasterizer; -extern u32 clut[4096]; - namespace Sampler { static Vec4IntResult SOFTRAST_CALL SampleNearest(float s, float t, int x, int y, Vec4IntArg prim_color, const u8 *const *tptr, const int *bufw, int level, int levelFrac, const SamplerID &samplerID); @@ -267,16 +265,16 @@ static inline u32 LookupColor(unsigned int index, unsigned int level, const Samp switch (samplerID.ClutFmt()) { case GE_CMODE_16BIT_BGR5650: - return RGB565ToRGBA8888(reinterpret_cast(clut)[index + clutSharingOffset]); + return RGB565ToRGBA8888(samplerID.cached.clut16[index + clutSharingOffset]); case GE_CMODE_16BIT_ABGR5551: - return RGBA5551ToRGBA8888(reinterpret_cast(clut)[index + clutSharingOffset]); + return RGBA5551ToRGBA8888(samplerID.cached.clut16[index + clutSharingOffset]); case GE_CMODE_16BIT_ABGR4444: - return RGBA4444ToRGBA8888(reinterpret_cast(clut)[index + clutSharingOffset]); + return RGBA4444ToRGBA8888(samplerID.cached.clut16[index + clutSharingOffset]); case GE_CMODE_32BIT_ABGR8888: - return clut[index + clutSharingOffset]; + return samplerID.cached.clut32[index + clutSharingOffset]; default: ERROR_LOG_REPORT(G3D, "Software: Unsupported palette format: %x", samplerID.ClutFmt()); diff --git a/GPU/Software/SamplerX86.cpp b/GPU/Software/SamplerX86.cpp index ebdbd8e11f..c1ca5c2ad0 100644 --- a/GPU/Software/SamplerX86.cpp +++ b/GPU/Software/SamplerX86.cpp @@ -29,8 +29,6 @@ using namespace Gen; using namespace Rasterizer; -extern u32 clut[4096]; - namespace Sampler { FetchFunc SamplerJitCache::CompileFetch(const SamplerID &id) { @@ -1253,8 +1251,10 @@ bool SamplerJitCache::Jit_ReadClutQuad(const SamplerID &id, bool level1) { regCache_.Release(vecLevelReg, RegCache::VEC_TEMP0); } + X64Reg idReg = GetSamplerID(); X64Reg clutBaseReg = regCache_.Alloc(RegCache::GEN_TEMP1); - MOV(PTRBITS, R(clutBaseReg), ImmPtr(clut)); + MOV(PTRBITS, R(clutBaseReg), MDisp(idReg, offsetof(SamplerID, cached.clut))); + UnlockSamplerID(idReg); X64Reg resultReg = regCache_.Find(level1 ? RegCache::VEC_RESULT1 : RegCache::VEC_RESULT); X64Reg maskReg = regCache_.Alloc(RegCache::VEC_TEMP0); @@ -3457,8 +3457,10 @@ bool SamplerJitCache::Jit_ReadClutColor(const SamplerID &id) { regCache_.Release(temp2Reg, RegCache::GEN_TEMP2); } + X64Reg idReg = GetSamplerID(); X64Reg temp1Reg = regCache_.Alloc(RegCache::GEN_TEMP1); - MOV(PTRBITS, R(temp1Reg), ImmPtr(clut)); + MOV(PTRBITS, R(temp1Reg), MDisp(idReg, offsetof(SamplerID, cached.clut))); + UnlockSamplerID(idReg); switch (id.ClutFmt()) { case GE_CMODE_16BIT_BGR5650: diff --git a/GPU/Software/SoftGpu.cpp b/GPU/Software/SoftGpu.cpp index d0e3fd378e..2e21e9dc07 100644 --- a/GPU/Software/SoftGpu.cpp +++ b/GPU/Software/SoftGpu.cpp @@ -617,6 +617,8 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { DEBUG_LOG(G3D, "Software: Invalid CLUT address, filling with garbage instead of crashing"); memset(clut, 0x00, clutTotalBytes); } + + drawEngine_->transformUnit.NotifyClutUpdate(clut); } break; diff --git a/GPU/Software/TransformUnit.cpp b/GPU/Software/TransformUnit.cpp index 47d8393c40..5d2a9a527a 100644 --- a/GPU/Software/TransformUnit.cpp +++ b/GPU/Software/TransformUnit.cpp @@ -613,6 +613,10 @@ void TransformUnit::Flush() { GPUDebug::NotifyDraw(); } +void TransformUnit::NotifyClutUpdate(void *src) { + binner_->UpdateClut(src); +} + // TODO: This probably is not the best interface. // Also, we should try to merge this into the similar function in DrawEngineCommon. bool TransformUnit::GetCurrentSimpleVertices(int count, std::vector &vertices, std::vector &indices) { diff --git a/GPU/Software/TransformUnit.h b/GPU/Software/TransformUnit.h index adb75c558e..8f8fcd72b2 100644 --- a/GPU/Software/TransformUnit.h +++ b/GPU/Software/TransformUnit.h @@ -120,6 +120,7 @@ public: bool GetCurrentSimpleVertices(int count, std::vector &vertices, std::vector &indices); void Flush(); + void NotifyClutUpdate(void *src); private: VertexData ReadVertex(VertexReader &vreader, bool &outside_range_flag); From 9466dc6397fd7ff9fa7b1df8537a09b736c5b8f9 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 16 Jan 2022 08:13:42 -0800 Subject: [PATCH 2/6] softgpu: Flush on offset changes. --- GPU/Software/BinManager.cpp | 12 +++++++++++- GPU/Software/BinManager.h | 2 ++ 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/GPU/Software/BinManager.cpp b/GPU/Software/BinManager.cpp index 80744e4069..e56f2553e2 100644 --- a/GPU/Software/BinManager.cpp +++ b/GPU/Software/BinManager.cpp @@ -160,9 +160,17 @@ void BinManager::UpdateState() { int newMaxTasks = selfRender ? 1 : g_threadManager.GetNumLooperThreads(); if (newMaxTasks > MAX_POSSIBLE_TASKS) newMaxTasks = MAX_POSSIBLE_TASKS; + // We don't want to overlap wrong, so flush any pending. if (maxTasks_ != newMaxTasks) { maxTasks_ = newMaxTasks; - tasksSplit_ = false; + Flush(); + } + + // Our bin sizes are based on offset, so if that changes we have to flush. + if (queueOffsetX_ != gstate.getOffsetX16() || queueOffsetY_ != gstate.getOffsetY16()) { + Flush(); + queueOffsetX_ = gstate.getOffsetX16(); + queueOffsetY_ = gstate.getOffsetY16(); } } @@ -325,6 +333,8 @@ void BinManager::Flush() { queueRange_.y1 = 0x7FFFFFFF; queueRange_.x2 = 0; queueRange_.y2 = 0; + queueOffsetX_ = -1; + queueOffsetY_ = -1; } inline BinCoords BinCoords::Intersect(const BinCoords &range) const { diff --git a/GPU/Software/BinManager.h b/GPU/Software/BinManager.h index 88a17c9075..138531bb81 100644 --- a/GPU/Software/BinManager.h +++ b/GPU/Software/BinManager.h @@ -178,6 +178,8 @@ private: BinCoords scissor_; BinQueue queue_; BinCoords queueRange_; + int queueOffsetX_ = -1; + int queueOffsetY_ = -1; int maxTasks_ = 1; bool tasksSplit_ = false; From cc155ec460b672bb82a414d1e44e5d18e9ebbe25 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 15 Jan 2022 23:24:58 -0800 Subject: [PATCH 3/6] softgpu: Avoid texture/CLUT flush unless overlap. Only need to flush here if there's some overlap in the target. --- GPU/Software/BinManager.cpp | 2 +- GPU/Software/BinManager.h | 2 +- GPU/Software/SoftGpu.cpp | 19 +++++++++++-------- GPU/Software/TransformUnit.cpp | 20 +++++++++++++++++++- GPU/Software/TransformUnit.h | 3 ++- 5 files changed, 34 insertions(+), 12 deletions(-) diff --git a/GPU/Software/BinManager.cpp b/GPU/Software/BinManager.cpp index e56f2553e2..cdb07f8bc9 100644 --- a/GPU/Software/BinManager.cpp +++ b/GPU/Software/BinManager.cpp @@ -174,7 +174,7 @@ void BinManager::UpdateState() { } } -void BinManager::UpdateClut(void *src) { +void BinManager::UpdateClut(const void *src) { if (cluts_.Full()) Flush(); clutIndex_ = (int)cluts_.Push(BinClut()); diff --git a/GPU/Software/BinManager.h b/GPU/Software/BinManager.h index 138531bb81..eff0c4e6c9 100644 --- a/GPU/Software/BinManager.h +++ b/GPU/Software/BinManager.h @@ -153,7 +153,7 @@ public: ~BinManager(); void UpdateState(); - void UpdateClut(void *src); + void UpdateClut(const void *src); const Rasterizer::RasterizerState &State() { return states_[stateIndex_]; diff --git a/GPU/Software/SoftGpu.cpp b/GPU/Software/SoftGpu.cpp index 2e21e9dc07..44401d8ba7 100644 --- a/GPU/Software/SoftGpu.cpp +++ b/GPU/Software/SoftGpu.cpp @@ -548,6 +548,10 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_SCISSOR1: case GE_CMD_SCISSOR2: + for (int i = 0; i < 8; ++i) { + // TODO: Narrow down the risk range, for now assuming 512x512 max texture. + drawEngine_->transformUnit.FlushIfOverlap(gstate.getTextureAddress(i), 4 * 512 * 512); + } break; case GE_CMD_MINZ: @@ -576,8 +580,8 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_TEXADDR5: case GE_CMD_TEXADDR6: case GE_CMD_TEXADDR7: - // TODO: Try not flushing here, unless overlap with framebuf/depthbuf? - drawEngine_->transformUnit.Flush(); + // TODO: Narrow down the risk range, for now assuming 512x512 max texture. + drawEngine_->transformUnit.FlushIfOverlap(gstate.getTextureAddress(cmd - GE_CMD_TEXADDR0), 4 * 512 * 512); break; case GE_CMD_TEXBUFWIDTH0: @@ -588,8 +592,8 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_TEXBUFWIDTH5: case GE_CMD_TEXBUFWIDTH6: case GE_CMD_TEXBUFWIDTH7: - // TODO: Try not flushing here, unless overlap with framebuf/depthbuf? - drawEngine_->transformUnit.Flush(); + // TODO: Narrow down the risk range, for now assuming 512x512 max texture. + drawEngine_->transformUnit.FlushIfOverlap(gstate.getTextureAddress(cmd - GE_CMD_TEXBUFWIDTH0), 4 * 512 * 512); break; case GE_CMD_CLUTADDR: @@ -598,13 +602,12 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_LOADCLUT: { - // Might be copying drawing into the CLUT, so flush. - // TODO: It seems worth copying the CLUT to state... - drawEngine_->transformUnit.Flush(); - u32 clutAddr = gstate.getClutAddress(); u32 clutTotalBytes = gstate.getClutLoadBytes(); + // Might be copying drawing into the CLUT, so flush. + drawEngine_->transformUnit.FlushIfOverlap(clutAddr, clutTotalBytes); + if (Memory::IsValidAddress(clutAddr)) { u32 validSize = Memory::ValidSize(clutAddr, clutTotalBytes); Memory::MemcpyUnchecked(clut, clutAddr, validSize); diff --git a/GPU/Software/TransformUnit.cpp b/GPU/Software/TransformUnit.cpp index 5d2a9a527a..c628a3c853 100644 --- a/GPU/Software/TransformUnit.cpp +++ b/GPU/Software/TransformUnit.cpp @@ -613,7 +613,25 @@ void TransformUnit::Flush() { GPUDebug::NotifyDraw(); } -void TransformUnit::NotifyClutUpdate(void *src) { +void TransformUnit::FlushIfOverlap(uint32_t addr, uint32_t sz) { + if (!Memory::IsVRAMAddress(addr)) + return; + addr &= 0x0FFFFFFF; + + uint32_t targetHeight = gstate.getScissorY2() + 1; + uint32_t target = gstate.getFrameBufAddress() & 0x0FFFFFFF; + uint32_t targetStride = gstate.FrameBufStride() * (gstate.FrameBufFormat() == GE_FORMAT_8888 ? 4 : 2); + uint32_t ztarget = gstate.getDepthBufAddress() & 0x0FFFFFFF; + uint32_t ztargetStride = gstate.DepthBufStride() * 2; + + // TODO: Skip if the texture is between width and stride? + if (addr < target + targetHeight * targetStride && addr + sz >= target) + Flush(); + else if (addr < ztarget + targetHeight * ztargetStride && addr + sz >= ztarget) + Flush(); +} + +void TransformUnit::NotifyClutUpdate(const void *src) { binner_->UpdateClut(src); } diff --git a/GPU/Software/TransformUnit.h b/GPU/Software/TransformUnit.h index 8f8fcd72b2..fe8f757d9a 100644 --- a/GPU/Software/TransformUnit.h +++ b/GPU/Software/TransformUnit.h @@ -120,7 +120,8 @@ public: bool GetCurrentSimpleVertices(int count, std::vector &vertices, std::vector &indices); void Flush(); - void NotifyClutUpdate(void *src); + void FlushIfOverlap(uint32_t addr, uint32_t sz); + void NotifyClutUpdate(const void *src); private: VertexData ReadVertex(VertexReader &vreader, bool &outside_range_flag); From 2de7993dc58243ba4889b02cb43786bf8814543b Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 15 Jan 2022 23:32:21 -0800 Subject: [PATCH 4/6] softgpu: Decorate some stats for flushes. --- GPU/Software/BinManager.cpp | 6 ++++++ GPU/Software/SoftGpu.cpp | 20 ++++++++++---------- GPU/Software/TransformUnit.cpp | 8 ++++---- GPU/Software/TransformUnit.h | 4 ++-- 4 files changed, 22 insertions(+), 16 deletions(-) diff --git a/GPU/Software/BinManager.cpp b/GPU/Software/BinManager.cpp index cdb07f8bc9..4d1233a617 100644 --- a/GPU/Software/BinManager.cpp +++ b/GPU/Software/BinManager.cpp @@ -18,6 +18,7 @@ #include #include #include +#include "Common/Profiler/Profiler.h" #include "Common/Thread/ThreadManager.h" #include "GPU/Software/BinManager.h" #include "GPU/Software/Rasterizer.h" @@ -133,6 +134,7 @@ BinManager::~BinManager() { } void BinManager::UpdateState() { + PROFILE_THIS_SCOPE("bin_state"); if (states_.Full()) Flush(); stateIndex_ = (int)states_.Push(RasterizerState()); @@ -175,6 +177,7 @@ void BinManager::UpdateState() { } void BinManager::UpdateClut(const void *src) { + PROFILE_THIS_SCOPE("bin_clut"); if (cluts_.Full()) Flush(); clutIndex_ = (int)cluts_.Push(BinClut()); @@ -249,6 +252,8 @@ void BinManager::AddPoint(const VertexData &v0) { } void BinManager::Drain() { + PROFILE_THIS_SCOPE("bin_drain"); + // If the waitable has fully drained, we can update our binning decisions. if (!tasksSplit_ || waitable_->Empty()) { int w2 = (queueRange_.x2 - queueRange_.x1 + 31) / 32; @@ -279,6 +284,7 @@ void BinManager::Drain() { } if (taskRanges_.size() <= 1) { + PROFILE_THIS_SCOPE("bin_drain_single"); while (!queue_.Empty()) { const BinItem &item = queue_.PeekNext(); DrawBinItem(item, states_[item.stateIndex]); diff --git a/GPU/Software/SoftGpu.cpp b/GPU/Software/SoftGpu.cpp index 44401d8ba7..0ae17137fd 100644 --- a/GPU/Software/SoftGpu.cpp +++ b/GPU/Software/SoftGpu.cpp @@ -550,7 +550,7 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_SCISSOR2: for (int i = 0; i < 8; ++i) { // TODO: Narrow down the risk range, for now assuming 512x512 max texture. - drawEngine_->transformUnit.FlushIfOverlap(gstate.getTextureAddress(i), 4 * 512 * 512); + drawEngine_->transformUnit.FlushIfOverlap("scissor", gstate.getTextureAddress(i), 4 * 512 * 512); } break; @@ -559,13 +559,13 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_FRAMEBUFPTR: // We assume fb.data won't change while we're drawing. - drawEngine_->transformUnit.Flush(); + drawEngine_->transformUnit.Flush("framebuf"); fb.data = Memory::GetPointer(gstate.getFrameBufAddress()); break; case GE_CMD_FRAMEBUFWIDTH: // We assume fb.data won't change while we're drawing. - drawEngine_->transformUnit.Flush(); + drawEngine_->transformUnit.Flush("framebuf"); fb.data = Memory::GetPointer(gstate.getFrameBufAddress()); break; @@ -581,7 +581,7 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_TEXADDR6: case GE_CMD_TEXADDR7: // TODO: Narrow down the risk range, for now assuming 512x512 max texture. - drawEngine_->transformUnit.FlushIfOverlap(gstate.getTextureAddress(cmd - GE_CMD_TEXADDR0), 4 * 512 * 512); + drawEngine_->transformUnit.FlushIfOverlap("texaddr", gstate.getTextureAddress(cmd - GE_CMD_TEXADDR0), 4 * 512 * 512); break; case GE_CMD_TEXBUFWIDTH0: @@ -593,7 +593,7 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_TEXBUFWIDTH6: case GE_CMD_TEXBUFWIDTH7: // TODO: Narrow down the risk range, for now assuming 512x512 max texture. - drawEngine_->transformUnit.FlushIfOverlap(gstate.getTextureAddress(cmd - GE_CMD_TEXBUFWIDTH0), 4 * 512 * 512); + drawEngine_->transformUnit.FlushIfOverlap("texbufw", gstate.getTextureAddress(cmd - GE_CMD_TEXBUFWIDTH0), 4 * 512 * 512); break; case GE_CMD_CLUTADDR: @@ -606,7 +606,7 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { u32 clutTotalBytes = gstate.getClutLoadBytes(); // Might be copying drawing into the CLUT, so flush. - drawEngine_->transformUnit.FlushIfOverlap(clutAddr, clutTotalBytes); + drawEngine_->transformUnit.FlushIfOverlap("loadclut", clutAddr, clutTotalBytes); if (Memory::IsValidAddress(clutAddr)) { u32 validSize = Memory::ValidSize(clutAddr, clutTotalBytes); @@ -638,7 +638,7 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_TRANSFERSTART: { // Let's finish any drawing before we transfer. - drawEngine_->transformUnit.Flush(); + drawEngine_->transformUnit.Flush("blockxfer"); u32 srcBasePtr = gstate.getTransferSrcAddress(); u32 srcStride = gstate.getTransferSrcStride(); @@ -691,13 +691,13 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_ZBUFPTR: // We assume depthbuf.data won't change while we're drawing. - drawEngine_->transformUnit.Flush(); + drawEngine_->transformUnit.Flush("depthbuf"); depthbuf.data = Memory::GetPointer(gstate.getDepthBufAddress()); break; case GE_CMD_ZBUFWIDTH: // We assume depthbuf.data won't change while we're drawing. - drawEngine_->transformUnit.Flush(); + drawEngine_->transformUnit.Flush("depthbuf"); depthbuf.data = Memory::GetPointer(gstate.getDepthBufAddress()); break; @@ -893,7 +893,7 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { void SoftGPU::FinishDeferred() { // Need to flush before going back to CPU, so drawing is appropriately visible. - drawEngine_->transformUnit.Flush(); + drawEngine_->transformUnit.Flush("finish"); } void SoftGPU::GetStats(char *buffer, size_t bufsize) { diff --git a/GPU/Software/TransformUnit.cpp b/GPU/Software/TransformUnit.cpp index c628a3c853..5736f37ddd 100644 --- a/GPU/Software/TransformUnit.cpp +++ b/GPU/Software/TransformUnit.cpp @@ -608,12 +608,12 @@ void TransformUnit::SubmitPrimitive(void* vertices, void* indices, GEPrimitiveTy } } -void TransformUnit::Flush() { +void TransformUnit::Flush(const char *reason) { binner_->Flush(); GPUDebug::NotifyDraw(); } -void TransformUnit::FlushIfOverlap(uint32_t addr, uint32_t sz) { +void TransformUnit::FlushIfOverlap(const char *reason, uint32_t addr, uint32_t sz) { if (!Memory::IsVRAMAddress(addr)) return; addr &= 0x0FFFFFFF; @@ -626,9 +626,9 @@ void TransformUnit::FlushIfOverlap(uint32_t addr, uint32_t sz) { // TODO: Skip if the texture is between width and stride? if (addr < target + targetHeight * targetStride && addr + sz >= target) - Flush(); + Flush(reason); else if (addr < ztarget + targetHeight * ztargetStride && addr + sz >= ztarget) - Flush(); + Flush(reason); } void TransformUnit::NotifyClutUpdate(const void *src) { diff --git a/GPU/Software/TransformUnit.h b/GPU/Software/TransformUnit.h index fe8f757d9a..79bd8bfbd5 100644 --- a/GPU/Software/TransformUnit.h +++ b/GPU/Software/TransformUnit.h @@ -119,8 +119,8 @@ public: bool GetCurrentSimpleVertices(int count, std::vector &vertices, std::vector &indices); - void Flush(); - void FlushIfOverlap(uint32_t addr, uint32_t sz); + void Flush(const char *reason); + void FlushIfOverlap(const char *reason, uint32_t addr, uint32_t sz); void NotifyClutUpdate(const void *src); private: From 86749a3fe034ff0c546a6c6f1b65ef1633bbcf0c Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 15 Jan 2022 23:36:58 -0800 Subject: [PATCH 5/6] softgpu: Flush block xfer only on overlap too. --- GPU/Software/SoftGpu.cpp | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/GPU/Software/SoftGpu.cpp b/GPU/Software/SoftGpu.cpp index 0ae17137fd..f48f7e6204 100644 --- a/GPU/Software/SoftGpu.cpp +++ b/GPU/Software/SoftGpu.cpp @@ -638,7 +638,6 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_TRANSFERSTART: { // Let's finish any drawing before we transfer. - drawEngine_->transformUnit.Flush("blockxfer"); u32 srcBasePtr = gstate.getTransferSrcAddress(); u32 srcStride = gstate.getTransferSrcStride(); @@ -657,19 +656,25 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { int bpp = gstate.getTransferBpp(); + const uint32_t src = srcBasePtr + (srcY * srcStride + srcX) * bpp; + const uint32_t srcSize = height * srcStride * bpp; + const uint32_t dst = srcBasePtr + (srcY * srcStride + srcX) * bpp; + const uint32_t dstSize = height * dstStride * bpp; + + drawEngine_->transformUnit.FlushIfOverlap("blockxfer", src, srcSize); + drawEngine_->transformUnit.FlushIfOverlap("blockxfer", dst, dstSize); + DEBUG_LOG(G3D, "Block transfer: %08x/%x -> %08x/%x, %ix%ix%i (%i,%i)->(%i,%i)", srcBasePtr, srcStride, dstBasePtr, dstStride, width, height, bpp, srcX, srcY, dstX, dstY); for (int y = 0; y < height; y++) { - const u8 *src = Memory::GetPointer(srcBasePtr + ((y + srcY) * srcStride + srcX) * bpp); - u8 *dst = Memory::GetPointer(dstBasePtr + ((y + dstY) * dstStride + dstX) * bpp); - memcpy(dst, src, width * bpp); + const u8 *srcp = Memory::GetPointer(srcBasePtr + ((y + srcY) * srcStride + srcX) * bpp); + u8 *dstp = Memory::GetPointer(dstBasePtr + ((y + dstY) * dstStride + dstX) * bpp); + memcpy(dstp, srcp, width * bpp); } - const uint32_t src = srcBasePtr + (srcY * srcStride + srcX) * bpp; - const uint32_t srcSize = height * srcStride * bpp; const std::string tag = "GPUBlockTransfer/" + GetMemWriteTagAt(src, srcSize); NotifyMemInfo(MemBlockFlags::READ, src, srcSize, tag.c_str(), tag.size()); - NotifyMemInfo(MemBlockFlags::WRITE, dstBasePtr + (dstY * dstStride + dstX) * bpp, height * dstStride * bpp, tag.c_str(), tag.size()); + NotifyMemInfo(MemBlockFlags::WRITE, dst, dstSize, tag.c_str(), tag.size()); // TODO: Correct timing appears to be 1.9, but erring a bit low since some of our other timing is inaccurate. cyclesExecuted += ((height * width * bpp) * 16) / 10; From 7e5f03eed16c5cb2cb895f968879abce578221a5 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 16 Jan 2022 08:21:15 -0800 Subject: [PATCH 6/6] softgpu: Reduce flushing for smaller textures. --- GPU/Software/SoftGpu.cpp | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/GPU/Software/SoftGpu.cpp b/GPU/Software/SoftGpu.cpp index f48f7e6204..7e786916ee 100644 --- a/GPU/Software/SoftGpu.cpp +++ b/GPU/Software/SoftGpu.cpp @@ -549,8 +549,7 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_SCISSOR1: case GE_CMD_SCISSOR2: for (int i = 0; i < 8; ++i) { - // TODO: Narrow down the risk range, for now assuming 512x512 max texture. - drawEngine_->transformUnit.FlushIfOverlap("scissor", gstate.getTextureAddress(i), 4 * 512 * 512); + drawEngine_->transformUnit.FlushIfOverlap("scissor", gstate.getTextureAddress(i), 4 * gstate.getTextureWidth(i) * gstate.getTextureHeight(i)); } break; @@ -580,8 +579,7 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_TEXADDR5: case GE_CMD_TEXADDR6: case GE_CMD_TEXADDR7: - // TODO: Narrow down the risk range, for now assuming 512x512 max texture. - drawEngine_->transformUnit.FlushIfOverlap("texaddr", gstate.getTextureAddress(cmd - GE_CMD_TEXADDR0), 4 * 512 * 512); + drawEngine_->transformUnit.FlushIfOverlap("texaddr", gstate.getTextureAddress(cmd - GE_CMD_TEXADDR0), 4 * gstate.getTextureWidth(cmd - GE_CMD_TEXADDR0) * gstate.getTextureHeight(cmd - GE_CMD_TEXADDR0)); break; case GE_CMD_TEXBUFWIDTH0: @@ -592,8 +590,7 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_TEXBUFWIDTH5: case GE_CMD_TEXBUFWIDTH6: case GE_CMD_TEXBUFWIDTH7: - // TODO: Narrow down the risk range, for now assuming 512x512 max texture. - drawEngine_->transformUnit.FlushIfOverlap("texbufw", gstate.getTextureAddress(cmd - GE_CMD_TEXBUFWIDTH0), 4 * 512 * 512); + drawEngine_->transformUnit.FlushIfOverlap("texbufw", gstate.getTextureAddress(cmd - GE_CMD_TEXBUFWIDTH0), 4 * gstate.getTextureWidth(cmd - GE_CMD_TEXBUFWIDTH0) * gstate.getTextureHeight(cmd - GE_CMD_TEXBUFWIDTH0)); break; case GE_CMD_CLUTADDR: @@ -692,6 +689,7 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_TEXSIZE5: case GE_CMD_TEXSIZE6: case GE_CMD_TEXSIZE7: + drawEngine_->transformUnit.FlushIfOverlap("texbufw", gstate.getTextureAddress(cmd - GE_CMD_TEXSIZE0), 4 * gstate.getTextureWidth(cmd - GE_CMD_TEXSIZE0) * gstate.getTextureHeight(cmd - GE_CMD_TEXSIZE0)); break; case GE_CMD_ZBUFPTR: