franklinblanco
/
yuzu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #4933 from lioncash/nodisc-gpu 

[gpu, render_base, rasterizer_interface]: Make use of [[nodiscard]] where applicable
This commit is contained in:
Chloe 2020-11-18 01:40:03 +11:00 committed by GitHub
parent 8ace3959a5 70812ec57b
commit 2dc9dbb809
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 55 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
src/video_core/gpu.h
View File

@ -17,11 +17,11 @@
#include "video_core/dma_pusher.h" #include "video_core/dma_pusher.h"
using CacheAddr = std::uintptr_t; using CacheAddr = std::uintptr_t;
inline CacheAddr ToCacheAddr(const void* host_ptr) { [[nodiscard]] inline CacheAddr ToCacheAddr(const void* host_ptr) {
return reinterpret_cast<CacheAddr>(host_ptr); return reinterpret_cast<CacheAddr>(host_ptr);
} }
inline u8* FromCacheAddr(CacheAddr cache_addr) { [[nodiscard]] inline u8* FromCacheAddr(CacheAddr cache_addr) {
return reinterpret_cast<u8*>(cache_addr); return reinterpret_cast<u8*>(cache_addr);
} }
@ -149,13 +149,13 @@ public:
u32 subchannel{}; u32 subchannel{};
u32 method_count{}; u32 method_count{};
bool IsLastCall() const {
return method_count <= 1;
}
MethodCall(u32 method, u32 argument, u32 subchannel = 0, u32 method_count = 0) MethodCall(u32 method, u32 argument, u32 subchannel = 0, u32 method_count = 0)
: method(method), argument(argument), subchannel(subchannel), : method(method), argument(argument), subchannel(subchannel),
method_count(method_count) {} method_count(method_count) {}
[[nodiscard]] bool IsLastCall() const {
return method_count <= 1;
}
}; };
explicit GPU(Core::System& system, bool is_async, bool use_nvdec); explicit GPU(Core::System& system, bool is_async, bool use_nvdec);
@ -179,10 +179,10 @@ public:
virtual void OnCommandListEnd(); virtual void OnCommandListEnd();
/// Request a host GPU memory flush from the CPU. /// Request a host GPU memory flush from the CPU.
u64 RequestFlush(VAddr addr, std::size_t size); [[nodiscard]] u64 RequestFlush(VAddr addr, std::size_t size);
/// Obtains current flush request fence id. /// Obtains current flush request fence id.
u64 CurrentFlushRequestFence() const { [[nodiscard]] u64 CurrentFlushRequestFence() const {
return current_flush_fence.load(std::memory_order_relaxed); return current_flush_fence.load(std::memory_order_relaxed);
} }
@ -190,48 +190,52 @@ public:
void TickWork(); void TickWork();
/// Returns a reference to the Maxwell3D GPU engine. /// Returns a reference to the Maxwell3D GPU engine.
Engines::Maxwell3D& Maxwell3D(); [[nodiscard]] Engines::Maxwell3D& Maxwell3D();
/// Returns a const reference to the Maxwell3D GPU engine. /// Returns a const reference to the Maxwell3D GPU engine.
const Engines::Maxwell3D& Maxwell3D() const; [[nodiscard]] const Engines::Maxwell3D& Maxwell3D() const;
/// Returns a reference to the KeplerCompute GPU engine. /// Returns a reference to the KeplerCompute GPU engine.
Engines::KeplerCompute& KeplerCompute(); [[nodiscard]] Engines::KeplerCompute& KeplerCompute();
/// Returns a reference to the KeplerCompute GPU engine. /// Returns a reference to the KeplerCompute GPU engine.
const Engines::KeplerCompute& KeplerCompute() const; [[nodiscard]] const Engines::KeplerCompute& KeplerCompute() const;
/// Returns a reference to the GPU memory manager. /// Returns a reference to the GPU memory manager.
Tegra::MemoryManager& MemoryManager(); [[nodiscard]] Tegra::MemoryManager& MemoryManager();
/// Returns a const reference to the GPU memory manager. /// Returns a const reference to the GPU memory manager.
const Tegra::MemoryManager& MemoryManager() const; [[nodiscard]] const Tegra::MemoryManager& MemoryManager() const;
/// Returns a reference to the GPU DMA pusher. /// Returns a reference to the GPU DMA pusher.
Tegra::DmaPusher& DmaPusher(); [[nodiscard]] Tegra::DmaPusher& DmaPusher();
/// Returns a const reference to the GPU DMA pusher. /// Returns a const reference to the GPU DMA pusher.
const Tegra::DmaPusher& DmaPusher() const; [[nodiscard]] const Tegra::DmaPusher& DmaPusher() const;
/// Returns a reference to the GPU CDMA pusher. /// Returns a reference to the GPU CDMA pusher.
Tegra::CDmaPusher& CDmaPusher(); [[nodiscard]] Tegra::CDmaPusher& CDmaPusher();
/// Returns a const reference to the GPU CDMA pusher. /// Returns a const reference to the GPU CDMA pusher.
const Tegra::CDmaPusher& CDmaPusher() const; [[nodiscard]] const Tegra::CDmaPusher& CDmaPusher() const;
VideoCore::RendererBase& Renderer() { /// Returns a reference to the underlying renderer.
[[nodiscard]] VideoCore::RendererBase& Renderer() {
return *renderer; return *renderer;
} }
const VideoCore::RendererBase& Renderer() const { /// Returns a const reference to the underlying renderer.
[[nodiscard]] const VideoCore::RendererBase& Renderer() const {
return *renderer; return *renderer;
} }
VideoCore::ShaderNotify& ShaderNotify() { /// Returns a reference to the shader notifier.
[[nodiscard]] VideoCore::ShaderNotify& ShaderNotify() {
return *shader_notify; return *shader_notify;
} }
const VideoCore::ShaderNotify& ShaderNotify() const { /// Returns a const reference to the shader notifier.
[[nodiscard]] const VideoCore::ShaderNotify& ShaderNotify() const {
return *shader_notify; return *shader_notify;
} }
@ -243,23 +247,23 @@ public:
void IncrementSyncPoint(u32 syncpoint_id); void IncrementSyncPoint(u32 syncpoint_id);
u32 GetSyncpointValue(u32 syncpoint_id) const; [[nodiscard]] u32 GetSyncpointValue(u32 syncpoint_id) const;
void RegisterSyncptInterrupt(u32 syncpoint_id, u32 value); void RegisterSyncptInterrupt(u32 syncpoint_id, u32 value);
bool CancelSyncptInterrupt(u32 syncpoint_id, u32 value); [[nodiscard]] bool CancelSyncptInterrupt(u32 syncpoint_id, u32 value);
u64 GetTicks() const; [[nodiscard]] u64 GetTicks() const;
std::unique_lock<std::mutex> LockSync() { [[nodiscard]] std::unique_lock<std::mutex> LockSync() {
return std::unique_lock{sync_mutex}; return std::unique_lock{sync_mutex};
} }
bool IsAsync() const { [[nodiscard]] bool IsAsync() const {
return is_async; return is_async;
} }
bool UseNvdec() const { [[nodiscard]] bool UseNvdec() const {
return use_nvdec; return use_nvdec;
} }
@ -273,7 +277,7 @@ public:
BitField<0, 1, FenceOperation> op; BitField<0, 1, FenceOperation> op;
BitField<8, 24, u32> syncpoint_id; BitField<8, 24, u32> syncpoint_id;
static CommandHeader Build(FenceOperation op, u32 syncpoint_id) { [[nodiscard]] static CommandHeader Build(FenceOperation op, u32 syncpoint_id) {
FenceAction result{}; FenceAction result{};
result.op.Assign(op); result.op.Assign(op);
result.syncpoint_id.Assign(syncpoint_id); result.syncpoint_id.Assign(syncpoint_id);
@ -291,7 +295,7 @@ public:
u32 address_high; u32 address_high;
u32 address_low; u32 address_low;
GPUVAddr SemaphoreAddress() const { [[nodiscard]] GPUVAddr SemaphoreAddress() const {
return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) | return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) |
address_low); address_low);
} }
@ -374,7 +378,7 @@ private:
u32 methods_pending); u32 methods_pending);
/// Determines where the method should be executed. /// Determines where the method should be executed.
bool ExecuteMethodOnEngine(u32 method); [[nodiscard]] bool ExecuteMethodOnEngine(u32 method);
protected: protected:
Core::System& system; Core::System& system;

