mirror of
https://github.com/hrydgard/ppsspp.git
synced 2026-11-17 03:14:34 +01:00
Merge pull request #15314 from unknownbrackets/softgpu-binning
Allow binning of separate textures
This commit is contained in:
9 files changed
+111
-37
No files matched your search
@@ -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 {
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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());
|
||||
|
||||
@@ -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
@@ -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) {
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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);
|
||||
|
||||
Reference in new issue
Block a user