drifty/emulator
1
0
Fork 0
mirror of https://git.citron-emu.org/citron/emulator synced 2026-02-03 08:03:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor(settings): simplify VRAM usage mode to Conservative/Aggressive

Browse Source 
The removed modes added complexity without significant benefit now that
the new VRAM management system (gc_aggressiveness, vram_limit_mb)
provides finer-grained control over memory pressure.

Signed-off-by: Zephyron <zephyron@citron-emu.org>
This commit is contained in:
Zephyron
2026-01-25 15:29:25 +10:00
parent 3e2137a470
commit 8eaa38540c
10 changed files with 13 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/android/app/src/main/res/values/arrays.xml
View File

@@ -429,15 +429,11 @@
<string-array name="vramUsageModeNames">
<item>Conservative</item>
<item>Aggressive</item>
<item>High-End GPU (4090/4080+)</item>
<item>Insane (RTX 4090 24GB)</item>
</string-array>
<integer-array name="vramUsageModeValues">
<item>0</item>
<item>1</item>
<item>2</item>
<item>3</item>
</integer-array>
<!-- VRAM Management setting arrays (FIXED: VRAM leak prevention) -->

2
src/citron/configuration/shared_translation.cpp
View File

@@ -382,8 +382,6 @@ std::unique_ptr<ComboboxTranslationMap> 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<Settings::ExtendedDynamicState>::Index(),
{

2
src/citron/util/vram_overlay.cpp
View File

@@ -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);

2
src/common/settings.h
View File

@@ -499,7 +499,7 @@ struct Values {
SwitchableSetting<VramUsageMode, true> vram_usage_mode{linkage,
VramUsageMode::Conservative,
VramUsageMode::Conservative,
VramUsageMode::Insane,
VramUsageMode::Aggressive,
"vram_usage_mode",
Category::RendererAdvanced};

4
src/common/settings_enums.h
View File

@@ -406,8 +406,6 @@ inline u32 EnumMetadata<VSyncMode>::Index() {
enum class VramUsageMode : u32 {
Conservative = 0,
Aggressive = 1,
HighEnd = 2,
Insane = 3,
};
template <>
@@ -416,8 +414,6 @@ EnumMetadata<VramUsageMode>::Canonicalizations() {
return {
{"Conservative", VramUsageMode::Conservative},
{"Aggressive", VramUsageMode::Aggressive},
{"HighEnd", VramUsageMode::HighEnd},
{"Insane", VramUsageMode::Insane},
};
}

58
src/video_core/renderer_vulkan/vk_buffer_cache.cpp
View File

@@ -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)

14
src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
View File

@@ -748,11 +748,8 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
const auto runtime_info{MakeRuntimeInfo(programs, key, program, previous_stage)};
ConvertLegacyToGeneric(program, runtime_info);
std::vector<u32> 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<size_t>(code.size(), 64 * 1024 / sizeof(u32)) // 64KB for Insane mode
: std::max<size_t>(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<size_t>(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<ComputePipeline> PipelineCache::CreateComputePipeline(
auto program{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
std::vector<u32> 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<size_t>(code.size(), 64 * 1024 / sizeof(u32)) // 64KB for Insane mode
: std::max<size_t>(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<size_t>(code.size(), 16 * 1024 / sizeof(u32)));
device.SaveShader(code);
vk::ShaderModule spv_module{BuildShader(device, code)};
if (device.HasDebuggingToolAttached()) {

19
src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp
View File

@@ -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);

67
src/video_core/renderer_vulkan/vk_texture_cache.cpp
View File

@@ -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() {

14
src/video_core/vulkan_common/vulkan_device.cpp
View File

@@ -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<u64>(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<u64>(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<u64>(device_access_memory, insane_memory + scaler_memory);
}
// Aggressive mode uses full available VRAM (no limits)