Upgrade GPUI to wgpu 30 and speed up startup

Cargo.toml

@@ -163,12 +163,12 @@ futures = "0.3.34"
 gix = { version = "0.89.0", default-features = false, features = ["max-performance-safe", "comfort", "basic", "status", "blame", "sha1", "sha256"] }
 # Already in the tree via gix; Git-compatible quoting for attribute patterns.
 gix-quote = "0.10.0"
-gpui = { package = "gpui-ce", git = "https://github.com/Havunen/gpui-ce.git", rev = "0665fb07d59cf7af185e58f44b9f890590abe204" }
-gpui_platform = { package = "gpui_ce_platform", git = "https://github.com/Havunen/gpui-ce.git", rev = "0665fb07d59cf7af185e58f44b9f890590abe204", features = ["font-kit"] }
-gpui_wgpu = { package = "gpui_ce_wgpu", git = "https://github.com/Havunen/gpui-ce.git", rev = "0665fb07d59cf7af185e58f44b9f890590abe204" }
-gpui_parley = { package = "gpui_ce_parley", git = "https://github.com/Havunen/gpui-ce.git", rev = "0665fb07d59cf7af185e58f44b9f890590abe204", default-features = false }
-gpui_shared_string = { package = "gpui_ce_shared_string", git = "https://github.com/Havunen/gpui-ce.git", rev = "0665fb07d59cf7af185e58f44b9f890590abe204" }
-gpui_sum_tree = { package = "gpui_ce_sum_tree", git = "https://github.com/Havunen/gpui-ce.git", rev = "0665fb07d59cf7af185e58f44b9f890590abe204" }
+gpui = { package = "gpui-ce", git = "https://github.com/Havunen/gpui-ce.git", rev = "1b6f3cedafcd97fa15e6bc5fdbb8f34cc805afc0" }
+gpui_platform = { package = "gpui_ce_platform", git = "https://github.com/Havunen/gpui-ce.git", rev = "1b6f3cedafcd97fa15e6bc5fdbb8f34cc805afc0", features = ["font-kit"] }
+gpui_wgpu = { package = "gpui_ce_wgpu", git = "https://github.com/Havunen/gpui-ce.git", rev = "1b6f3cedafcd97fa15e6bc5fdbb8f34cc805afc0" }
+gpui_parley = { package = "gpui_ce_parley", git = "https://github.com/Havunen/gpui-ce.git", rev = "1b6f3cedafcd97fa15e6bc5fdbb8f34cc805afc0", default-features = false }
+gpui_shared_string = { package = "gpui_ce_shared_string", git = "https://github.com/Havunen/gpui-ce.git", rev = "1b6f3cedafcd97fa15e6bc5fdbb8f34cc805afc0" }
+gpui_sum_tree = { package = "gpui_ce_sum_tree", git = "https://github.com/Havunen/gpui-ce.git", rev = "1b6f3cedafcd97fa15e6bc5fdbb8f34cc805afc0" }
 image = "0.25.10"
 fast_image_resize = { version = "6.1.0", features = ["image"] }
 # Already in the dependency graph; merges sorted reference streams lazily.

crates/gitcomet-app/src/launch.rs

