Significantly improve performance by using a buffered writer

CHANGELOG.md

@@ -44,6 +44,7 @@
 - Use bat's ANSI iterator during tab expansion, see #2998 (@eth-p)
 - Support 'statically linked binary' for aarch64 in 'Release' page, see #2992 (@tzq0301)
 - Update options in shell completions and the man page of `bat`, see #2995 (@akinomyoga)
+- Significantly improve performance by using a buffered writer, see #3101 (@MoSal)
 
 ## Syntaxes
 

src/bin/bat/app.rs

@@ -338,13 +338,16 @@ impl App {
             return Err("Must be one file name per input type.".into());
         }
 
+        let stdin_is_terminal = || std::io::stdin().is_terminal();
+
         let mut filenames_or_none: Box<dyn Iterator<Item = Option<&Path>>> = match filenames {
             Some(filenames) => Box::new(filenames.into_iter().map(Some)),
             None => Box::new(std::iter::repeat(None)),
         };
         if files.is_none() {
             return Ok(vec![new_stdin_input(
                 filenames_or_none.next().unwrap_or(None),
+                stdin_is_terminal(),
             )]);
         }
         let files_or_none: Box<dyn Iterator<Item = _>> = match files {
@@ -356,7 +359,7 @@ impl App {
         for (filepath, provided_name) in files_or_none.zip(filenames_or_none) {
             if let Some(filepath) = filepath {
                 if filepath.to_str().unwrap_or_default() == "-" {
-                    file_input.push(new_stdin_input(provided_name));
+                    file_input.push(new_stdin_input(provided_name, stdin_is_terminal()));
                 } else {
                     file_input.push(new_file_input(filepath, provided_name));
                 }

src/bin/bat/input.rs

@@ -5,8 +5,8 @@ pub fn new_file_input<'a>(file: &'a Path, name: Option<&'a Path>) -> Input<'a> {
     named(Input::ordinary_file(file), name.or(Some(file)))
 }
 
-pub fn new_stdin_input(name: Option<&Path>) -> Input {
-    named(Input::stdin(), name)
+pub fn new_stdin_input(name: Option<&Path>, is_terminal: bool) -> Input {
+    named(Input::stdin(is_terminal), name)
 }
 
 fn named<'a>(input: Input<'a>, name: Option<&Path>) -> Input<'a> {

src/controller.rs

@@ -1,4 +1,4 @@
-use std::io::{self, BufRead, Write};
+use std::io::{self, BufRead, BufWriter, Write};
 
 use crate::assets::HighlightingAssets;
 use crate::config::{Config, VisibleLines};
@@ -88,9 +88,12 @@ impl<'b> Controller<'b> {
             clircle::Identifier::stdout()
         };
 
+        const BUF_W_SZ: usize = 1 << 14;
         let mut writer = match output_buffer {
             Some(buf) => OutputHandle::FmtWrite(buf),
-            None => OutputHandle::IoWrite(output_type.handle()?),
+            None => {
+                OutputHandle::IoWrite(BufWriter::with_capacity(BUF_W_SZ, output_type.handle()?))
+            }
         };
         let mut no_errors: bool = true;
         let stderr = io::stderr();
@@ -124,10 +127,10 @@ impl<'b> Controller<'b> {
         Ok(no_errors)
     }
 
-    fn print_input<R: BufRead>(
+    fn print_input<R: BufRead, W: io::Write>(
         &self,
         input: Input,
-        writer: &mut OutputHandle,
+        writer: &mut OutputHandle<W>,
         stdin: R,
         stdout_identifier: Option<&Identifier>,
         is_first: bool,
@@ -174,7 +177,7 @@ impl<'b> Controller<'b> {
             None
         };
 
-        let mut printer: Box<dyn Printer> = if self.config.loop_through {
+        let mut printer: Box<dyn Printer<_>> = if self.config.loop_through {
             Box::new(SimplePrinter::new(self.config))
         } else {
             Box::new(InteractivePrinter::new(
@@ -196,10 +199,10 @@ impl<'b> Controller<'b> {
         )
     }
 
-    fn print_file(
+    fn print_file<W: io::Write>(
         &self,
-        printer: &mut dyn Printer,
-        writer: &mut OutputHandle,
+        printer: &mut dyn Printer<W>,
+        writer: &mut OutputHandle<W>,
         input: &mut OpenedInput,
         add_header_padding: bool,
         #[cfg(feature = "git")] line_changes: &Option<LineChanges>,
@@ -227,19 +230,26 @@ impl<'b> Controller<'b> {
                 }
             };
 
-            self.print_file_ranges(printer, writer, &mut input.reader, &line_ranges)?;
+            self.print_file_ranges(
+                printer,
+                writer,
+                &mut input.reader,
+                &line_ranges,
+                input.is_terminal,
+            )?;
         }
         printer.print_footer(writer, input)?;
 
         Ok(())
     }
 
-    fn print_file_ranges(
+    fn print_file_ranges<W: io::Write>(
         &self,
-        printer: &mut dyn Printer,
-        writer: &mut OutputHandle,
+        printer: &mut dyn Printer<W>,
+        writer: &mut OutputHandle<W>,
         reader: &mut InputReader,
         line_ranges: &LineRanges,
+        input_is_terminal: bool,
     ) -> Result<()> {
         let mut line_buffer = Vec::new();
         let mut line_number: usize = 1;
@@ -278,7 +288,13 @@ impl<'b> Controller<'b> {
 
             line_number += 1;
             line_buffer.clear();
+
+            // flush per line if input is terminal to allow interactive use
+            if input_is_terminal {
+                writer.flush()?;
+            }
         }
+        writer.flush()?;
         Ok(())
     }
 }

src/input.rs

@@ -94,6 +94,7 @@ pub(crate) struct InputMetadata {
 pub struct Input<'a> {
     pub(crate) kind: InputKind<'a>,
     pub(crate) metadata: InputMetadata,
+    pub(crate) is_terminal: bool,
     pub(crate) description: InputDescription,
 }
 
@@ -106,6 +107,7 @@ pub(crate) enum OpenedInputKind {
 pub(crate) struct OpenedInput<'a> {
     pub(crate) kind: OpenedInputKind,
     pub(crate) metadata: InputMetadata,
+    pub(crate) is_terminal: bool,
     pub(crate) reader: InputReader<'a>,
     pub(crate) description: InputDescription,
 }
@@ -141,15 +143,17 @@ impl<'a> Input<'a> {
             description: kind.description(),
             metadata,
             kind,
+            is_terminal: false,
         }
     }
 
-    pub fn stdin() -> Self {
+    pub fn stdin(is_terminal: bool) -> Self {
         let kind = InputKind::StdIn;
         Input {
             description: kind.description(),
             metadata: InputMetadata::default(),
             kind,
+            is_terminal,
         }
     }
 
@@ -159,6 +163,7 @@ impl<'a> Input<'a> {
             description: kind.description(),
             metadata: InputMetadata::default(),
             kind,
+            is_terminal: false,
         }
     }
 
@@ -207,6 +212,7 @@ impl<'a> Input<'a> {
                     kind: OpenedInputKind::StdIn,
                     description,
                     metadata: self.metadata,
+                    is_terminal: self.is_terminal,
                     reader: InputReader::new(stdin),
                 })
             }
@@ -215,6 +221,7 @@ impl<'a> Input<'a> {
                 kind: OpenedInputKind::OrdinaryFile(path.clone()),
                 description,
                 metadata: self.metadata,
+                is_terminal: self.is_terminal,
                 reader: {
                     let mut file = File::open(&path)
                         .map_err(|e| format!("'{}': {}", path.to_string_lossy(), e))?;
@@ -243,6 +250,7 @@ impl<'a> Input<'a> {
                 description,
                 kind: OpenedInputKind::CustomReader,
                 metadata: self.metadata,
+                is_terminal: self.is_terminal,
                 reader: InputReader::new(BufReader::new(reader)),
             }),
         }

src/pretty_printer.rs

@@ -348,7 +348,7 @@ impl<'a> Input<'a> {
 
     /// A new input from STDIN.
     pub fn from_stdin() -> Self {
-        input::Input::stdin().into()
+        input::Input::stdin(true).into()
     }
 
     /// The filename of the input.