17
src/video_core/rasterizer_interface.h
View File

@ -32,7 +32,7 @@ using DiskResourceLoadCallback = std::function<void(LoadCallbackStage, std::size
class RasterizerInterface { class RasterizerInterface {
public: public:
virtual ~RasterizerInterface() {} virtual ~RasterizerInterface() = default;
/// Dispatches a draw invocation /// Dispatches a draw invocation
virtual void Draw(bool is_indexed, bool is_instanced) = 0; virtual void Draw(bool is_indexed, bool is_instanced) = 0;
@ -90,15 +90,16 @@ public:
virtual void TickFrame() = 0; virtual void TickFrame() = 0;
/// Attempt to use a faster method to perform a surface copy /// Attempt to use a faster method to perform a surface copy
virtual bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src, [[nodiscard]] virtual bool AccelerateSurfaceCopy(
const Tegra::Engines::Fermi2D::Regs::Surface& dst, const Tegra::Engines::Fermi2D::Regs::Surface& src,
const Tegra::Engines::Fermi2D::Config& copy_config) { const Tegra::Engines::Fermi2D::Regs::Surface& dst,
const Tegra::Engines::Fermi2D::Config& copy_config) {
return false; return false;
} }
/// Attempt to use a faster method to display the framebuffer to screen /// Attempt to use a faster method to display the framebuffer to screen
virtual bool AccelerateDisplay(const Tegra::FramebufferConfig& config, VAddr framebuffer_addr, [[nodiscard]] virtual bool AccelerateDisplay(const Tegra::FramebufferConfig& config,
u32 pixel_stride) { VAddr framebuffer_addr, u32 pixel_stride) {
return false; return false;
} }
@ -110,12 +111,12 @@ public:
const DiskResourceLoadCallback& callback) {} const DiskResourceLoadCallback& callback) {}
/// Grant access to the Guest Driver Profile for recording/obtaining info on the guest driver. /// Grant access to the Guest Driver Profile for recording/obtaining info on the guest driver.
GuestDriverProfile& AccessGuestDriverProfile() { [[nodiscard]] GuestDriverProfile& AccessGuestDriverProfile() {
return guest_driver_profile; return guest_driver_profile;
} }
/// Grant access to the Guest Driver Profile for recording/obtaining info on the guest driver. /// Grant access to the Guest Driver Profile for recording/obtaining info on the guest driver.
const GuestDriverProfile& AccessGuestDriverProfile() const { [[nodiscard]] const GuestDriverProfile& AccessGuestDriverProfile() const {
return guest_driver_profile; return guest_driver_profile;
} }

