From 14dc9e8ca2cefe79243933a1d9a4483cdbfe06af Mon Sep 17 00:00:00 2001 From: Aliaksandr Kalenik Date: Fri, 17 Apr 2026 16:54:21 +0200 Subject: [PATCH] LibHTTP: Short-circuit CacheIndex eviction when under its size limit remove_entries_exceeding_cache_limit() is called after every network response, but the cache is usually still under budget and nothing needs to evict. Every one of those calls currently still runs the window-function eviction SQL over the whole CacheIndex table just to conclude there is nothing to do. Short-circuit the call when the cache is already within its configured size limit. To make that check cheap, maintain m_total_estimated_size as a running total of the cache's estimated byte size, so the no-op case becomes a single u64 compare and the DB is only touched when there is real work. Bookkeeping: - Seed the total in CacheIndex::create() via a new select_total_estimated_size statement (COALESCE(..., 0) so an empty index returns 0 rather than NULL). - Each Entry caches serialized_request_headers_size and serialized_response_headers_size so we don't re-serialize to recompute its footprint; Entry::estimated_size() centralizes the arithmetic. - create_entry() adds the new entry's size. Any row it displaces is removed via DELETE ... RETURNING so the total stays accurate even for entries that were never loaded into m_entries. - remove_entry() and the bulk DELETE statements were extended with the same RETURNING clause for the same reason. - update_response_headers() shifts the total by the signed delta between old and new serialized header size. Also COALESCEs estimate_cache_size_accessed_since over an empty table to 0 so callers don't have to special-case NULL. --- Libraries/LibHTTP/Cache/CacheIndex.cpp | 79 ++++++++++++++++++++++---- Libraries/LibHTTP/Cache/CacheIndex.h | 11 +++- 2 files changed, 77 insertions(+), 13 deletions(-) diff --git a/Libraries/LibHTTP/Cache/CacheIndex.cpp b/Libraries/LibHTTP/Cache/CacheIndex.cpp index 45819bbe282..47af52931e4 100644 --- a/Libraries/LibHTTP/Cache/CacheIndex.cpp +++ b/Libraries/LibHTTP/Cache/CacheIndex.cpp @@ -98,8 +98,16 @@ ErrorOr CacheIndex::create(Database::Database& database, LexicalPath Statements statements {}; statements.insert_entry = TRY(database.prepare_statement("INSERT OR REPLACE INTO CacheIndex VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?);"sv)); - statements.remove_entry = TRY(database.prepare_statement("DELETE FROM CacheIndex WHERE cache_key = ? AND vary_key = ?;"sv)); - statements.remove_entries_accessed_since = TRY(database.prepare_statement("DELETE FROM CacheIndex WHERE last_access_time >= ? RETURNING cache_key, vary_key;"sv)); + statements.remove_entry = TRY(database.prepare_statement(R"#( + DELETE FROM CacheIndex + WHERE cache_key = ? AND vary_key = ? + RETURNING data_size + OCTET_LENGTH(request_headers) + OCTET_LENGTH(response_headers); + )#"sv)); + statements.remove_entries_accessed_since = TRY(database.prepare_statement(R"#( + DELETE FROM CacheIndex + WHERE last_access_time >= ? + RETURNING cache_key, vary_key, data_size + OCTET_LENGTH(request_headers) + OCTET_LENGTH(response_headers); + )#"sv)); statements.select_entries = TRY(database.prepare_statement("SELECT * FROM CacheIndex WHERE cache_key = ?;"sv)); statements.update_response_headers = TRY(database.prepare_statement("UPDATE CacheIndex SET response_headers = ? WHERE cache_key = ? AND vary_key = ?;"sv)); statements.update_last_access_time = TRY(database.prepare_statement("UPDATE CacheIndex SET last_access_time = ? WHERE cache_key = ? AND vary_key = ?;"sv)); @@ -120,15 +128,20 @@ ErrorOr CacheIndex::create(Database::Database& database, LexicalPath FROM RankedCacheIndex WHERE cumulative_estimated_size > ? ) - RETURNING cache_key, vary_key; + RETURNING cache_key, vary_key, data_size + OCTET_LENGTH(request_headers) + OCTET_LENGTH(response_headers); )#"sv)); statements.estimate_cache_size_accessed_since = TRY(database.prepare_statement(R"#( - SELECT SUM(data_size + OCTET_LENGTH(request_headers) + OCTET_LENGTH(response_headers)) + SELECT COALESCE(SUM(data_size + OCTET_LENGTH(request_headers) + OCTET_LENGTH(response_headers)), 0) FROM CacheIndex WHERE last_access_time >= ?; )#"sv)); + statements.select_total_estimated_size = TRY(database.prepare_statement(R"#( + SELECT COALESCE(SUM(data_size + OCTET_LENGTH(request_headers) + OCTET_LENGTH(response_headers)), 0) + FROM CacheIndex; + )#"sv)); + auto disk_space = TRY(FileSystem::compute_disk_space(cache_directory)); auto maximum_disk_cache_size = compute_maximum_disk_cache_size(disk_space.free_bytes); @@ -138,13 +151,19 @@ ErrorOr CacheIndex::create(Database::Database& database, LexicalPath .maximum_disk_cache_entry_size = compute_maximum_disk_cache_entry_size(maximum_disk_cache_size), }; - return CacheIndex { database, statements, limits }; + u64 total_estimated_size { 0 }; + database.execute_statement( + statements.select_total_estimated_size, + [&](auto statement_id) { total_estimated_size = database.result_column(statement_id, 0); }); + + return CacheIndex { database, statements, limits, total_estimated_size }; } -CacheIndex::CacheIndex(Database::Database& database, Statements statements, Limits limits) +CacheIndex::CacheIndex(Database::Database& database, Statements statements, Limits limits, u64 total_estimated_size) : m_database(database) , m_statements(statements) , m_limits(limits) + , m_total_estimated_size(total_estimated_size) { } @@ -164,19 +183,31 @@ ErrorOr CacheIndex::create_entry(u64 cache_key, u64 vary_key, String url, auto serialized_request_headers = serialize_headers(request_headers); auto serialized_response_headers = serialize_headers(response_headers); - if (data_size + serialized_request_headers.length() + serialized_response_headers.length() > m_limits.maximum_disk_cache_entry_size) - return Error::from_string_literal("Cache entry size exceeds allowed maximum"); - Entry entry { .vary_key = vary_key, .url = move(url), .request_headers = move(request_headers), .response_headers = move(response_headers), .data_size = data_size, + .serialized_request_headers_size = static_cast(serialized_request_headers.length()), + .serialized_response_headers_size = static_cast(serialized_response_headers.length()), .request_time = request_time, .response_time = response_time, .last_access_time = now, }; + auto entry_size = entry.estimated_size(); + + if (entry_size > m_limits.maximum_disk_cache_entry_size) + return Error::from_string_literal("Cache entry size exceeds allowed maximum"); + + m_database->execute_statement( + m_statements.remove_entry, + [&](auto statement_id) { + auto removed_size = m_database->result_column(statement_id, 0); + m_total_estimated_size -= removed_size; + }, + cache_key, + vary_key); auto& entries = m_entries.ensure(cache_key); auto existing_entry_index = entries.find_first_index_if([&](auto const& existing_entry) { @@ -190,22 +221,37 @@ ErrorOr CacheIndex::create_entry(u64 cache_key, u64 vary_key, String url, else entries.append(move(entry)); + m_total_estimated_size += entry_size; + return {}; } void CacheIndex::remove_entry(u64 cache_key, u64 vary_key) { - m_database->execute_statement(m_statements.remove_entry, {}, cache_key, vary_key); + m_database->execute_statement( + m_statements.remove_entry, + [&](auto statement_id) { + auto removed_size = m_database->result_column(statement_id, 0); + m_total_estimated_size -= removed_size; + }, + cache_key, + vary_key); + delete_entry(cache_key, vary_key); } void CacheIndex::remove_entries_exceeding_cache_limit(Function on_entry_removed) { + if (m_total_estimated_size <= m_limits.maximum_disk_cache_size) + return; + m_database->execute_statement( m_statements.remove_entries_exceeding_cache_limit, [&](auto statement_id) { auto cache_key = m_database->result_column(statement_id, 0); auto vary_key = m_database->result_column(statement_id, 1); + auto removed_size = m_database->result_column(statement_id, 2); + m_total_estimated_size -= removed_size; delete_entry(cache_key, vary_key); if (on_entry_removed) @@ -221,6 +267,8 @@ void CacheIndex::remove_entries_accessed_since(UnixDateTime since, Functionresult_column(statement_id, 0); auto vary_key = m_database->result_column(statement_id, 1); + auto removed_size = m_database->result_column(statement_id, 2); + m_total_estimated_size -= removed_size; delete_entry(cache_key, vary_key); if (on_entry_removed) @@ -235,8 +283,15 @@ void CacheIndex::update_response_headers(u64 cache_key, u64 vary_key, NonnullRef if (!entry.has_value()) return; - m_database->execute_statement(m_statements.update_response_headers, {}, serialize_headers(response_headers), cache_key, vary_key); + auto serialized_response_headers = serialize_headers(response_headers); + auto serialized_response_headers_size = static_cast(serialized_response_headers.length()); + + m_database->execute_statement(m_statements.update_response_headers, {}, serialized_response_headers, cache_key, vary_key); + + m_total_estimated_size -= entry->serialized_response_headers_size; + m_total_estimated_size += serialized_response_headers_size; entry->response_headers = move(response_headers); + entry->serialized_response_headers_size = serialized_response_headers_size; } void CacheIndex::update_last_access_time(u64 cache_key, u64 vary_key) @@ -270,7 +325,7 @@ Optional CacheIndex::find_entry(u64 cache_key, HeaderL auto response_time = m_database->result_column(statement_id, column++); auto last_access_time = m_database->result_column(statement_id, column++); - entries.empend(vary_key, move(url), deserialize_headers(request_headers), deserialize_headers(response_headers), data_size, request_time, response_time, last_access_time); + entries.empend(vary_key, move(url), deserialize_headers(request_headers), deserialize_headers(response_headers), data_size, request_headers.length(), response_headers.length(), request_time, response_time, last_access_time); }, cache_key); diff --git a/Libraries/LibHTTP/Cache/CacheIndex.h b/Libraries/LibHTTP/Cache/CacheIndex.h index 99881caed64..858f64fcca8 100644 --- a/Libraries/LibHTTP/Cache/CacheIndex.h +++ b/Libraries/LibHTTP/Cache/CacheIndex.h @@ -27,10 +27,17 @@ class CacheIndex { NonnullRefPtr request_headers; NonnullRefPtr response_headers; u64 data_size { 0 }; + u64 serialized_request_headers_size { 0 }; + u64 serialized_response_headers_size { 0 }; UnixDateTime request_time; UnixDateTime response_time; UnixDateTime last_access_time; + + u64 estimated_size() const + { + return data_size + serialized_request_headers_size + serialized_response_headers_size; + } }; public: @@ -60,6 +67,7 @@ private: Database::StatementID update_response_headers { 0 }; Database::StatementID update_last_access_time { 0 }; Database::StatementID estimate_cache_size_accessed_since { 0 }; + Database::StatementID select_total_estimated_size { 0 }; }; struct Limits { @@ -68,7 +76,7 @@ private: u64 maximum_disk_cache_entry_size { 0 }; }; - CacheIndex(Database::Database&, Statements, Limits); + CacheIndex(Database::Database&, Statements, Limits, u64 total_estimated_size); Optional get_entry(u64 cache_key, u64 vary_key); void delete_entry(u64 cache_key, u64 vary_key); @@ -79,6 +87,7 @@ private: HashMap, IdentityHashTraits> m_entries; Limits m_limits; + u64 m_total_estimated_size { 0 }; }; }