perf(replay/recorder): buffer writes to zip file

Doesn't seem to be doing much.

Cargo.lock

@@ -1417,7 +1417,6 @@ dependencies = [
  "ncr",
  "parking_lot",
  "serde_json",
- "smallvec",
  "tokio",
  "zip",
 ]

Cargo.toml

@@ -38,7 +38,6 @@ mlua = { version = "0", features = ["async", "luajit", "send"] }
 ncr = { version = "0", features = ["cfb8", "ecb", "gcm"] }
 parking_lot = "0"
 serde_json = "1"
-smallvec = { version = "1", features = ["write"] }
 tokio = { version = "1", features = ["macros"] }
 zip = { version = "2", default-features = false, features = ["flate2"] }
 

src/arguments.rs

@@ -7,8 +7,8 @@ use std::path::PathBuf;
 #[command(version = build_info::version_formatted())]
 pub struct Arguments {
     /// Path to Lua entry point
-    #[arg(short, long)]
-    pub script: Option<PathBuf>,
+    #[arg(short, long, default_value = "errornowatcher.lua")]
+    pub script: PathBuf,
 
     /// Code to execute after loading script
     #[arg(short, long)]

src/main.rs

@@ -29,7 +29,6 @@ use std::{
     collections::HashMap,
     env,
     fs::{OpenOptions, read_to_string},
-    path::PathBuf,
     sync::Arc,
 };
 
@@ -52,16 +51,15 @@ async fn main() -> anyhow::Result<()> {
     console_subscriber::init();
 
     let args = Arguments::parse();
-    let script_path = args.script.unwrap_or(PathBuf::from("errornowatcher.lua"));
     let event_listeners = Arc::new(RwLock::new(HashMap::new()));
     let lua = unsafe { Lua::unsafe_new() };
     let globals = lua.globals();
 
     lua::register_globals(&lua, &globals, event_listeners.clone())?;
-    globals.set("SCRIPT_PATH", &*script_path)?;
+    globals.set("SCRIPT_PATH", &*args.script)?;
     lua.load(
-        read_to_string(&script_path)
-            .with_context(|| format!("failed to read {}", script_path.display()))?,
+        read_to_string(&args.script)
+            .with_context(|| format!("failed to read {}", args.script.display()))?,
     )
     .exec()?;
     if let Some(code) = args.exec {

src/replay/recorder.rs

@@ -7,17 +7,16 @@ use azalea::{
 };
 use log::debug;
 use serde_json::json;
-use smallvec::SmallVec;
 use std::{
     fs::File,
-    io::Write,
+    io::{BufWriter, Write},
     time::{Instant, SystemTime, UNIX_EPOCH},
 };
 use zip::{ZipWriter, write::SimpleFileOptions};
 
 #[derive(Resource)]
 pub struct Recorder {
-    zip_writer: ZipWriter<File>,
+    zip_writer: BufWriter<ZipWriter<File>>,
     start: Instant,
     server: String,
     pub should_ignore_compression: bool,
@@ -34,20 +33,20 @@ impl Recorder {
         );
         zip_writer.start_file("recording.tmcpr", SimpleFileOptions::default())?;
         Ok(Self {
-            zip_writer,
+            zip_writer: BufWriter::new(zip_writer),
             start: Instant::now(),
             server,
             should_ignore_compression,
         })
     }
 
-    pub fn finish(mut self) -> Result<()> {
+    pub fn finish(self) -> Result<()> {
         debug!("finishing replay recording");
 
         let elapsed = self.start.elapsed().as_millis();
-        self.zip_writer
-            .start_file("metaData.json", SimpleFileOptions::default())?;
-        self.zip_writer.write_all(
+        let mut zip_writer = self.zip_writer.into_inner()?;
+        zip_writer.start_file("metaData.json", SimpleFileOptions::default())?;
+        zip_writer.write_all(
             json!({
                 "singleplayer": false,
                 "serverName": self.server,
@@ -62,23 +61,23 @@ impl Recorder {
             .to_string()
             .as_bytes(),
         )?;
-        self.zip_writer.finish()?;
+        zip_writer.finish()?;
 
         debug!("finished replay recording");
         Ok(())
     }
 
     pub fn save_raw_packet(&mut self, raw_packet: &[u8]) -> Result<()> {
-        let mut data = SmallVec::<[u8; 128]>::with_capacity(raw_packet.len() + 8);
-        data.write_all(&TryInto::<u32>::try_into(self.start.elapsed().as_millis())?.to_be_bytes())?;
-        data.write_all(&TryInto::<u32>::try_into(raw_packet.len())?.to_be_bytes())?;
-        data.write_all(raw_packet)?;
+        let mut data = Vec::with_capacity(raw_packet.len() + 8);
+        data.extend(TryInto::<u32>::try_into(self.start.elapsed().as_millis())?.to_be_bytes());
+        data.extend(TryInto::<u32>::try_into(raw_packet.len())?.to_be_bytes());
+        data.extend(raw_packet);
         self.zip_writer.write_all(&data)?;
         Ok(())
     }
 
     pub fn save_packet<T: ProtocolPacket>(&mut self, packet: &T) -> Result<()> {
-        let mut raw_packet = SmallVec::<[u8; 128]>::new();
+        let mut raw_packet = Vec::with_capacity(64);
         packet.id().azalea_write_var(&mut raw_packet)?;
         packet.write(&mut raw_packet)?;
         self.save_raw_packet(&raw_packet)