feat(y-octo): import y-octo monorepo (#11750)

packages/common/y-octo/utils/benches/apply_benchmarks.rs

@@ -0,0 +1,35 @@
+mod utils;
+
+use std::time::Duration;
+
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use path_ext::PathExt;
+use utils::Files;
+
+fn apply(c: &mut Criterion) {
+  let files = Files::load();
+
+  let mut group = c.benchmark_group("apply");
+  group.measurement_time(Duration::from_secs(15));
+
+  for file in &files.files {
+    group.throughput(Throughput::Bytes(file.content.len() as u64));
+    group.bench_with_input(
+      BenchmarkId::new("apply with yrs", file.path.name_str()),
+      &file.content,
+      |b, content| {
+        b.iter(|| {
+          use yrs::{updates::decoder::Decode, Doc, Transact, Update};
+          let update = Update::decode_v1(content).unwrap();
+          let doc = Doc::new();
+          doc.transact_mut().apply_update(update).unwrap();
+        });
+      },
+    );
+  }
+
+  group.finish();
+}
+
+criterion_group!(benches, apply);
+criterion_main!(benches);

packages/common/y-octo/utils/benches/array_ops_benchmarks.rs

@@ -0,0 +1,79 @@
+use std::time::Duration;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use rand::{Rng, SeedableRng};
+
+fn operations(c: &mut Criterion) {
+  let mut group = c.benchmark_group("ops/array");
+  group.measurement_time(Duration::from_secs(15));
+
+  group.bench_function("yrs/insert", |b| {
+    let base_text = "test1 test2 test3 test4 test5 test6 test7 test8 test9";
+    let mut rng = rand_chacha::ChaCha20Rng::seed_from_u64(1234);
+
+    let idxs = (0..99)
+      .map(|_| rng.random_range(0..base_text.len() as u32))
+      .collect::<Vec<_>>();
+    b.iter(|| {
+      use yrs::{Array, Doc, Transact};
+      let doc = Doc::new();
+      let array = doc.get_or_insert_array("test");
+
+      let mut trx = doc.transact_mut();
+      for c in base_text.chars() {
+        array.push_back(&mut trx, c.to_string());
+      }
+      for idx in &idxs {
+        array.insert(&mut trx, *idx, "test");
+      }
+      drop(trx);
+    });
+  });
+
+  group.bench_function("yrs/insert range", |b| {
+    let base_text = "test1 test2 test3 test4 test5 test6 test7 test8 test9";
+    let mut rng = rand_chacha::ChaCha20Rng::seed_from_u64(1234);
+
+    let idxs = (0..99)
+      .map(|_| rng.random_range(0..base_text.len() as u32))
+      .collect::<Vec<_>>();
+    b.iter(|| {
+      use yrs::{Array, Doc, Transact};
+      let doc = Doc::new();
+      let array = doc.get_or_insert_array("test");
+
+      let mut trx = doc.transact_mut();
+      for c in base_text.chars() {
+        array.push_back(&mut trx, c.to_string());
+      }
+      for idx in &idxs {
+        array.insert_range(&mut trx, *idx, vec!["test1", "test2"]);
+      }
+      drop(trx);
+    });
+  });
+
+  group.bench_function("yrs/remove", |b| {
+    let base_text = "test1 test2 test3 test4 test5 test6 test7 test8 test9";
+
+    b.iter(|| {
+      use yrs::{Array, Doc, Transact};
+      let doc = Doc::new();
+      let array = doc.get_or_insert_array("test");
+
+      let mut trx = doc.transact_mut();
+      for c in base_text.chars() {
+        array.push_back(&mut trx, c.to_string());
+      }
+      for idx in (base_text.len() as u32)..0 {
+        array.remove(&mut trx, idx);
+      }
+      drop(trx);
+    });
+  });
+
+  group.finish();
+}
+
+criterion_group!(benches, operations);
+criterion_main!(benches);

packages/common/y-octo/utils/benches/codec_benchmarks.rs

@@ -0,0 +1,89 @@
+use criterion::{criterion_group, criterion_main, Criterion, SamplingMode};
+use lib0::{
+  decoding::{Cursor, Read},
+  encoding::Write,
+};
+
+const BENCHMARK_SIZE: u32 = 100000;
+
+fn codec(c: &mut Criterion) {
+  let mut codec_group = c.benchmark_group("codec");
+  codec_group.sampling_mode(SamplingMode::Flat);
+  {
+    codec_group.bench_function("lib0 encode var_int (64 bit)", |b| {
+      b.iter(|| {
+        let mut encoder = Vec::with_capacity(BENCHMARK_SIZE as usize * 8);
+        for i in 0..(BENCHMARK_SIZE as i64) {
+          encoder.write_var(i);
+        }
+      })
+    });
+    codec_group.bench_function("lib0 decode var_int (64 bit)", |b| {
+      let mut encoder = Vec::with_capacity(BENCHMARK_SIZE as usize * 8);
+      for i in 0..(BENCHMARK_SIZE as i64) {
+        encoder.write_var(i);
+      }
+
+      b.iter(|| {
+        let mut decoder = Cursor::from(&encoder);
+        for i in 0..(BENCHMARK_SIZE as i64) {
+          let num: i64 = decoder.read_var().unwrap();
+          assert_eq!(num, i);
+        }
+      })
+    });
+  }
+
+  {
+    codec_group.bench_function("lib0 encode var_uint (32 bit)", |b| {
+      b.iter(|| {
+        let mut encoder = Vec::with_capacity(BENCHMARK_SIZE as usize * 8);
+        for i in 0..BENCHMARK_SIZE {
+          encoder.write_var(i);
+        }
+      })
+    });
+    codec_group.bench_function("lib0 decode var_uint (32 bit)", |b| {
+      let mut encoder = Vec::with_capacity(BENCHMARK_SIZE as usize * 8);
+      for i in 0..BENCHMARK_SIZE {
+        encoder.write_var(i);
+      }
+
+      b.iter(|| {
+        let mut decoder = Cursor::from(&encoder);
+        for i in 0..BENCHMARK_SIZE {
+          let num: u32 = decoder.read_var().unwrap();
+          assert_eq!(num, i);
+        }
+      })
+    });
+  }
+
+  {
+    codec_group.bench_function("lib0 encode var_uint (64 bit)", |b| {
+      b.iter(|| {
+        let mut encoder = Vec::with_capacity(BENCHMARK_SIZE as usize * 8);
+        for i in 0..(BENCHMARK_SIZE as u64) {
+          encoder.write_var(i);
+        }
+      })
+    });
+    codec_group.bench_function("lib0 decode var_uint (64 bit)", |b| {
+      let mut encoder = Vec::with_capacity(BENCHMARK_SIZE as usize * 8);
+      for i in 0..(BENCHMARK_SIZE as u64) {
+        encoder.write_var(i);
+      }
+
+      b.iter(|| {
+        let mut decoder = Cursor::from(&encoder);
+        for i in 0..(BENCHMARK_SIZE as u64) {
+          let num: u64 = decoder.read_var().unwrap();
+          assert_eq!(num, i);
+        }
+      })
+    });
+  }
+}
+
+criterion_group!(benches, codec);
+criterion_main!(benches);

packages/common/y-octo/utils/benches/map_ops_benchmarks.rs

@@ -0,0 +1,79 @@
+use std::time::Duration;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+
+fn operations(c: &mut Criterion) {
+  let mut group = c.benchmark_group("ops/map");
+  group.measurement_time(Duration::from_secs(15));
+
+  group.bench_function("yrs/insert", |b| {
+    let base_text = "test1 test2 test3 test4 test5 test6 test7 test8 test9"
+      .split(' ')
+      .collect::<Vec<_>>();
+
+    b.iter(|| {
+      use yrs::{Doc, Map, Transact};
+      let doc = Doc::new();
+      let map = doc.get_or_insert_map("test");
+
+      let mut trx = doc.transact_mut();
+      for (idx, key) in base_text.iter().enumerate() {
+        map.insert(&mut trx, key.to_string(), idx as f64);
+      }
+
+      drop(trx);
+    });
+  });
+
+  group.bench_function("yrs/get", |b| {
+    use yrs::{Doc, Map, Transact};
+
+    let base_text = "test1 test2 test3 test4 test5 test6 test7 test8 test9"
+      .split(' ')
+      .collect::<Vec<_>>();
+
+    let doc = Doc::new();
+    let map = doc.get_or_insert_map("test");
+
+    let mut trx = doc.transact_mut();
+    for (idx, key) in base_text.iter().enumerate() {
+      map.insert(&mut trx, key.to_string(), idx as f64);
+    }
+    drop(trx);
+
+    b.iter(|| {
+      let trx = doc.transact();
+      for key in &base_text {
+        map.get(&trx, key).unwrap();
+      }
+    });
+  });
+
+  group.bench_function("yrs/remove", |b| {
+    let base_text = "test1 test2 test3 test4 test5 test6 test7 test8 test9"
+      .split(' ')
+      .collect::<Vec<_>>();
+
+    b.iter(|| {
+      use yrs::{Doc, Map, Transact};
+      let doc = Doc::new();
+      let map = doc.get_or_insert_map("test");
+
+      let mut trx = doc.transact_mut();
+      for (idx, key) in base_text.iter().enumerate() {
+        map.insert(&mut trx, key.to_string(), idx as f64);
+      }
+
+      for key in &base_text {
+        map.remove(&mut trx, key).unwrap();
+      }
+
+      drop(trx);
+    });
+  });
+
+  group.finish();
+}
+
+criterion_group!(benches, operations);
+criterion_main!(benches);

packages/common/y-octo/utils/benches/text_ops_benchmarks.rs

@@ -0,0 +1,54 @@
+use std::time::Duration;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use rand::{Rng, SeedableRng};
+
+fn operations(c: &mut Criterion) {
+  let mut group = c.benchmark_group("ops/text");
+  group.measurement_time(Duration::from_secs(15));
+
+  group.bench_function("yrs/insert", |b| {
+    let base_text = "test1 test2 test3 test4 test5 test6 test7 test8 test9";
+    let mut rng = rand_chacha::ChaCha20Rng::seed_from_u64(1234);
+
+    let idxs = (0..99)
+      .map(|_| rng.random_range(0..base_text.len() as u32))
+      .collect::<Vec<_>>();
+    b.iter(|| {
+      use yrs::{Doc, Text, Transact};
+      let doc = Doc::new();
+      let text = doc.get_or_insert_text("test");
+      let mut trx = doc.transact_mut();
+
+      text.push(&mut trx, base_text);
+      for idx in &idxs {
+        text.insert(&mut trx, *idx, "test");
+      }
+      drop(trx);
+    });
+  });
+
+  group.bench_function("yrs/remove", |b| {
+    let base_text = "test1 test2 test3 test4 test5 test6 test7 test8 test9";
+
+    b.iter(|| {
+      use yrs::{Doc, Text, Transact};
+      let doc = Doc::new();
+      let text = doc.get_or_insert_text("test");
+      let mut trx = doc.transact_mut();
+
+      text.push(&mut trx, base_text);
+      text.push(&mut trx, base_text);
+      text.push(&mut trx, base_text);
+      for idx in (base_text.len() as u32)..0 {
+        text.remove_range(&mut trx, idx, 1);
+      }
+      drop(trx);
+    });
+  });
+
+  group.finish();
+}
+
+criterion_group!(benches, operations);
+criterion_main!(benches);

packages/common/y-octo/utils/benches/update_benchmarks.rs

@@ -0,0 +1,33 @@
+mod utils;
+
+use std::time::Duration;
+
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use path_ext::PathExt;
+use utils::Files;
+
+fn update(c: &mut Criterion) {
+  let files = Files::load();
+
+  let mut group = c.benchmark_group("update");
+  group.measurement_time(Duration::from_secs(15));
+
+  for file in &files.files {
+    group.throughput(Throughput::Bytes(file.content.len() as u64));
+    group.bench_with_input(
+      BenchmarkId::new("parse with yrs", file.path.name_str()),
+      &file.content,
+      |b, content| {
+        b.iter(|| {
+          use yrs::{updates::decoder::Decode, Update};
+          Update::decode_v1(content).unwrap()
+        });
+      },
+    );
+  }
+
+  group.finish();
+}
+
+criterion_group!(benches, update);
+criterion_main!(benches);

packages/common/y-octo/utils/benches/utils/files.rs

@@ -0,0 +1,42 @@
+use std::{
+  fs::{read, read_dir},
+  path::{Path, PathBuf},
+};
+
+use path_ext::PathExt;
+
+pub struct File {
+  pub path: PathBuf,
+  pub content: Vec<u8>,
+}
+
+const BASE: &str = "../y-octo/src/fixtures/";
+
+impl File {
+  fn new(path: &Path) -> Self {
+    let content = read(path).unwrap();
+    Self {
+      path: path.into(),
+      content,
+    }
+  }
+}
+
+pub struct Files {
+  pub files: Vec<File>,
+}
+
+impl Files {
+  pub fn load() -> Self {
+    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(BASE);
+
+    let files = read_dir(path).unwrap();
+    let files = files
+      .flatten()
+      .filter(|f| f.path().is_file() && f.path().ext_str() == "bin")
+      .map(|f| File::new(&f.path()))
+      .collect::<Vec<_>>();
+
+    Self { files }
+  }
+}

packages/common/y-octo/utils/benches/utils/mod.rs

@@ -0,0 +1,3 @@
+mod files;
+
+pub use files::Files;