More async GPU init

Common/GPU/Vulkan/VulkanRenderManager.cpp

@@ -273,14 +273,21 @@ class CreateMultiPipelinesTask : public Task {
 
 	// Use during shutdown to make sure there aren't any leftover tasks sitting queued.
 	// Could probably be done more elegantly. Like waiting for all tasks of a type, or saving pointers to them, or something...
-	static void WaitForAll();
+	// Returns the maximum value of tasks in flight seen during the wait.
+	static int WaitForAll();
 	static std::atomic<int> tasksInFlight_;
 };
 
-void CreateMultiPipelinesTask::WaitForAll() {
-	while (tasksInFlight_.load() > 0) {
+int CreateMultiPipelinesTask::WaitForAll() {
+	int inFlight = 0;
+	int maxInFlight = 0;
+	while ((inFlight = tasksInFlight_.load()) > 0) {
+		if (inFlight > maxInFlight) {
+			maxInFlight = inFlight;
+		}
 		sleep_ms(2, "create-multi-pipelines-wait");
 	}
+	return maxInFlight;
 }
 
 std::atomic<int> CreateMultiPipelinesTask::tasksInFlight_;
@@ -410,7 +417,7 @@ void VulkanRenderManager::StopThreads() {
 		presentWaitThread_.join();
 	}
 
-	INFO_LOG(Log::G3D, "Vulkan compiler thread joined. Now wait for any straggling compile tasks.");
+	INFO_LOG(Log::G3D, "Vulkan compiler thread joined. Now wait for any straggling compile tasks. runCompileThread_ = %d", (int)runCompileThread_);
 	CreateMultiPipelinesTask::WaitForAll();
 
 	{
@@ -775,6 +782,10 @@ void VulkanRenderManager::ReportBadStateForDraw() {
 	ERROR_LOG_REPORT_ONCE(baddraw, Log::G3D, "Can't draw: %s%s. Step count: %d", cause1, cause2, (int)steps_.size());
 }
 
+int VulkanRenderManager::WaitForPipelines() {
+	return CreateMultiPipelinesTask::WaitForAll();
+}
+
 VKRGraphicsPipeline *VulkanRenderManager::CreateGraphicsPipeline(VKRGraphicsPipelineDesc *desc, PipelineFlags pipelineFlags, uint32_t variantBitmask, VkSampleCountFlagBits sampleCount, bool cacheLoad, const char *tag) {
 	if (!desc->vertexShader || !desc->fragmentShader) {
 		ERROR_LOG(Log::G3D, "Can't create graphics pipeline with missing vs/ps: %p %p", desc->vertexShader, desc->fragmentShader);

Common/GPU/Vulkan/VulkanRenderManager.h

@@ -283,6 +283,8 @@ class VulkanRenderManager {
 
 	void ReportBadStateForDraw();
 
+	int WaitForPipelines();
+
 	void NudgeCompilerThread() {
 		compileQueueMutex_.lock();
 		compileCond_.notify_one();

Common/Render/TextureAtlas.cpp

@@ -61,8 +61,10 @@ bool Atlas::Load(const uint8_t *data, size_t data_size) {
 		return false;
 	}
 
-	images = reader.ReadMultipleAlloc<AtlasImage>(num_images, header.version >= 1);
+	delete[] images;
+	delete[] fonts;
 
+	images = reader.ReadMultipleAlloc<AtlasImage>(num_images, header.version >= 1);
 	fonts = new AtlasFont[num_fonts];
 	for (int i = 0; i < num_fonts; i++) {
 		AtlasFontHeader font_header = reader.Read<AtlasFontHeader>();

Core/CoreParameter.h

@@ -23,7 +23,7 @@
 #include "Core/Compatibility.h"
 #include "Core/Loaders.h"
 
-enum GPUCore {
+enum GPUCore : int {
 	GPUCORE_GLES,
 	GPUCORE_SOFTWARE,
 	GPUCORE_DIRECTX9,

Core/System.cpp

@@ -575,6 +575,21 @@ bool PSP_InitStart(const CoreParameter &coreParam) {
 			return;
 		}
 
+		// Initialize the GPU as far as we can here (do things like load cache files).
+
+		if (!gpu) {  // should be!
+			INFO_LOG(Log::Loader, "Starting graphics...");
+			Draw::DrawContext *draw = g_CoreParameter.graphicsContext ? g_CoreParameter.graphicsContext->GetDrawContext() : nullptr;
+			// This set the `gpu` global.
+			GPUCore gpuCore = PSP_CoreParameter().gpuCore;
+			bool success = GPU_Init(gpuCore, g_CoreParameter.graphicsContext, draw);
+			if (!success) {
+				*error_string = "Unable to initialize rendering engine.";
+				CPU_Shutdown(false);
+				g_bootState = BootState::Failed;
+			}
+		}
+
 		g_bootState = BootState::Complete;
 	});
 
@@ -604,27 +619,11 @@ BootState PSP_InitUpdate(std::string *error_string) {
 		return BootState::Failed;
 	}
 
-	// Ok, async boot completed, let's finish up things on the main thread.
-	if (!gpu) {  // should be!
-		INFO_LOG(Log::Loader, "Starting graphics...");
-		Draw::DrawContext *draw = g_CoreParameter.graphicsContext ? g_CoreParameter.graphicsContext->GetDrawContext() : nullptr;
-		// This set the `gpu` global.
-		bool success = GPU_Init(g_CoreParameter.graphicsContext, draw);
-		if (!success) {
-			*error_string = "Unable to initialize rendering engine.";
-			PSP_Shutdown(false);
-			g_bootState = BootState::Off;
-			return BootState::Failed;
-		}
-	}
-
-	// TODO: This should all be checked during GPU_Init.
-	if (!GPU_IsStarted()) {
-		*error_string = "Unable to initialize rendering engine.";
-		PSP_Shutdown(false);
-		g_bootState = BootState::Off;
-		Core_NotifyLifecycle(CoreLifecycle::START_COMPLETE);
-		return BootState::Failed;
+	// Ok, async part of the boot completed, let's finish up things on the main thread.
+	if (gpu) {
+		gpu->FinishInitOnMainThread();
+	} else {
+		_dbg_assert_(gpu);
 	}
 
 	Core_NotifyLifecycle(CoreLifecycle::START_COMPLETE);

GPU/Common/FramebufferManagerCommon.cpp

@@ -2783,7 +2783,7 @@ void FramebufferManagerCommon::NotifyBlockTransferAfter(u32 dstBasePtr, int dstS
 
 		// A few games use this INSTEAD of actually drawing the video image to the screen, they just blast it to
 		// the backbuffer. Detect this and have the framebuffermanager draw the pixels.
-		if (!useBufferedRendering_ && currentRenderVfb_ != dstRect.vfb) {
+		if ((!useBufferedRendering_ && currentRenderVfb_ != dstRect.vfb) || dstRect.vfb == nullptr) {
 			return;
 		}
 

GPU/D3D11/GPU_D3D11.cpp

@@ -39,8 +39,6 @@ GPU_D3D11::GPU_D3D11(GraphicsContext *gfxCtx, Draw::DrawContext *draw)
 	context_ = (ID3D11DeviceContext *)draw->GetNativeObject(Draw::NativeObject::CONTEXT);
 	D3D_FEATURE_LEVEL featureLevel = (D3D_FEATURE_LEVEL)draw->GetNativeObject(Draw::NativeObject::FEATURE_LEVEL);
 
-	stockD3D11.Create(device_);
-
 	shaderManagerD3D11_ = new ShaderManagerD3D11(draw, device_, context_, featureLevel);
 	framebufferManagerD3D11_ = new FramebufferManagerD3D11(draw);
 	framebufferManager_ = framebufferManagerD3D11_;
@@ -77,6 +75,11 @@ GPU_D3D11::GPU_D3D11(GraphicsContext *gfxCtx, Draw::DrawContext *draw)
 	textureCache_->NotifyConfigChanged();
 }
 
+void GPU_D3D11::FinishInitOnMainThread() {
+	textureCacheD3D11_->InitDeviceObjects();
+	stockD3D11.Create(device_);
+}
+
 GPU_D3D11::~GPU_D3D11() {
 	stockD3D11.Destroy();
 }

GPU/D3D11/GPU_D3D11.h

@@ -34,6 +34,8 @@ class GPU_D3D11 : public GPUCommonHW {
 	GPU_D3D11(GraphicsContext *gfxCtx, Draw::DrawContext *draw);
 	~GPU_D3D11();
 
+	void FinishInitOnMainThread() override;
+
 	u32 CheckGPUFeatures() const override;
 
 	void GetStats(char *buffer, size_t bufsize) override;

GPU/D3D11/TextureCacheD3D11.cpp

@@ -42,8 +42,6 @@ struct DepthPushConstants {
 	float pad[2];
 };
 
-#define INVALID_TEX (ID3D11ShaderResourceView *)(-1LL)
-
 static const D3D11_INPUT_ELEMENT_DESC g_QuadVertexElements[] = {
 	{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, },
 	{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12,},
@@ -135,21 +133,21 @@ TextureCacheD3D11::TextureCacheD3D11(Draw::DrawContext *draw, Draw2D *draw2D)
 	device_ = (ID3D11Device *)draw->GetNativeObject(Draw::NativeObject::DEVICE);
 	context_ = (ID3D11DeviceContext *)draw->GetNativeObject(Draw::NativeObject::CONTEXT);
 
-	lastBoundTexture = INVALID_TEX;
-
-	D3D11_BUFFER_DESC desc{ sizeof(DepthPushConstants), D3D11_USAGE_DYNAMIC, D3D11_BIND_CONSTANT_BUFFER, D3D11_CPU_ACCESS_WRITE };
-	HRESULT hr = device_->CreateBuffer(&desc, nullptr, &depalConstants_);
-	_dbg_assert_(SUCCEEDED(hr));
-
-	HRESULT result = 0;
+	lastBoundTexture_ = D3D11_INVALID_TEX;
 
-	nextTexture_ = nullptr;
+	InitDeviceObjects();
 }
 
 TextureCacheD3D11::~TextureCacheD3D11() {
 	Clear(true);
 }
 
+void TextureCacheD3D11::InitDeviceObjects() {
+	D3D11_BUFFER_DESC desc{ sizeof(DepthPushConstants), D3D11_USAGE_DYNAMIC, D3D11_BIND_CONSTANT_BUFFER, D3D11_CPU_ACCESS_WRITE };
+	HRESULT hr = device_->CreateBuffer(&desc, nullptr, &depalConstants_);
+	_dbg_assert_(SUCCEEDED(hr));
+}
+
 void TextureCacheD3D11::SetFramebufferManager(FramebufferManagerD3D11 *fbManager) {
 	framebufferManager_ = fbManager;
 }
@@ -168,7 +166,7 @@ void TextureCacheD3D11::ReleaseTexture(TexCacheEntry *entry, bool delete_them) {
 }
 
 void TextureCacheD3D11::ForgetLastTexture() {
-	lastBoundTexture = INVALID_TEX;
+	lastBoundTexture_ = D3D11_INVALID_TEX;
 
 	ID3D11ShaderResourceView *nullTex[4]{};
 	context_->PSSetShaderResources(0, 4, nullTex);
@@ -217,9 +215,9 @@ void TextureCacheD3D11::BindTexture(TexCacheEntry *entry) {
 		return;
 	}
 	ID3D11ShaderResourceView *textureView = DxView(entry);
-	if (textureView != lastBoundTexture) {
+	if (textureView != lastBoundTexture_) {
 		context_->PSSetShaderResources(0, 1, &textureView);
-		lastBoundTexture = textureView;
+		lastBoundTexture_ = textureView;
 	}
 	int maxLevel = (entry->status & TexCacheEntry::STATUS_NO_MIPS) ? 0 : entry->maxLevel;
 	SamplerCacheKey samplerKey = GetSamplingParams(maxLevel, entry);

GPU/D3D11/TextureCacheD3D11.h

@@ -42,6 +42,8 @@ class SamplerCacheD3D11 {
 	std::map<SamplerCacheKey, Microsoft::WRL::ComPtr<ID3D11SamplerState>> cache_;
 };
 
+#define D3D11_INVALID_TEX (ID3D11ShaderResourceView *)(-1LL)
+
 class TextureCacheD3D11 : public TextureCacheCommon {
 public:
 	TextureCacheD3D11(Draw::DrawContext *draw, Draw2D *draw2D);
@@ -56,6 +58,8 @@ class TextureCacheD3D11 : public TextureCacheCommon {
 	void DeviceLost() override { draw_ = nullptr; }
 	void DeviceRestore(Draw::DrawContext *draw) override { draw_ = draw; }
 
+	void InitDeviceObjects();
+
 protected:
 	void BindTexture(TexCacheEntry *entry) override;
 	void Unbind() override;
@@ -82,7 +86,7 @@ class TextureCacheD3D11 : public TextureCacheCommon {
 
 	SamplerCacheD3D11 samplerCache_;
 
-	ID3D11ShaderResourceView *lastBoundTexture;
+	ID3D11ShaderResourceView *lastBoundTexture_ = D3D11_INVALID_TEX;
 	Microsoft::WRL::ComPtr<ID3D11Buffer> depalConstants_;
 };
 

GPU/Directx9/GPU_DX9.cpp

@@ -75,7 +75,6 @@ GPU_DX9::GPU_DX9(GraphicsContext *gfxCtx, Draw::DrawContext *draw)
 
 	// Some of our defaults are different from hw defaults, let's assert them.
 	// We restore each frame anyway, but here is convenient for tests.
-	dxstate.Restore();
 	textureCache_->NotifyConfigChanged();
 
 	if (g_Config.bHardwareTessellation) {
@@ -87,6 +86,11 @@ GPU_DX9::GPU_DX9(GraphicsContext *gfxCtx, Draw::DrawContext *draw)
 	}
 }
 
+void GPU_DX9::FinishInitOnMainThread() {
+	textureCacheDX9_->InitDeviceObjects();
+	dxstate.Restore();
+}
+
 u32 GPU_DX9::CheckGPUFeatures() const {
 	u32 features = GPUCommonHW::CheckGPUFeatures();
 	features |= GPU_USE_16BIT_FORMATS;

GPU/Directx9/GPU_DX9.h

@@ -34,6 +34,7 @@ class FramebufferManagerDX9;
 class GPU_DX9 : public GPUCommonHW {
 public:
 	GPU_DX9(GraphicsContext *gfxCtx, Draw::DrawContext *draw);
+	void FinishInitOnMainThread() override;
 
 	u32 CheckGPUFeatures() const override;
 

GPU/Directx9/TextureCacheDX9.cpp

@@ -73,6 +73,13 @@ TextureCacheDX9::TextureCacheDX9(Draw::DrawContext *draw, Draw2D *draw2D)
 	lastBoundTexture = INVALID_TEX;
 	device_ = (LPDIRECT3DDEVICE9)draw->GetNativeObject(Draw::NativeObject::DEVICE);
 	deviceEx_ = (LPDIRECT3DDEVICE9EX)draw->GetNativeObject(Draw::NativeObject::DEVICE_EX);
+}
+
+TextureCacheDX9::~TextureCacheDX9() {
+	Clear(true);
+}
+
+void TextureCacheDX9::InitDeviceObjects() {
 	D3DCAPS9 pCaps;
 	ZeroMemory(&pCaps, sizeof(pCaps));
 	HRESULT result = 0;
@@ -92,10 +99,6 @@ TextureCacheDX9::TextureCacheDX9(Draw::DrawContext *draw, Draw2D *draw2D)
 	device_->CreateVertexDeclaration(g_FramebufferVertexElements, &pFramebufferVertexDecl);
 }
 
-TextureCacheDX9::~TextureCacheDX9() {
-	Clear(true);
-}
-
 void TextureCacheDX9::SetFramebufferManager(FramebufferManagerDX9 *fbManager) {
 	framebufferManager_ = fbManager;
 }

GPU/Directx9/TextureCacheDX9.h

@@ -46,6 +46,7 @@ class TextureCacheDX9 : public TextureCacheCommon {
 	void DeviceLost() override { draw_ = nullptr; }
 	void DeviceRestore(Draw::DrawContext *draw) override { draw_ = draw; }
 
+	void InitDeviceObjects();
 protected:
 	void BindTexture(TexCacheEntry *entry) override;
 	void Unbind() override;
@@ -73,7 +74,7 @@ class TextureCacheDX9 : public TextureCacheCommon {
 	IDirect3DBaseTexture9 *lastBoundTexture = nullptr;
 	float maxAnisotropyLevel;
 
-	FramebufferManagerDX9 *framebufferManagerDX9_;
+	FramebufferManagerDX9 *framebufferManagerDX9_ = nullptr;
 };
 
 static D3DFORMAT getClutDestFormat(GEPaletteFormat format);