mirror of
https://github.com/RPCS3/rpcs3.git
synced 2025-07-05 14:31:24 +12:00
112 lines
2.8 KiB
C++
112 lines
2.8 KiB
C++
#include "stdafx.h"
|
|
#include "cache_utils.hpp"
|
|
#include "system_utils.hpp"
|
|
#include "system_config.h"
|
|
#include "IdManager.h"
|
|
#include "Emu/Cell/PPUAnalyser.h"
|
|
#include "Emu/Cell/PPUThread.h"
|
|
|
|
LOG_CHANNEL(sys_log, "SYS");
|
|
|
|
namespace rpcs3::cache
|
|
{
|
|
std::string get_ppu_cache()
|
|
{
|
|
auto& _main = g_fxo->get<ppu_module>();
|
|
|
|
if (!g_fxo->is_init<ppu_module>() || _main.cache.empty())
|
|
{
|
|
ppu_log.warning("PPU Cache location not initialized.");
|
|
return {};
|
|
}
|
|
|
|
return _main.cache;
|
|
}
|
|
|
|
void limit_cache_size()
|
|
{
|
|
const std::string cache_location = rpcs3::utils::get_hdd1_dir() + "/caches";
|
|
|
|
if (!fs::is_dir(cache_location))
|
|
{
|
|
sys_log.warning("Cache does not exist (%s)", cache_location);
|
|
return;
|
|
}
|
|
|
|
const u64 size = fs::get_dir_size(cache_location);
|
|
|
|
if (size == umax)
|
|
{
|
|
sys_log.error("Could not calculate cache directory '%s' size (%s)", cache_location, fs::g_tls_error);
|
|
return;
|
|
}
|
|
|
|
const u64 max_size = static_cast<u64>(g_cfg.vfs.cache_max_size) * 1024 * 1024;
|
|
|
|
if (max_size == 0) // Everything must go, so no need to do checks
|
|
{
|
|
fs::remove_all(cache_location, false);
|
|
sys_log.success("Cleared disk cache");
|
|
return;
|
|
}
|
|
|
|
if (size <= max_size)
|
|
{
|
|
sys_log.trace("Cache size below limit: %llu/%llu", size, max_size);
|
|
return;
|
|
}
|
|
|
|
sys_log.success("Cleaning disk cache...");
|
|
std::vector<fs::dir_entry> file_list{};
|
|
fs::dir cache_dir(cache_location);
|
|
if (!cache_dir)
|
|
{
|
|
sys_log.error("Could not open cache directory '%s' (%s)", cache_location, fs::g_tls_error);
|
|
return;
|
|
}
|
|
|
|
// retrieve items to delete
|
|
for (const auto &item : cache_dir)
|
|
{
|
|
if (item.name != "." && item.name != "..")
|
|
file_list.push_back(item);
|
|
}
|
|
|
|
cache_dir.close();
|
|
|
|
// sort oldest first
|
|
std::sort(file_list.begin(), file_list.end(), [](auto left, auto right)
|
|
{
|
|
return left.mtime < right.mtime;
|
|
});
|
|
|
|
// keep removing until cache is empty or enough bytes have been cleared
|
|
// cache is cleared down to 80% of limit to increase interval between clears
|
|
const u64 to_remove = static_cast<u64>(size - max_size * 0.8);
|
|
u64 removed = 0;
|
|
for (const auto &item : file_list)
|
|
{
|
|
const std::string &name = cache_location + "/" + item.name;
|
|
const bool is_dir = fs::is_dir(name);
|
|
const u64 item_size = is_dir ? fs::get_dir_size(name) : item.size;
|
|
|
|
if (is_dir && item_size == umax)
|
|
{
|
|
sys_log.error("Failed to calculate '%s' item '%s' size (%s)", cache_location, item.name, fs::g_tls_error);
|
|
break;
|
|
}
|
|
|
|
if (is_dir ? !fs::remove_all(name, true) : !fs::remove_file(name))
|
|
{
|
|
sys_log.error("Could not remove cache directory '%s' item '%s' (%s)", cache_location, item.name, fs::g_tls_error);
|
|
break;
|
|
}
|
|
|
|
removed += item_size;
|
|
if (removed >= to_remove)
|
|
break;
|
|
}
|
|
|
|
sys_log.success("Cleaned disk cache, removed %.2f MB", size / 1024.0 / 1024.0);
|
|
}
|
|
}
|