update diff gutter synchronously, with a timeout

Author: pascalkuthe

helix-term/src/application.rs

@@ -31,7 +31,7 @@ use crate::{
 use log::{debug, error, warn};
 use std::{
     io::{stdin, stdout, Write},
-    sync::{atomic::Ordering, Arc},
+    sync::Arc,
     time::{Duration, Instant},
 };
 
@@ -274,17 +274,26 @@ impl Application {
     }
 
     #[cfg(feature = "integration")]
-    fn render(&mut self) {}
+    async fn render(&mut self) {}
 
     #[cfg(not(feature = "integration"))]
-    fn render(&mut self) {
+    async fn render(&mut self) {
         let mut cx = crate::compositor::Context {
             editor: &mut self.editor,
             jobs: &mut self.jobs,
             scroll: None,
         };
 
-        cx.editor.redraw_handle.store(false, Ordering::Relaxed);
+        // Aquire mutable access to the redraw_handle lock
+        // to ensure that there are no tasks running that want to block rendering
+        drop(cx.editor.redraw_handle.1.write().await);
+        cx.editor.needs_redraw = false;
+        {
+            // exhaust any leftover redraw notifications
+            let notify = cx.editor.redraw_handle.0.notified();
+            tokio::pin!(notify);
+            notify.enable();
+        }
 
         let area = self
             .terminal
@@ -306,7 +315,7 @@ impl Application {
     where
         S: Stream<Item = crossterm::Result<crossterm::event::Event>> + Unpin,
     {
-        self.render();
+        self.render().await;
         self.last_render = Instant::now();
 
         loop {
@@ -331,18 +340,18 @@ impl Application {
                 biased;
 
                 Some(event) = input_stream.next() => {
-                    self.handle_terminal_events(event);
+                    self.handle_terminal_events(event).await;
                 }
                 Some(signal) = self.signals.next() => {
                     self.handle_signals(signal).await;
                 }
                 Some(callback) = self.jobs.futures.next() => {
                     self.jobs.handle_callback(&mut self.editor, &mut self.compositor, callback);
-                    self.render();
+                    self.render().await;
                 }
                 Some(callback) = self.jobs.wait_futures.next() => {
                     self.jobs.handle_callback(&mut self.editor, &mut self.compositor, callback);
-                    self.render();
+                    self.render().await;
                 }
                 event = self.editor.wait_event() => {
                     let _idle_handled = self.handle_editor_event(event).await;
@@ -447,25 +456,25 @@ impl Application {
                 self.compositor.resize(area);
                 self.terminal.clear().expect("couldn't clear terminal");
 
-                self.render();
+                self.render().await;
             }
             signal::SIGUSR1 => {
                 self.refresh_config();
-                self.render();
+                self.render().await;
             }
             _ => unreachable!(),
         }
     }
 
-    pub fn handle_idle_timeout(&mut self) {
+    pub async fn handle_idle_timeout(&mut self) {
         let mut cx = crate::compositor::Context {
             editor: &mut self.editor,
             jobs: &mut self.jobs,
             scroll: None,
         };
         let should_render = self.compositor.handle_event(&Event::IdleTimeout, &mut cx);
-        if should_render || self.editor.redraw_handle.load(Ordering::Relaxed) {
-            self.render();
+        if should_render || self.editor.needs_redraw {
+            self.render().await;
         }
     }
 
@@ -538,31 +547,31 @@ impl Application {
         match event {
             EditorEvent::DocumentSaved(event) => {
                 self.handle_document_write(event);
-                self.render();
+                self.render().await;
             }
             EditorEvent::ConfigEvent(event) => {
                 self.handle_config_events(event);
-                self.render();
+                self.render().await;
             }
             EditorEvent::LanguageServerMessage((id, call)) => {
                 self.handle_language_server_message(call, id).await;
                 // limit render calls for fast language server messages
                 let last = self.editor.language_servers.incoming.is_empty();
 
                 if last || self.last_render.elapsed() > LSP_DEADLINE {
-                    self.render();
+                    self.render().await;
                     self.last_render = Instant::now();
                 }
             }
             EditorEvent::DebuggerEvent(payload) => {
                 let needs_render = self.editor.handle_debugger_message(payload).await;
                 if needs_render {
-                    self.render();
+                    self.render().await;
                 }
             }
             EditorEvent::IdleTimer => {
                 self.editor.clear_idle_timer();
-                self.handle_idle_timeout();
+                self.handle_idle_timeout().await;
 
                 #[cfg(feature = "integration")]
                 {
@@ -574,7 +583,10 @@ impl Application {
         false
     }
 
-    pub fn handle_terminal_events(&mut self, event: Result<CrosstermEvent, crossterm::ErrorKind>) {
+    pub async fn handle_terminal_events(
+        &mut self,
+        event: Result<CrosstermEvent, crossterm::ErrorKind>,
+    ) {
         let mut cx = crate::compositor::Context {
             editor: &mut self.editor,
             jobs: &mut self.jobs,
@@ -598,7 +610,7 @@ impl Application {
         };
 
         if should_redraw && !self.editor.should_close() {
-            self.render();
+            self.render().await;
         }
     }
 

helix-vcs/Cargo.toml

@@ -11,12 +11,16 @@ homepage = "https://helix-editor.com"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-git-repository = { version = "0.26", default-features = false , optional = true }
+
+helix-core = { version = "0.6", path = "../helix-core" }
+
 tokio = { version = "1", features = ["rt", "rt-multi-thread", "time", "sync", "parking_lot", "macros"] }
+parking_lot = "0.12"
+
+git-repository = { version = "0.26", default-features = false , optional = true }
 imara-diff = "0.1.5"
-helix-core = { version = "0.6", path = "../helix-core" }
+
 log = "0.4"
-parking_lot = "0.12"
 
 [features]
 git = ["git-repository"]

helix-vcs/src/diff.rs

@@ -1,21 +1,33 @@
 use std::ops::Range;
-use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
 
 use helix_core::Rope;
 use imara_diff::Algorithm;
 use parking_lot::{Mutex, MutexGuard};
 use tokio::sync::mpsc::{unbounded_channel, UnboundedSender};
+use tokio::sync::{Notify, RwLock};
 use tokio::task::JoinHandle;
 
 use crate::diff::worker::DiffWorker;
 
 mod line_cache;
 mod worker;
 
-enum Event {
-    UpdateDocument(Rope),
-    UpdateDiffBase(Rope),
+type RedrawHandle = Arc<(Notify, RwLock<()>)>;
+
+// The order of enum variants is used by the PartialOrd
+// derive macro, DO NOT REORDER
+#[derive(PartialEq, PartialOrd)]
+enum RenderStrategy {
+    Async,
+    SyncWithTimeout,
+    Sync,
+}
+
+struct Event {
+    text: Rope,
+    is_base: bool,
+    render_strategy: RenderStrategy,
 }
 
 #[derive(Clone, Debug)]
@@ -26,22 +38,23 @@ pub struct DiffHandle {
 }
 
 impl DiffHandle {
-    pub fn new(diff_base: Rope, doc: Rope, redraw_handle: Arc<AtomicBool>) -> DiffHandle {
+    pub fn new(diff_base: Rope, doc: Rope, redraw_handle: RedrawHandle) -> DiffHandle {
         DiffHandle::new_with_handle(diff_base, doc, redraw_handle).0
     }
 
     fn new_with_handle(
         diff_base: Rope,
         doc: Rope,
-        notify: Arc<AtomicBool>,
+        redraw_handle: RedrawHandle,
     ) -> (DiffHandle, JoinHandle<()>) {
         let (sender, receiver) = unbounded_channel();
         let hunks: Arc<Mutex<Vec<Hunk>>> = Arc::default();
         let worker = DiffWorker {
             channel: receiver,
             hunks: hunks.clone(),
             new_hunks: Vec::default(),
-            notify,
+            redraw_handle,
+            difff_finished_notify: Arc::default(),
         };
         let handle = tokio::spawn(worker.run(diff_base, doc));
         let differ = DiffHandle {
@@ -63,35 +76,38 @@ impl DiffHandle {
         }
     }
 
-    pub fn update_document(&self, doc: Rope) -> bool {
-        if self.inverted {
-            self.update_diff_base_impl(doc)
+    pub fn update_document(&self, doc: Rope, block: bool) -> bool {
+        let mode = if block {
+            RenderStrategy::Sync
         } else {
-            self.update_document_impl(doc)
-        }
+            RenderStrategy::SyncWithTimeout
+        };
+        self.update_document_impl(doc, self.inverted, mode)
     }
 
     pub fn update_diff_base(&self, diff_base: Rope) -> bool {
-        if self.inverted {
-            self.update_document_impl(diff_base)
-        } else {
-            self.update_diff_base_impl(diff_base)
-        }
+        self.update_document_impl(diff_base, !self.inverted, RenderStrategy::Async)
     }
 
-    pub fn update_document_impl(&self, doc: Rope) -> bool {
-        self.channel.send(Event::UpdateDocument(doc)).is_ok()
-    }
-
-    pub fn update_diff_base_impl(&self, diff_base: Rope) -> bool {
-        self.channel.send(Event::UpdateDiffBase(diff_base)).is_ok()
+    fn update_document_impl(&self, text: Rope, is_base: bool, mode: RenderStrategy) -> bool {
+        let event = Event {
+            text,
+            is_base,
+            render_strategy: mode,
+        };
+        self.channel.send(event).is_ok()
     }
 }
 
 // TODO configuration
-const DIFF_DEBOUNCE_TIME: u64 = 100;
+/// synchronus debounce value should be low
+/// so we can update synchrously most of the time
+const DIFF_DEBOUNCE_TIME_SYNC: u64 = 1;
+/// maximum time that rendering should be blocked until the diff finishes
+const SYNC_DIFF_TIMEOUT: u64 = 50;
+const DIFF_DEBOUNCE_TIME_ASYNC: u64 = 100;
 const ALGORITHM: Algorithm = Algorithm::Histogram;
-const MAX_DIFF_LINES: usize = u16::MAX as usize;
+const MAX_DIFF_LINES: usize = 64 * u16::MAX as usize;
 // cap average line length to 128 for files with MAX_DIFF_LINES
 const MAX_DIFF_BYTES: usize = MAX_DIFF_LINES * 128;