Smarter handling of input lines

Instead of using a Vec<String>, which allocates for each line, we
introduce a BufLines type which keeps the whole file in one allocation.

input/c_major.tab, repeated into a 25MB file, processed with muxml:
[OLD:]
  measurement          mean ± σ            min … max           outliers         delta
  wall_time           345ms ± 3.78ms     339ms …  354ms          0 ( 0%)        0%
  peak_rss            462MB ±  126KB     462MB …  463MB          0 ( 0%)        0%
  cpu_cycles         1.07G  ± 20.7M     1.03G  … 1.12G           0 ( 0%)        0%
  instructions       3.56G  ±  294      3.56G  … 3.56G           0 ( 0%)        0%
  cache_references   29.7M  ± 1.10M     29.2M  … 33.7M           1 ( 7%)        0%
  cache_misses       3.19M  ± 21.6K     3.17M  … 3.24M           0 ( 0%)        0%
  branch_misses      2.47M  ±  160K     2.16M  … 2.69M           0 ( 0%)        0%

[NEW:]
  measurement          mean ± σ            min … max           outliers         delta
  wall_time           329ms ± 2.72ms     322ms …  334ms          3 (19%)        ⚡-  4.9% ±  0.7%
  peak_rss            408MB ± 74.3KB     407MB …  408MB          0 ( 0%)        ⚡- 11.9% ±  0.0%
  cpu_cycles         1.03G  ± 7.11M     1.02G  … 1.04G           0 ( 0%)        ⚡-  3.7% ±  1.1%
  instructions       3.30G  ±  365      3.30G  … 3.30G           1 ( 6%)        ⚡-  7.2% ±  0.0%
  cache_references   23.7M  ±  227K     23.4M  … 24.3M           1 ( 6%)        ⚡- 20.4% ±  1.9%
  cache_misses       2.99M  ± 20.7K     2.96M  … 3.05M           1 ( 6%)        ⚡-  6.5% ±  0.5%
  branch_misses      1.79M  ±  162K     1.55M  … 2.08M           0 ( 0%)        ⚡- 27.4% ±  4.8%

the same file, using the fixup backend:
[OLD:]
  measurement          mean ± σ            min … max           outliers         delta
  wall_time           164ms ± 2.00ms     160ms …  168ms          0 ( 0%)        0%
  peak_rss            182MB ±  102KB     182MB …  183MB          0 ( 0%)        0%
  cpu_cycles          528M  ± 6.68M      519M  …  543M           0 ( 0%)        0%
  instructions       2.26G  ±  254      2.26G  … 2.26G           1 ( 3%)        0%
  cache_references   18.2M  ±  190K     17.9M  … 19.1M           2 ( 6%)        0%
  cache_misses        320K  ± 11.6K      292K  …  342K           0 ( 0%)        0%
  branch_misses      1.27M  ±  132K     1.15M  … 1.66M           2 ( 6%)        0%

[NEW:]
  measurement          mean ± σ            min … max           outliers         delta
  wall_time           122ms ± 2.23ms     119ms …  128ms          0 ( 0%)        ⚡- 25.4% ±  0.6%
  peak_rss            107MB ±  123KB     107MB …  107MB          1 ( 2%)        ⚡- 41.2% ±  0.0%
  cpu_cycles          422M  ± 7.88M      414M  …  453M           1 ( 2%)        ⚡- 20.1% ±  0.7%
  instructions       1.87G  ±  237      1.87G  … 1.87G           0 ( 0%)        ⚡- 17.1% ±  0.0%
  cache_references   9.03M  ± 65.9K     8.95M  … 9.25M           1 ( 2%)        ⚡- 50.4% ±  0.4%
  cache_misses        165K  ± 14.3K      101K  …  179K           6 (15%)        ⚡- 48.4% ±  2.0%
  branch_misses      1.11M  ±  122K     1.01M  … 1.43M           6 (15%)        ⚡- 13.2% ±  4.7%

Author: algorithmiker

Cargo.lock

@@ -14,6 +14,7 @@ clap = { version = "4.5.4", features = ["derive"] }
 entrace_core = { version = "0.1.0", features = [] }
 itertools = "0.14.0"
 itoa = "1.0.11"
