yuzu/src/video_core/shader/async_shaders.h

140 lines
4.5 KiB
C++
Raw Normal View History

2020-07-10 03:36:38 +00:00
// Copyright 2020 yuzu Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#pragma once
2020-07-16 08:38:35 +00:00
#include <condition_variable>
2020-07-10 03:36:38 +00:00
#include <deque>
#include <memory>
#include <shared_mutex>
#include <thread>
#include "common/bit_field.h"
#include "common/common_types.h"
#include "video_core/renderer_opengl/gl_device.h"
#include "video_core/renderer_opengl/gl_resource_manager.h"
#include "video_core/renderer_opengl/gl_shader_decompiler.h"
2020-07-28 04:08:02 +00:00
#include "video_core/renderer_vulkan/vk_device.h"
#include "video_core/renderer_vulkan/vk_pipeline_cache.h"
#include "video_core/renderer_vulkan/vk_scheduler.h"
#include "video_core/renderer_vulkan/vk_update_descriptor.h"
2020-07-10 03:36:38 +00:00
namespace Core::Frontend {
class EmuWindow;
class GraphicsContext;
} // namespace Core::Frontend
namespace Tegra {
class GPU;
}
2020-07-28 04:08:02 +00:00
namespace Vulkan {
class VKPipelineCache;
}
2020-07-10 03:36:38 +00:00
namespace VideoCommon::Shader {
class AsyncShaders {
public:
enum class Backend {
OpenGL,
GLASM,
2020-07-28 04:08:02 +00:00
Vulkan,
2020-07-10 03:36:38 +00:00
};
struct ResultPrograms {
OpenGL::OGLProgram opengl;
OpenGL::OGLAssemblyProgram glasm;
};
struct Result {
u64 uid;
VAddr cpu_address;
Backend backend;
ResultPrograms program;
std::vector<u64> code;
std::vector<u64> code_b;
Tegra::Engines::ShaderType shader_type;
2020-07-28 04:08:02 +00:00
std::unique_ptr<Vulkan::VKGraphicsPipeline> pipeline;
2020-07-10 03:36:38 +00:00
};
explicit AsyncShaders(Core::Frontend::EmuWindow& emu_window);
~AsyncShaders();
/// Start up shader worker threads
void AllocateWorkers();
2020-07-10 03:36:38 +00:00
/// Clear the shader queue and kill all worker threads
void FreeWorkers();
// Force end all threads
void KillWorkers();
/// Check to see if any shaders have actually been compiled
bool HasCompletedWork();
/// Deduce if a shader can be build on another thread of MUST be built in sync. We cannot build
/// every shader async as some shaders are only built and executed once. We try to "guess" which
/// shader would be used only once
bool IsShaderAsync(const Tegra::GPU& gpu) const;
/// Pulls completed compiled shaders
std::vector<Result> GetCompletedWork();
void QueueOpenGLShader(const OpenGL::Device& device, Tegra::Engines::ShaderType shader_type,
u64 uid, std::vector<u64> code, std::vector<u64> code_b, u32 main_offset,
VideoCommon::Shader::CompilerSettings compiler_settings,
const VideoCommon::Shader::Registry& registry, VAddr cpu_addr);
void QueueVulkanShader(Vulkan::VKPipelineCache* pp_cache, const Vulkan::VKDevice& device,
Vulkan::VKScheduler& scheduler,
Vulkan::VKDescriptorPool& descriptor_pool,
Vulkan::VKUpdateDescriptorQueue& update_descriptor_queue,
Vulkan::VKRenderPassCache& renderpass_cache,
2020-07-28 04:08:02 +00:00
std::vector<VkDescriptorSetLayoutBinding> bindings,
Vulkan::SPIRVProgram program, Vulkan::GraphicsPipelineCacheKey key);
2020-07-28 04:08:02 +00:00
2020-07-10 03:36:38 +00:00
private:
void ShaderCompilerThread(Core::Frontend::GraphicsContext* context);
2020-07-16 08:38:35 +00:00
/// Check our worker queue to see if we have any work queued already
bool HasWorkQueued();
2020-07-10 03:36:38 +00:00
struct WorkerParams {
Backend backend;
2020-07-28 04:08:02 +00:00
// For OGL
const OpenGL::Device* device;
2020-07-10 03:36:38 +00:00
Tegra::Engines::ShaderType shader_type;
u64 uid;
std::vector<u64> code;
std::vector<u64> code_b;
u32 main_offset;
VideoCommon::Shader::CompilerSettings compiler_settings;
2020-07-28 04:08:02 +00:00
const VideoCommon::Shader::Registry* registry;
2020-07-10 03:36:38 +00:00
VAddr cpu_address;
2020-07-28 04:08:02 +00:00
// For Vulkan
Vulkan::VKPipelineCache* pp_cache;
const Vulkan::VKDevice* vk_device;
Vulkan::VKScheduler* scheduler;
Vulkan::VKDescriptorPool* descriptor_pool;
Vulkan::VKUpdateDescriptorQueue* update_descriptor_queue;
Vulkan::VKRenderPassCache* renderpass_cache;
2020-07-28 04:08:02 +00:00
std::vector<VkDescriptorSetLayoutBinding> bindings;
Vulkan::SPIRVProgram program;
Vulkan::GraphicsPipelineCacheKey key;
2020-07-10 03:36:38 +00:00
};
2020-07-16 08:38:35 +00:00
std::condition_variable cv;
std::mutex queue_mutex;
2020-07-10 03:36:38 +00:00
std::shared_mutex completed_mutex;
std::atomic<bool> is_thread_exiting{};
std::vector<std::unique_ptr<Core::Frontend::GraphicsContext>> context_list;
std::vector<std::thread> worker_threads;
std::queue<WorkerParams> pending_queue;
2020-07-10 03:36:38 +00:00
std::vector<AsyncShaders::Result> finished_work;
Core::Frontend::EmuWindow& emu_window;
};
} // namespace VideoCommon::Shader