diff --git a/src/android/app/src/main/res/values/arrays.xml b/src/android/app/src/main/res/values/arrays.xml index e0e32ca11..a097e4dd1 100644 --- a/src/android/app/src/main/res/values/arrays.xml +++ b/src/android/app/src/main/res/values/arrays.xml @@ -429,15 +429,11 @@ Conservative Aggressive - High-End GPU (4090/4080+) - Insane (RTX 4090 24GB) 0 1 - 2 - 3 diff --git a/src/citron/configuration/shared_translation.cpp b/src/citron/configuration/shared_translation.cpp index a1e9d854f..72c99bca0 100644 --- a/src/citron/configuration/shared_translation.cpp +++ b/src/citron/configuration/shared_translation.cpp @@ -382,8 +382,6 @@ std::unique_ptr ComboboxEnumeration(QWidget* parent) { { PAIR(VramUsageMode, Conservative, tr("Conservative")), PAIR(VramUsageMode, Aggressive, tr("Aggressive")), - PAIR(VramUsageMode, HighEnd, tr("High-End GPU (4090/4080+)")), - PAIR(VramUsageMode, Insane, tr("Insane (RTX 4090 24GB)")), }}); translations->insert({Settings::EnumMetadata::Index(), { diff --git a/src/citron/util/vram_overlay.cpp b/src/citron/util/vram_overlay.cpp index fe1ad3422..c6aabe2a1 100644 --- a/src/citron/util/vram_overlay.cpp +++ b/src/citron/util/vram_overlay.cpp @@ -162,8 +162,6 @@ void VramOverlay::DrawVramInfo(QPainter& painter) { switch (Settings::values.vram_usage_mode.GetValue()) { case Settings::VramUsageMode::Conservative: mode_text = QString::fromUtf8("Mode: Conservative"); break; case Settings::VramUsageMode::Aggressive: mode_text = QString::fromUtf8("Mode: Aggressive"); break; - case Settings::VramUsageMode::HighEnd: mode_text = QString::fromUtf8("Mode: High-End GPU"); break; - case Settings::VramUsageMode::Insane: mode_text = QString::fromUtf8("Mode: Insane"); painter.setPen(leak_warning_color); break; default: mode_text = QString::fromUtf8("Mode: Unknown"); break; } painter.drawText(section_padding, y_offset, mode_text); diff --git a/src/common/settings.h b/src/common/settings.h index 76fffa163..cfb01707b 100644 --- a/src/common/settings.h +++ b/src/common/settings.h @@ -499,7 +499,7 @@ struct Values { SwitchableSetting vram_usage_mode{linkage, VramUsageMode::Conservative, VramUsageMode::Conservative, - VramUsageMode::Insane, + VramUsageMode::Aggressive, "vram_usage_mode", Category::RendererAdvanced}; diff --git a/src/common/settings_enums.h b/src/common/settings_enums.h index 49ae303e9..e6bd1c186 100644 --- a/src/common/settings_enums.h +++ b/src/common/settings_enums.h @@ -406,8 +406,6 @@ inline u32 EnumMetadata::Index() { enum class VramUsageMode : u32 { Conservative = 0, Aggressive = 1, - HighEnd = 2, - Insane = 3, }; template <> @@ -416,8 +414,6 @@ EnumMetadata::Canonicalizations() { return { {"Conservative", VramUsageMode::Conservative}, {"Aggressive", VramUsageMode::Aggressive}, - {"HighEnd", VramUsageMode::HighEnd}, - {"Insane", VramUsageMode::Insane}, }; } diff --git a/src/video_core/renderer_vulkan/vk_buffer_cache.cpp b/src/video_core/renderer_vulkan/vk_buffer_cache.cpp index c786207f3..e7e8fd58b 100644 --- a/src/video_core/renderer_vulkan/vk_buffer_cache.cpp +++ b/src/video_core/renderer_vulkan/vk_buffer_cache.cpp @@ -70,40 +70,11 @@ vk::Buffer CreateBuffer(const Device& device, const MemoryAllocator& memory_allo flags |= VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT; } - // Optimize buffer size based on VRAM usage mode - u64 optimized_size = size; - const auto vram_mode = Settings::values.vram_usage_mode.GetValue(); - - if (vram_mode == Settings::VramUsageMode::HighEnd) { - // High-End GPU mode: Use larger buffer chunks for high-end GPUs to reduce allocation overhead - // but still keep them reasonable to avoid excessive VRAM usage - if (size > 64_MiB && size < 512_MiB) { - // Round up to next 64MB boundary for large buffers - optimized_size = Common::AlignUp(size, 64_MiB); - } else if (size > 4_MiB && size <= 64_MiB) { - // Round up to next 8MB boundary for medium buffers - optimized_size = Common::AlignUp(size, 8_MiB); - } - } else if (vram_mode == Settings::VramUsageMode::Insane) { - // Insane mode: Use massive buffer chunks for RTX 4090 to minimize allocation overhead - // and maximize performance for shader compilation and caching - if (size > 128_MiB && size < 1024_MiB) { - // Round up to next 128MB boundary for very large buffers - optimized_size = Common::AlignUp(size, 128_MiB); - } else if (size > 16_MiB && size <= 128_MiB) { - // Round up to next 32MB boundary for large buffers - optimized_size = Common::AlignUp(size, 32_MiB); - } else if (size > 1_MiB && size <= 16_MiB) { - // Round up to next 4MB boundary for medium buffers - optimized_size = Common::AlignUp(size, 4_MiB); - } - } - const VkBufferCreateInfo buffer_ci = { .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, .pNext = nullptr, .flags = 0, - .size = optimized_size, + .size = size, .usage = flags, .sharingMode = VK_SHARING_MODE_EXCLUSIVE, .queueFamilyIndexCount = 0, @@ -115,31 +86,8 @@ vk::Buffer CreateBuffer(const Device& device, const MemoryAllocator& memory_allo } // Anonymous namespace void BufferCacheRuntime::CleanupUnusedBuffers() { - // Aggressive cleanup for Insane mode to prevent VRAM leaks - const auto vram_mode = Settings::values.vram_usage_mode.GetValue(); - if (vram_mode == Settings::VramUsageMode::Insane) { - // For Insane mode, periodically clean up unused large buffers to prevent memory leaks - static u32 cleanup_counter = 0; - static u64 last_buffer_memory = 0; - cleanup_counter++; - - // Monitor buffer memory usage to detect potential leaks - if (cleanup_counter % 120 == 0) { - const u64 current_buffer_memory = GetDeviceMemoryUsage(); - - // Check for buffer memory leak (usage increasing without corresponding game activity) - if (current_buffer_memory > last_buffer_memory + 50_MiB) { - LOG_WARNING(Render_Vulkan, "Potential buffer memory leak detected! Usage increased by {} MB", - (current_buffer_memory - last_buffer_memory) / (1024 * 1024)); - - // Force cleanup of any cached buffers that might be accumulating - LOG_INFO(Render_Vulkan, "Performed aggressive buffer cleanup (Insane mode)"); - } - - last_buffer_memory = current_buffer_memory; - LOG_DEBUG(Render_Vulkan, "Buffer memory usage: {} MB (Insane mode)", current_buffer_memory / (1024 * 1024)); - } - } + // Cleanup is now handled by the VRAM management system (gc_aggressiveness setting) + // This function is kept for compatibility but no longer performs mode-specific cleanup } Buffer::Buffer(BufferCacheRuntime& runtime, VideoCommon::NullBufferParams null_params) diff --git a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp index c69f496da..520375840 100644 --- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp +++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp @@ -748,11 +748,8 @@ std::unique_ptr PipelineCache::CreateGraphicsPipeline( const auto runtime_info{MakeRuntimeInfo(programs, key, program, previous_stage)}; ConvertLegacyToGeneric(program, runtime_info); std::vector code = EmitSPIRV(profile, runtime_info, program, binding); - // Reserve more space for Insane mode to reduce allocations during shader compilation - const size_t reserve_size = Settings::values.vram_usage_mode.GetValue() == Settings::VramUsageMode::Insane - ? std::max(code.size(), 64 * 1024 / sizeof(u32)) // 64KB for Insane mode - : std::max(code.size(), 16 * 1024 / sizeof(u32)); // 16KB for other modes - code.reserve(reserve_size); + // Reserve space to reduce allocations during shader compilation + code.reserve(std::max(code.size(), 16 * 1024 / sizeof(u32))); device.SaveShader(code); modules[stage_index] = BuildShader(device, code); if (device.HasDebuggingToolAttached()) { @@ -854,11 +851,8 @@ std::unique_ptr PipelineCache::CreateComputePipeline( auto program{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)}; std::vector code = EmitSPIRV(profile, program); - // Reserve more space for Insane mode to reduce allocations during shader compilation - const size_t reserve_size = Settings::values.vram_usage_mode.GetValue() == Settings::VramUsageMode::Insane - ? std::max(code.size(), 64 * 1024 / sizeof(u32)) // 64KB for Insane mode - : std::max(code.size(), 16 * 1024 / sizeof(u32)); // 16KB for other modes - code.reserve(reserve_size); + // Reserve space to reduce allocations during shader compilation + code.reserve(std::max(code.size(), 16 * 1024 / sizeof(u32))); device.SaveShader(code); vk::ShaderModule spv_module{BuildShader(device, code)}; if (device.HasDebuggingToolAttached()) { diff --git a/src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp b/src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp index a6b331e05..deacda44e 100644 --- a/src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp +++ b/src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp @@ -99,24 +99,7 @@ void StagingBufferPool::FreeDeferred(StagingBufferRef& ref) { void StagingBufferPool::TickFrame() { current_delete_level = (current_delete_level + 1) % NUM_LEVELS; - // Enhanced cleanup for Insane mode to prevent VRAM leaks - const auto vram_mode = Settings::values.vram_usage_mode.GetValue(); - if (vram_mode == Settings::VramUsageMode::Insane) { - static u32 cleanup_counter = 0; - cleanup_counter++; - - // More aggressive cleanup for Insane mode every 30 frames - if (cleanup_counter % 30 == 0) { - // Force release of all caches to prevent memory accumulation - ReleaseCache(MemoryUsage::DeviceLocal); - ReleaseCache(MemoryUsage::Upload); - ReleaseCache(MemoryUsage::Download); - - // Additional cleanup for large staging buffers - LOG_DEBUG(Render_Vulkan, "Performed aggressive staging buffer cleanup (Insane mode)"); - } - } - + // Cleanup is now handled by the VRAM management system (gc_aggressiveness setting) ReleaseCache(MemoryUsage::DeviceLocal); ReleaseCache(MemoryUsage::Upload); ReleaseCache(MemoryUsage::Download); diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.cpp b/src/video_core/renderer_vulkan/vk_texture_cache.cpp index a5ca9b70b..07e1cd614 100644 --- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp +++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp @@ -939,29 +939,8 @@ VkBuffer TextureCacheRuntime::GetTemporaryBuffer(size_t needed_size) { return *buffers[level]; } - // Optimize buffer size based on VRAM usage mode - size_t new_size = Common::NextPow2(needed_size); - const auto vram_mode = Settings::values.vram_usage_mode.GetValue(); - - if (vram_mode == Settings::VramUsageMode::HighEnd) { - // For high-end GPUs, use larger temporary buffers to reduce allocation overhead - // but cap them to prevent excessive VRAM usage - if (needed_size > 32_MiB && needed_size < 256_MiB) { - new_size = Common::AlignUp(needed_size, 32_MiB); - } else if (needed_size > 2_MiB && needed_size <= 32_MiB) { - new_size = Common::AlignUp(needed_size, 4_MiB); - } - } else if (vram_mode == Settings::VramUsageMode::Insane) { - // Insane mode: Use massive temporary buffers for RTX 4090 to maximize texture caching - // and shader compilation performance - if (needed_size > 64_MiB && needed_size < 512_MiB) { - new_size = Common::AlignUp(needed_size, 64_MiB); - } else if (needed_size > 8_MiB && needed_size <= 64_MiB) { - new_size = Common::AlignUp(needed_size, 16_MiB); - } else if (needed_size > 1_MiB && needed_size <= 8_MiB) { - new_size = Common::AlignUp(needed_size, 2_MiB); - } - } + // Use power-of-2 buffer sizes for efficient allocation + const size_t new_size = Common::NextPow2(needed_size); static constexpr VkBufferUsageFlags flags = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | @@ -981,46 +960,8 @@ VkBuffer TextureCacheRuntime::GetTemporaryBuffer(size_t needed_size) { } void TextureCacheRuntime::CleanupUnusedBuffers() { - // Aggressive cleanup for Insane mode to prevent VRAM leaks - const auto vram_mode = Settings::values.vram_usage_mode.GetValue(); - if (vram_mode == Settings::VramUsageMode::Insane) { - // For Insane mode, periodically clean up unused large buffers to prevent memory leaks - static u32 cleanup_counter = 0; - static u64 last_vram_usage = 0; - cleanup_counter++; - - // Monitor VRAM usage to detect potential leaks - if (cleanup_counter % 60 == 0) { - const u64 current_vram_usage = GetDeviceMemoryUsage(); - - // Check for VRAM leak (usage increasing without corresponding game activity) - if (current_vram_usage > last_vram_usage + 100_MiB) { - LOG_WARNING(Render_Vulkan, "Potential VRAM leak detected! Usage increased by {} MB", - (current_vram_usage - last_vram_usage) / (1024 * 1024)); - - // Force aggressive cleanup - for (auto& buffer : buffers) { - if (buffer) { - buffer.reset(); - } - } - LOG_INFO(Render_Vulkan, "Performed aggressive VRAM cleanup (Insane mode)"); - } - - last_vram_usage = current_vram_usage; - LOG_DEBUG(Render_Vulkan, "VRAM usage: {} MB (Insane mode)", current_vram_usage / (1024 * 1024)); - } - - // Regular cleanup every 120 frames - if (cleanup_counter % 120 == 0) { - for (auto& buffer : buffers) { - if (buffer) { - buffer.reset(); - } - } - LOG_DEBUG(Render_Vulkan, "Cleaned up unused temporary buffers (Insane mode)"); - } - } + // Cleanup is now handled by the VRAM management system (gc_aggressiveness setting) + // This function is kept for compatibility but no longer performs mode-specific cleanup } void TextureCacheRuntime::BarrierFeedbackLoop() { diff --git a/src/video_core/vulkan_common/vulkan_device.cpp b/src/video_core/vulkan_common/vulkan_device.cpp index f05ff2372..f1318a045 100644 --- a/src/video_core/vulkan_common/vulkan_device.cpp +++ b/src/video_core/vulkan_common/vulkan_device.cpp @@ -1354,20 +1354,6 @@ void Device::CollectPhysicalMemoryInfo() { const size_t scaler_memory = 1_GiB * Settings::values.resolution_info.ScaleUp(1); device_access_memory = std::min(device_access_memory, normal_memory + scaler_memory); - } else if (vram_mode == Settings::VramUsageMode::HighEnd) { - // High-End GPU mode: Use more VRAM but with smart buffer management - // Allow up to 12GB for RTX 4090/4080+ users, but optimize buffer allocation - const size_t high_end_memory = 12_GiB; - const size_t scaler_memory = 1_GiB * Settings::values.resolution_info.ScaleUp(1); - device_access_memory = - std::min(device_access_memory, high_end_memory + scaler_memory); - } else if (vram_mode == Settings::VramUsageMode::Insane) { - // Insane mode: Use most of RTX 4090's 24GB VRAM for maximum performance - // Reserve only 2GB for system and other applications - const size_t insane_memory = 22_GiB; - const size_t scaler_memory = 2_GiB * Settings::values.resolution_info.ScaleUp(1); - device_access_memory = - std::min(device_access_memory, insane_memory + scaler_memory); } // Aggressive mode uses full available VRAM (no limits)