+memchr = "2.7.5"
 midly = "0.5.3"
 rustc-hash = "2.1.1"
 tracing = {version = "0.1.41", features = ["max_level_off","release_max_level_off"]}

Cargo.toml

@@ -1,4 +1,4 @@
-use std::time::Instant;
+use std::{borrow::Cow, time::Instant};
 
 use clap::ValueEnum;
 use tracing::trace;
@@ -13,7 +13,7 @@ use crate::{
         Backend,
     },
     parser::parse,
-    time,
+    time, BufLines,
 };
 
 pub struct FixupBackend();
@@ -54,7 +54,7 @@ impl Backend for FixupBackend {
     type BackendSettings = FixupBackendSettings;
 
     fn process<Out: std::io::Write>(
-        parser_input: &[String], out: &mut Out, settings: Self::BackendSettings,
+        parser_input: &BufLines, out: &mut Out, settings: Self::BackendSettings,
     ) -> BackendResult {
         if let Some(dump) = settings.dump {
             let (parse_time, parsed) = time(|| parse(parser_input));
@@ -68,9 +68,9 @@ impl Backend for FixupBackend {
             r.err = parsed.error;
             return r;
         }
+
         let mut diagnostics = vec![];
-        // TODO: figure out a way not to clone these
-        let mut parser_input = parser_input.to_owned();
+        let mut parser_input: Vec<Cow<str>> = parser_input.buf.lines().map(Cow::Borrowed).collect();
         let mut parse_time;
         let fixup_start = Instant::now();
         let mut location_tracker = LocationTracker::new();
@@ -117,18 +117,17 @@ impl Backend for FixupBackend {
                             };
                             // we just replace both with a rest to be sure
                             // todo: use a better strategy by checking the actual ticks
-                            parser_input[line_idx].replace_range(char_idx..char_idx + 1, "-");
-                            parser_input[line_idx].replace_range(char_idx + 1..char_idx + 2, "-");
+                            let line_mut = parser_input[line_idx].to_mut();
+                            line_mut.replace_range(char_idx..char_idx + 1, "-");
+                            line_mut.replace_range(char_idx + 1..char_idx + 2, "-");
                             diagnostics.push(Diagnostic::info(
                                 err.main_location.clone(),
                                 DiagnosticKind::FormatReplacedInvalid,
                             ));
                         }
                         BackendErrorKind::NoClosingBarline => {
                             let l_idx = err.main_location.get_line_idx().unwrap();
-                            let line = &mut parser_input[l_idx];
-                            line.truncate(line.trim_end().len());
-                            line.push('|');
+                            parser_input[l_idx].to_mut().push('|');
                             diagnostics.push(Diagnostic::info(
                                 err.main_location.clone(),
                                 DiagnosticKind::FormatAddedBarline,
@@ -143,7 +142,9 @@ impl Backend for FixupBackend {
                             else {
                                 continue;
                             };
-                            parser_input[line_idx].replace_range(char_idx..char_idx + 1, "-");
+                            parser_input[line_idx]
+                                .to_mut()
+                                .replace_range(char_idx + 1..char_idx + 2, "-");
                             diagnostics.push(Diagnostic::info(
                                 err.main_location.clone(),
                                 DiagnosticKind::FormatReplacedInvalid,
@@ -154,8 +155,8 @@ impl Backend for FixupBackend {
             }
         }
         let gen_time = fixup_start.elapsed();
-        let maybe_io_err =
-            out.write_all(parser_input.join("\n").as_ref()).map_err(BackendError::from).err();
+        let joined = parser_input.join("\n");
+        let maybe_io_err = out.write_all(joined.as_bytes()).map_err(BackendError::from).err();
         BackendResult::new(diagnostics, maybe_io_err, Some(parse_time), Some(gen_time))
     }
 }

src/backend/fixup/mod.rs

@@ -7,12 +7,15 @@ use midly::{
 use tracing::trace;
 
 use super::{Backend, BackendResult};
-use crate::parser::{
-    parse,
-    tab_element::TabElement::{self, Fret},
-    ParseResult,
-};
 use crate::time;
+use crate::{
+    parser::{
+        parse,
+        tab_element::TabElement::{self, Fret},
+        ParseResult,
+    },
+    BufLines,
+};
 
 const BPM: u32 = 80;
 const MINUTE_IN_MS: u32 = 60 * 1000;
@@ -25,7 +28,7 @@ impl Backend for MidiBackend {
     type BackendSettings = ();
 
     fn process<Out: std::io::Write>(
-        input: &[String], out: &mut Out, _settings: Self::BackendSettings,
+        input: &BufLines, out: &mut Out, _settings: Self::BackendSettings,
     ) -> BackendResult {
         let diagnostics = vec![];
         let (parse_time, parse_result) = time(|| parse(input));
@@ -58,15 +61,11 @@ impl Backend for MidiBackend {
             tracks,
         };
         let gen_time = gen_start.elapsed();
+        let mut last_err = None;
         if let Err(x) = smf.write_std(out) {
-            return BackendResult::new(
-                diagnostics,
-                Some(x.into()),
-                Some(parse_time),
-                Some(gen_time),
-            );
-        }
-        BackendResult::new(diagnostics, None, Some(parse_time), Some(gen_time))
+            last_err = Some(x.into());
+        };
+        BackendResult::new(diagnostics, last_err, Some(parse_time), Some(gen_time))
     }
 }
 

src/backend/midi/mod.rs

@@ -1,6 +1,8 @@
 use errors::{backend_error::BackendError, diagnostic::Diagnostic};
 
 use std::{fmt::Display, time::Duration};
+
+use crate::BufLines;
 pub mod errors;
 pub mod fixup;
 pub mod midi;
@@ -23,7 +25,7 @@ pub trait Backend {
     type BackendSettings;
 
     fn process<Out: std::io::Write>(
-        input: &[String], out: &mut Out, settings: Self::BackendSettings,
+        input: &BufLines, out: &mut Out, settings: Self::BackendSettings,
     ) -> BackendResult;
 }
 
@@ -44,7 +46,7 @@ pub enum BackendSelector {
 }
 
 impl BackendSelector {
-    pub fn process<Out: std::io::Write>(self, input: &[String], out: &mut Out) -> BackendResult {
+    pub fn process<Out: std::io::Write>(self, input: &BufLines, out: &mut Out) -> BackendResult {
         match self {
             BackendSelector::Midi => midi::MidiBackend::process(input, out, ()),
             BackendSelector::Muxml(settings) => muxml::MuxmlBackend::process(input, out, settings),

src/backend/mod.rs

@@ -4,13 +4,13 @@ pub mod fretboard;
 mod muxml2_tests;
 pub mod settings;
 use crate::backend::errors::backend_error::BackendError;
-use crate::parser;
 use crate::parser::tab_element::TabElement;
 use crate::parser::{source_location_from_stream, ParseResult};
 use crate::{
     backend::{Backend, BackendResult},
     rlen, time,
 };
+use crate::{parser, BufLines};
 use formatters::{
     write_muxml2_measure_prelude, write_muxml2_note, write_muxml2_rest, MUXML2_DOCUMENT_END,
     MUXML_INCOMPLETE_DOC_PRELUDE,
@@ -26,7 +26,7 @@ impl Backend for MuxmlBackend {
     type BackendSettings = settings::Settings;
 
     fn process<Out: std::io::Write>(
-        input: &[String], out: &mut Out, settings: Self::BackendSettings,
+        input: &BufLines, out: &mut Out, settings: Self::BackendSettings,
     ) -> BackendResult {
         let (parse_time, parse_result) = time(|| parser::parse(input));
         if let Some(err) = parse_result.error {
@@ -228,17 +228,20 @@ impl MuxmlGenerator {
     pub fn process_measure(&mut self, measure_idx: usize) -> Result<(), BackendError> {
         let meas = span!(Level::TRACE, "Muxml2: processing measure", measure_idx);
         let _meas = meas.enter();
-        let ticks_in_measure = rlen(&self.parsed.measures[measure_idx].data_range) / 6;
-        debug_assert!(rlen(&self.parsed.measures[measure_idx].data_range) % 6 == 0);
-        // Length of actual content in measure. `remove_space_between_notes` will reduce this for
-        // example
+
+        let data_range = &self.parsed.measures[measure_idx].data_range;
+        let ticks_in_measure = rlen(data_range) / 6;
+        debug_assert!(rlen(data_range) % 6 == 0);
+
+        // Length of actual content in measure. `remove_space_between_notes` will reduce this for example
         let mut measure_content_len = ticks_in_measure;
         self.measure_buf.clear();
         debug!("initial measure_content_len = {measure_content_len}");
-        let mut stream_idx: usize = *self.parsed.measures[measure_idx].data_range.start() as usize;
-        let mut note_count = 0;
-        let mut stream_proc_cnt = 0;
-        while stream_idx <= *self.parsed.measures[measure_idx].data_range.end() as usize {
+
+        let mut stream_idx: usize = *data_range.start() as usize;
+        let (mut note_count, mut stream_proc_cnt) = (0, 0);
+        let end = *data_range.end() as usize;
+        while stream_idx <= end {
             let elem = &self.parsed.tick_stream[stream_idx];
             //trace!(
             //    "current elem: {elem:?}, note_count: {note_count}, proc_cnt = {stream_proc_cnt}"
@@ -281,8 +284,7 @@ impl MuxmlGenerator {
                     self.measure_buf.push(Muxml2TabElement::Rest(1));
                 }
                 trace!(kind = ?self.measure_buf.last().unwrap(), "Parsed a tick");
-                note_count = 0;
-                stream_proc_cnt = 0;
+                (note_count, stream_proc_cnt) = (0, 0)
             } else {
                 stream_proc_cnt += 1;
             }
@@ -308,14 +310,14 @@ impl MuxmlGenerator {
             measure_denominator,
         )
         .unwrap();
-        // borrowing schenanigans
         for i in 0..self.measure_buf.len() {
             self.write_tab_element(i)?;
         }
         self.document.push_str("</measure>");
         Ok(())
     }
     #[inline(always)]
+    // takes an index because of borrowing schenanigans
     pub fn write_tab_element(&mut self, elem_idx: usize) -> std::fmt::Result {
         let elem = &self.measure_buf[elem_idx];
         match elem {

src/backend/muxml/mod.rs

@@ -3,7 +3,6 @@ use crate::backend::{
     muxml::{settings::Settings, MuxmlBackend},
     Backend,
 };
-use itertools::Itertools;
 
 #[test]
 fn test_muxml2() -> anyhow::Result<()> {
@@ -21,11 +20,7 @@ E|--------------|
         trim_measure: true,
         simplify_time_signature: true,
     };
-    MuxmlBackend::process(
-        &i1.lines().map(|x| x.to_string()).collect::<Vec<_>>(),
-        &mut out,
-        settings,
-    );
+    MuxmlBackend::process(&i1.into(), &mut out, settings);
     insta::assert_snapshot!(String::from_utf8_lossy(&out));
     Ok(())
 }
@@ -45,11 +40,7 @@ E|----|
         trim_measure: true,
         simplify_time_signature: true,
     };
-    MuxmlBackend::process(
-        &i1.lines().map(|x| x.to_string()).collect::<Vec<_>>(),
-        &mut out,
-        settings,
-    );
+    MuxmlBackend::process(&i1.into(), &mut out, settings);
     insta::assert_snapshot!(String::from_utf8_lossy(&out));
     Ok(())
 }
@@ -77,11 +68,7 @@ E|-----9-|-----9-|"#;
         trim_measure: true,
         simplify_time_signature: true,
     };
-    let res = MuxmlBackend::process(
-        &example_score.lines().map(|x| x.to_string()).collect_vec(),
-        &mut Vec::new(),
-        settings,
-    );
+    let res = MuxmlBackend::process(&example_score.into(), &mut Vec::new(), settings);
     let e = res.err.unwrap();
     use crate::backend::errors::error_location::ErrorLocation;
     assert_eq!(e.main_location, ErrorLocation::LineAndChar(3, 25));