22
src/video_core/renderer_base.h
View File

@ -38,7 +38,7 @@ public:
virtual ~RendererBase(); virtual ~RendererBase();
/// Initialize the renderer /// Initialize the renderer
virtual bool Init() = 0; [[nodiscard]] virtual bool Init() = 0;
/// Shutdown the renderer /// Shutdown the renderer
virtual void ShutDown() = 0; virtual void ShutDown() = 0;
@ -49,43 +49,43 @@ public:
// Getter/setter functions: // Getter/setter functions:
// ------------------------ // ------------------------
f32 GetCurrentFPS() const { [[nodiscard]] f32 GetCurrentFPS() const {
return m_current_fps; return m_current_fps;
} }
int GetCurrentFrame() const { [[nodiscard]] int GetCurrentFrame() const {
return m_current_frame; return m_current_frame;
} }
RasterizerInterface& Rasterizer() { [[nodiscard]] RasterizerInterface& Rasterizer() {
return *rasterizer; return *rasterizer;
} }
const RasterizerInterface& Rasterizer() const { [[nodiscard]] const RasterizerInterface& Rasterizer() const {
return *rasterizer; return *rasterizer;
} }
Core::Frontend::GraphicsContext& Context() { [[nodiscard]] Core::Frontend::GraphicsContext& Context() {
return *context; return *context;
} }
const Core::Frontend::GraphicsContext& Context() const { [[nodiscard]] const Core::Frontend::GraphicsContext& Context() const {
return *context; return *context;
} }
Core::Frontend::EmuWindow& GetRenderWindow() { [[nodiscard]] Core::Frontend::EmuWindow& GetRenderWindow() {
return render_window; return render_window;
} }
const Core::Frontend::EmuWindow& GetRenderWindow() const { [[nodiscard]] const Core::Frontend::EmuWindow& GetRenderWindow() const {
return render_window; return render_window;
} }
RendererSettings& Settings() { [[nodiscard]] RendererSettings& Settings() {
return renderer_settings; return renderer_settings;
} }
const RendererSettings& Settings() const { [[nodiscard]] const RendererSettings& Settings() const {
return renderer_settings; return renderer_settings;
} }