@@ -146,7 +146,10 @@ pub(crate) fn run_mode(
     #[cfg(not(feature = "ui-gpui-runtime"))]
     let () = extensions;
 
-    install_configured_git_executable_preference(&mode);
+    {
+        let _stage = gitcomet_core::startup_trace::span("git_executable_preference");
+        install_configured_git_executable_preference(&mode);
+    }
     #[cfg(feature = "ui-gpui-runtime")]
     let backend = || build_backend(&repository_options, backend_override.clone());
     #[cfg(not(feature = "ui-gpui-runtime"))]
@@ -261,7 +264,11 @@ fn run_browser(
     }
 
     let path = browser_instance::normalize_browser_path(path);
-    let browser_open_target = gitcomet_state::session::load()
+    let session = {
+        let _stage = gitcomet_core::startup_trace::span("browser_session_load");
+        gitcomet_state::session::load()
+    };
+    let browser_open_target = session
         .browser_open_target
         .as_deref()
         .and_then(gitcomet_ui_gpui::BrowserOpenTarget::from_key)
@@ -270,18 +277,21 @@ fn run_browser(
         path: path.clone(),
         target: browser_open_target,
     };
-    let mut browser_instance =
-        match browser_instance::start_or_forward(initial_browser_request.clone()) {
-            Ok(browser_instance::StartResult::Forwarded) => return exit_code::SUCCESS,
-            Ok(browser_instance::StartResult::Primary(primary)) => Some(primary),
-            Err(err) => {
-                eprintln!(
-                    "Could not initialize the {name} browser-instance broker; \
+    let instance_result = {
+        let _stage = gitcomet_core::startup_trace::span("browser_instance_broker");
+        browser_instance::start_or_forward(initial_browser_request.clone())
+    };
+    let mut browser_instance = match instance_result {
+        Ok(browser_instance::StartResult::Forwarded) => return exit_code::SUCCESS,
+        Ok(browser_instance::StartResult::Primary(primary)) => Some(primary),
+        Err(err) => {
+            eprintln!(
+                "Could not initialize the {name} browser-instance broker; \
                      launching this process independently: {err}"
-                );
-                None
-            }
-        };
+            );
+            None
+        }
+    };
     let browser_requests = browser_instance
         .as_mut()
         .and_then(browser_instance::PrimaryBrowserInstance::take_requests);
@@ -295,17 +305,25 @@ fn run_browser(
         let _ = std::thread::Builder::new()
             .name("git-probe".into())
             .spawn(move || {
+                let _stage = gitcomet_core::startup_trace::span("git_runtime_probe_background");
                 let _ = probe.run();
             });
     }
 
-    let startup_crash_report = crashlog::take_startup_report();
+    let startup_crash_report = {
+        let _stage = gitcomet_core::startup_trace::span("startup_crash_report");
+        crashlog::take_startup_report()
+    };
     if let Some(report) = startup_crash_report.as_ref() {
         // Keep the recovery path visible even if WSLg cannot create
         // a window for the in-app notification.
         print_startup_crash_report_hint(report);
     }
