agent: Fix reading the entire threads database after every thread save (#66015)

Part of #64897. Also fixes the `threads.db` read traffic and lock stalls
reported in [this comment on
#59107](https://github.com/zed-industries/zed/issues/59107#issuecomment-5781374977).

During long agent sessions, Zed kept reading the whole `threads.db` file
in the background. The reporter saw about 150 MB/s of reads.

After every save, we reload the thread list. That only needs small
fields like the title and dates. But some of those fields were added to
the table later, so SQLite stores them after each thread's large `data`
blob, and has to go through the whole blob to reach them. On a 148 MB
test database with 120 threads, one reload read 37,958 pages, which is
the entire file.

This adds an index that holds just the fields the thread list needs.
SQLite now reads the list from the index and skips the blobs, and the
same reload reads 7 pages. The index starts with the dates, so SQLite
also gets the threads in newest-first order without sorting, but that
part is minor. A test checks that SQLite actually uses the index.

Moving `data` to the end of the table would fix it too. But `threads.db`
has no migration tracking, and that change would copy every thread's
blob on first launch. I went with the index since it's safer and doesn't
touch any existing rows.

Saving a thread 200 times in a row on that database (release build):

| | Before | After |
|---|---|---|
| Time per save | 22.2 ms | 2.4 ms |
| CPU time for 200 saves | 4.4 s | 0.47 s |

Memory use stays the same. The index takes about 24 KB, and Zed builds
it once on first launch, in the background. That took about 0.1 s for
148 MB.

Next, I'd like to update only the saved thread in the list, so we don't
reload the whole list after every save. That'll be a follow-up PR.

Release Notes:

- Improved CPU usage and disk reads while the agent is working,
especially with a long thread history.

---------

Co-authored-by: zed-zippy[bot] <234243425+zed-zippy[bot]@users.noreply.github.com>
This commit is contained in:
Smit Barmase
2026-10-23 08:23:02 +00:00
committed by GitHub
parent 18512de483
commit fda552edce
+55 -6
View File
@@ -18,7 +18,7 @@ use sqlez::{
};
use std::{io::ErrorKind, path::PathBuf, sync::Arc};
use ui::{App, SharedString};
use util::path_list::PathList;
use util::{ResultExt, path_list::PathList};
use zed_env_vars::ZED_STATELESS;
pub type DbMessage = crate::Message;
@@ -402,6 +402,8 @@ pub(crate) struct ThreadsDatabase {
save_count: std::sync::atomic::AtomicUsize,
}
const LIST_THREADS_QUERY: &str = "SELECT id, parent_id, folder_paths, folder_paths_order, summary, updated_at, created_at FROM threads ORDER BY updated_at DESC, created_at DESC";
struct GlobalThreadsDatabase(Shared<Task<Result<Arc<ThreadsDatabase>, Arc<anyhow::Error>>>>);
impl Global for GlobalThreadsDatabase {}
@@ -486,6 +488,19 @@ impl ThreadsDatabase {
}
}
// The columns added above are stored after the `data` blob, so reading
// them from the table walks every thread's overflow pages. This index
// covers `LIST_THREADS_QUERY`, so listing threads never touches the blobs.
connection
.exec(indoc! {"
CREATE INDEX IF NOT EXISTS threads_list_metadata ON threads (
updated_at, created_at, id, parent_id, folder_paths, folder_paths_order, summary
)
"})
.and_then(|mut create_index| create_index())
.map_err(|e| e.context("Failed to create threads list index"))
.log_err();
let db = Self {
executor,
connection: Arc::new(Mutex::new(connection)),
@@ -579,15 +594,29 @@ impl ThreadsDatabase {
self.executor.spawn(async move {
let connection = connection.lock();
let mut select = connection
.select_bound::<(), (Arc<str>, Option<Arc<str>>, Option<String>, Option<String>, String, String, Option<String>)>(indoc! {"
SELECT id, parent_id, folder_paths, folder_paths_order, summary, updated_at, created_at FROM threads ORDER BY updated_at DESC, created_at DESC
"})?;
let mut select = connection.select_bound::<(), (
Arc<str>,
Option<Arc<str>>,
Option<String>,
Option<String>,
String,
String,
Option<String>,
)>(LIST_THREADS_QUERY)?;
let rows = select(())?;
let mut threads = Vec::new();
for (id, parent_id, folder_paths, folder_paths_order, summary, updated_at, created_at) in rows {
for (
id,
parent_id,
folder_paths,
folder_paths_order,
summary,
updated_at,
created_at,
) in rows
{
let folder_paths = folder_paths
.map(|paths| {
PathList::deserialize(&util::path_list::SerializedPathList {
@@ -976,6 +1005,26 @@ mod tests {
assert_eq!(entries[1].id, older_id);
}
#[gpui::test]
async fn test_list_threads_reads_only_the_index(cx: &mut TestAppContext) {
let database = ThreadsDatabase::new(cx.executor()).unwrap();
let plan = database
.connection
.lock()
.select::<(i32, i32, i32, String)>(&format!("EXPLAIN QUERY PLAN {LIST_THREADS_QUERY}"))
.unwrap()()
.unwrap();
let details = plan
.into_iter()
.map(|(_, _, _, detail)| detail)
.collect::<Vec<_>>();
assert_eq!(
details,
["SCAN threads USING COVERING INDEX threads_list_metadata"]
);
}
#[gpui::test]
async fn test_save_thread_replaces_metadata(cx: &mut TestAppContext) {
let database = ThreadsDatabase::new(cx.executor()).unwrap();