diff --git a/GPU/Software/BinManager.cpp b/GPU/Software/BinManager.cpp index 36981c6e8f..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" @@ -86,7 +87,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 +115,7 @@ private: BinWaitable *notify_; BinQueue &items_; std::atomic &status_; - const BinQueue &states_; + const BinQueue &states_; }; BinManager::BinManager() { @@ -133,10 +134,12 @@ BinManager::~BinManager() { } void BinManager::UpdateState() { + PROFILE_THIS_SCOPE("bin_state"); if (states_.Full()) 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()); @@ -159,10 +162,26 @@ 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(); + } +} + +void BinManager::UpdateClut(const void *src) { + PROFILE_THIS_SCOPE("bin_clut"); + 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) { @@ -233,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; @@ -263,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]); @@ -310,11 +332,15 @@ void BinManager::Flush() { queue_.Reset(); while (states_.Size() > 1) states_.SkipNext(); + while (cluts_.Size() > 1) + cluts_.SkipNext(); queueRange_.x1 = 0x7FFFFFFF; 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 4d32ea0335..eff0c4e6c9 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(const void *src); const Rasterizer::RasterizerState &State() { return states_[stateIndex_]; @@ -166,11 +171,15 @@ 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_; + int queueOffsetX_ = -1; + int queueOffsetY_ = -1; int maxTasks_ = 1; bool tasksSplit_ = false; 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..7e786916ee 100644 --- a/GPU/Software/SoftGpu.cpp +++ b/GPU/Software/SoftGpu.cpp @@ -548,6 +548,9 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_SCISSOR1: case GE_CMD_SCISSOR2: + for (int i = 0; i < 8; ++i) { + drawEngine_->transformUnit.FlushIfOverlap("scissor", gstate.getTextureAddress(i), 4 * gstate.getTextureWidth(i) * gstate.getTextureHeight(i)); + } break; case GE_CMD_MINZ: @@ -555,13 +558,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; @@ -576,8 +579,7 @@ 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(); + 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: @@ -588,8 +590,7 @@ 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(); + 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: @@ -598,13 +599,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("loadclut", clutAddr, clutTotalBytes); + if (Memory::IsValidAddress(clutAddr)) { u32 validSize = Memory::ValidSize(clutAddr, clutTotalBytes); Memory::MemcpyUnchecked(clut, clutAddr, validSize); @@ -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; @@ -633,7 +635,6 @@ void SoftGPU::ExecuteOp(u32 op, u32 diff) { case GE_CMD_TRANSFERSTART: { // Let's finish any drawing before we transfer. - drawEngine_->transformUnit.Flush(); u32 srcBasePtr = gstate.getTransferSrcAddress(); u32 srcStride = gstate.getTransferSrcStride(); @@ -652,19 +653,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; @@ -682,17 +689,18 @@ 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: // 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; @@ -888,7 +896,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 47d8393c40..5736f37ddd 100644 --- a/GPU/Software/TransformUnit.cpp +++ b/GPU/Software/TransformUnit.cpp @@ -608,11 +608,33 @@ void TransformUnit::SubmitPrimitive(void* vertices, void* indices, GEPrimitiveTy } } -void TransformUnit::Flush() { +void TransformUnit::Flush(const char *reason) { binner_->Flush(); GPUDebug::NotifyDraw(); } +void TransformUnit::FlushIfOverlap(const char *reason, 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(reason); + else if (addr < ztarget + targetHeight * ztargetStride && addr + sz >= ztarget) + Flush(reason); +} + +void TransformUnit::NotifyClutUpdate(const 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..79bd8bfbd5 100644 --- a/GPU/Software/TransformUnit.h +++ b/GPU/Software/TransformUnit.h @@ -119,7 +119,9 @@ public: bool GetCurrentSimpleVertices(int count, std::vector &vertices, std::vector &indices); - void Flush(); + void Flush(const char *reason); + void FlushIfOverlap(const char *reason, uint32_t addr, uint32_t sz); + void NotifyClutUpdate(const void *src); private: VertexData ReadVertex(VertexReader &vreader, bool &outside_range_flag);