-    if let Err(err) = crashlog::begin_session() {
+    let crash_session_result = {
+        let _stage = gitcomet_core::startup_trace::span("crashlog_begin_session");
+        crashlog::begin_session()
+    };
+    if let Err(err) = crash_session_result {
         eprintln!("Failed to create {name} crash-recovery marker before UI launch: {err}");
     }
     let startup_report = startup_crash_report.map(|report| gitcomet_ui_gpui::StartupCrashReport {

crates/gitcomet-app/src/lib.rs

@@ -142,6 +142,7 @@ impl AppLaunch {
 
     /// Runs with `args` (including the program name) and returns the exit code.
     pub fn run_with_args(self, args: Vec<OsString>) -> i32 {
+        gitcomet_core::startup_trace::mark("app_entry");
         let Self {
             identity,
             about,
@@ -157,9 +158,16 @@ impl AppLaunch {
         }
 
         #[cfg(feature = "ui-gpui-runtime")]
-        crashlog::install();
+        {
+            let _stage = gitcomet_core::startup_trace::span("crashlog_install");
+            crashlog::install();
+        }
 
-        dispatch(cli::parse_cli(args, &about), on_prepare, move |mode| {
+        let parsed = {
+            let _stage = gitcomet_core::startup_trace::span("parse_cli");
+            cli::parse_cli(args, &about)
+        };
+        dispatch(parsed, on_prepare, move |mode| {
             launch::run_mode(mode, extensions, repository_options, backend)
         })
     }

crates/gitcomet-base/Cargo.toml

@@ -17,6 +17,7 @@ test-support = []
 
 [dependencies]
 serde = { workspace = true }
+serde_json = { workspace = true }
 sysinfo = { workspace = true }
 tempfile = { workspace = true }
 

crates/gitcomet-base/src/lib.rs

@@ -11,6 +11,7 @@ mod loadable;
 pub mod op_trace;
 pub mod panic;
 pub mod platform;
+pub mod startup_trace;
 
 pub use loadable::Loadable;
 

crates/gitcomet-base/src/startup_trace.rs

@@ -0,0 +1,187 @@
+//! Opt-in startup stage timings, available before the native UI exists.
+//!
+//! Set `GITCOMET_STARTUP_TRACE` to a local file path. Each line is JSON; begin
+//! records survive a stalled stage and end records include its duration. The
+//! file is appended, with a process id on every record. No repository paths,
+//! environment values or command arguments are recorded.
+
+use std::fs::{File, OpenOptions};
+use std::io::Write;
+use std::sync::{Mutex, OnceLock};
+use std::time::Instant;
+
+static TRACE: OnceLock<Option<Trace>> = OnceLock::new();
+
+struct Trace {
+    origin: Instant,
+    file: Mutex<File>,
+}
+
+fn trace() -> Option<&'static Trace> {
+    TRACE
+        .get_or_init(|| {
+            let path = std::env::var_os("GITCOMET_STARTUP_TRACE").filter(|p| !p.is_empty())?;
+            let origin = Instant::now();
+            match OpenOptions::new().create(true).append(true).open(path) {
+                Ok(file) => Some(Trace {
+                    origin,
+                    file: Mutex::new(file),
+                }),
+                Err(error) => {
+                    crate::write_stderr_line(format_args!("Cannot open startup trace: {error}"));
+                    None
+                }
+            }
+        })
+        .as_ref()
+}
+
+pub fn is_enabled() -> bool {
+    trace().is_some()
+}
+
+/// A timestamp relative to the earliest startup trace call in this process.
+pub fn mark(name: &'static str) {
+    if let Some(trace) = trace() {
+        trace.write("mark", name, None);
+    }
+}
+
+/// Times a synchronous stage. Keep the guard alive only for that stage, not
+/// for the whole event loop. Disabled tracing does not read the clock.
+#[must_use = "the startup stage ends when its guard drops"]
+pub fn span(name: &'static str) -> Span {
+    Span(trace().map(|trace| {
+        trace.write("begin", name, None);
+        (name, Instant::now())
+    }))
+}
+
+pub struct Span(Option<(&'static str, Instant)>);
+
+impl Drop for Span {
+    fn drop(&mut self) {
+        if let Some((name, started)) = self.0
+            && let Some(trace) = trace()
+        {
+            trace.write("end", name, Some(started.elapsed().as_secs_f64() * 1_000.0));
+        }
+    }
+}
+
+impl Trace {
+    fn write(&self, kind: &str, name: &str, duration_ms: Option<f64>) {
+        let thread = std::thread::current();
+        let record = record(
+            kind,
+            name,
+            self.origin.elapsed().as_secs_f64() * 1_000.0,
+            duration_ms,
+            thread.name(),
+        );
+        if let Ok(mut file) = self.file.lock() {
+            let _ = write_record(&mut *file, &record);
+        }
+    }
+}
+
+fn write_record(writer: &mut impl Write, record: &serde_json::Value) -> std::io::Result<()> {
+    // Value's Display implementation streams many tiny writes. Assemble one
+    // complete record so tracing does not add a filesystem call per JSON token.
+    let line = format!("{record}\n");
+    writer.write_all(line.as_bytes())
+}
+
+fn record(
+    kind: &str,
+    name: &str,
+    elapsed_ms: f64,
+    duration_ms: Option<f64>,
+    thread: Option<&str>,
+) -> serde_json::Value {
+    serde_json::json!({
+        "kind": kind,
+        "name": name,
+        "elapsed_ms": elapsed_ms,
+        "duration_ms": duration_ms,
+        "pid": std::process::id(),
+        "thread": thread,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn stage_records_are_json_with_distinct_elapsed_and_stage_duration() {
+        let value = record("end", "native_application", 125.0, Some(95.0), Some("main"));
+        let parsed: serde_json::Value = serde_json::from_str(&value.to_string()).unwrap();
+        assert_eq!(parsed["elapsed_ms"], 125.0);
+        assert_eq!(parsed["duration_ms"], 95.0);
+        assert_eq!(parsed["pid"], std::process::id());
+        assert_eq!(parsed["name"], "native_application");
+    }
+
+    #[test]
+    fn trace_writes_each_record_as_a_complete_line_without_waiting_for_shutdown() {
+        let temporary = tempfile::NamedTempFile::new().unwrap();
+        let trace = Trace {
+            origin: Instant::now(),
+            file: Mutex::new(temporary.reopen().unwrap()),
+        };
+        trace.write("begin", "font\"catalog\n日本語", None);
+        let first = std::fs::read_to_string(temporary.path()).unwrap();
+        assert_eq!(first.lines().count(), 1);
+        let first: serde_json::Value = serde_json::from_str(first.trim_end()).unwrap();
+        assert_eq!(first["name"], "font\"catalog\n日本語");
+        trace.write("end", "font\"catalog\n日本語", Some(2.0));
+        let contents = std::fs::read_to_string(temporary.path()).unwrap();
+        let rows: Vec<serde_json::Value> = contents
+            .lines()
+            .map(|line| serde_json::from_str(line).unwrap())
+            .collect();
+        assert_eq!(rows.len(), 2);
+        assert_eq!(rows[0]["kind"], "begin");
+        assert_eq!(rows[0]["name"], "font\"catalog\n日本語");
+        assert!(rows[0]["duration_ms"].is_null());
+        assert_eq!(rows[1]["duration_ms"], 2.0);
+    }
+
+    #[test]
+    fn trace_serializes_one_complete_record_per_write_without_changing_timestamps() {
+        #[derive(Default)]
+        struct Writes(Vec<Vec<u8>>);
+        impl std::io::Write for Writes {
+            fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
+                self.0.push(bytes.to_vec());
+                Ok(bytes.len())
+            }
+            fn flush(&mut self) -> std::io::Result<()> {
+                Ok(())
+            }
+        }
+
+        let value = record(
+            "end",
+            "quote\" slash\\ newline\n雪",
+            125.125,
+            Some(95.25),
+            Some("worker\tthread"),
+        );
+        let mut writer = Writes::default();
+        write_record(&mut writer, &value).unwrap();
+        assert_eq!(
+            writer.0.len(),
+            1,
+            "JSON tokens must not cause separate writes"
+        );
+        let bytes = &writer.0[0];
+        assert_eq!(bytes.last(), Some(&b'\n'));
+        assert_eq!(bytes.iter().filter(|byte| **byte == b'\n').count(), 1);
+        let parsed: serde_json::Value = serde_json::from_slice(bytes).unwrap();
+        assert_eq!(parsed, value);
+        assert_eq!(parsed["elapsed_ms"], 125.125);
+        assert_eq!(parsed["duration_ms"], 95.25);
+    }
+}

crates/gitcomet-core/src/large_file_tools.rs

@@ -3,7 +3,8 @@
 //! PATH, which is what every filter, hook and command will use.
 
 use crate::process::{
-    bytes_to_text_preserving_utf8, current_git_runtime, git_command_for_preference, probe_output,
+    GitExecutablePreference, GitRuntimeState, bytes_to_text_preserving_utf8, current_git_runtime,
+    git_command_for_preference, probe_output,
 };
 use crate::services::CancellationToken;
 pub use crate::signing_tools::SigningToolAvailability as ToolAvailability;
@@ -33,14 +34,27 @@ impl Default for LargeFileToolsState {
 pub fn detect_large_file_tools_cancellable(
     cancellation: &CancellationToken,
 ) -> LargeFileToolsState {
-    let runtime = current_git_runtime();
+    detect_large_file_tools_for_runtime_cancellable(&current_git_runtime(), cancellation)
+}
+
+/// Probe the runtime captured when the request was created, even if the
+/// configured executable changes before its worker starts.
+pub fn detect_large_file_tools_for_runtime_cancellable(
+    runtime: &GitRuntimeState,
+    cancellation: &CancellationToken,
+) -> LargeFileToolsState {
+    detect_for_runtime_with_factory(runtime, &git_command_for_preference, cancellation)
+}
+
+fn detect_for_runtime_with_factory(
+    runtime: &GitRuntimeState,
+    git: &(dyn Fn(&GitExecutablePreference) -> Command + Sync),
+    cancellation: &CancellationToken,
+) -> LargeFileToolsState {
     if !runtime.is_available() || cancellation.is_cancelled() {
         return LargeFileToolsState::default();
     }
-    detect_large_file_tools_with(
-        &|| git_command_for_preference(&runtime.preference),
-        cancellation,
-    )
+    detect_large_file_tools_with(&|| git(&runtime.preference), cancellation)
 }
 
 /// Injectable factory for deterministic tests.
@@ -157,3 +171,6 @@ mod tests {
         assert_eq!(state, LargeFileToolsState::default());
     }
 }
+
+#[cfg(test)]
+mod runtime_tests;