Merge pull request #15314 from unknownbrackets/softgpu-binning

Allow binning of separate textures
This commit is contained in:
Henrik Rydgård authored and GitHub committed 2022-01-16 19:54:47 +01:00
commit d6d3bf360c
9 files changed
+111 -37

No files matched your search

+29 -3
View File
@@ -18,6 +18,7 @@
#include <atomic>
#include <condition_variable>
#include <mutex>
#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<BinItem, 1024> &items, std::atomic<bool> &status, const BinQueue<RasterizerState, 32> &states)
DrawBinItemsTask(BinWaitable *notify, BinQueue<BinItem, 1024> &items, std::atomic<bool> &status, const BinQueue<RasterizerState, 64> &states)
: notify_(notify), items_(items), status_(status), states_(states) {
}
@@ -114,7 +115,7 @@ private:
BinWaitable *notify_;
BinQueue<BinItem, 1024> &items_;
std::atomic<bool> &status_;
const BinQueue<RasterizerState, 32> &states_;
const BinQueue<RasterizerState, 64> &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 {
+10 -1
View File
@@ -143,12 +143,17 @@ struct BinQueue {
std::atomic<size_t> 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<Rasterizer::RasterizerState, 32> states_;
BinQueue<Rasterizer::RasterizerState, 64> states_;
int stateIndex_;
BinQueue<BinClut, 64> cluts_;
int clutIndex_;
BinCoords scissor_;
BinQueue<BinItem, 1024> queue_;
BinCoords queueRange_;
int queueOffsetX_ = -1;
int queueOffsetY_ = -1;
int maxTasks_ = 1;
bool tasksSplit_ = false;
+1 -1
View File
@@ -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) {
+7
View File
@@ -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 {
+4 -6
View File
@@ -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<u16*>(clut)[index + clutSharingOffset]);
return RGB565ToRGBA8888(samplerID.cached.clut16[index + clutSharingOffset]);
case GE_CMODE_16BIT_ABGR5551:
return RGBA5551ToRGBA8888(reinterpret_cast<u16*>(clut)[index + clutSharingOffset]);
return RGBA5551ToRGBA8888(samplerID.cached.clut16[index + clutSharingOffset]);
case GE_CMODE_16BIT_ABGR4444:
return RGBA4444ToRGBA8888(reinterpret_cast<u16*>(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());
+6 -4
View File
@@ -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:
+28 -20
View File
@@ -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) {
+23 -1
View File
@@ -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<GPUDebugVertex> &vertices, std::vector<u16> &indices) {
+3 -1
View File
@@ -119,7 +119,9 @@ public:
bool GetCurrentSimpleVertices(int count, std::vector<GPUDebugVertex> &vertices, std::vector<u16> &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);