loro/crates/loro-internal/examples/encoding.rs
Zixuan Chen d942e3d7a2
Feat: Peritext-like rich text support (#123)
* feat: richtext wip

* feat: add insert to style range map wip

* feat: richtext state

* fix: fix style state inserting and style map

* fix: tiny vec merge err

* fix: comment err

* refactor: use new generic-btree & refine impl

* feat: fugue tracker

* feat: tracker

* feat: tracker

* fix: fix a few err in impl

* feat: init richtext content state

* feat: refactor arena

* feat: extract anchor_type info out of style flag

* refactor: state apply op more efficiently
we can now reuse the repr in state and op

* fix: new clippy errors

* refactor: use state chunk as delta item

* refactor: use two op to insert style start and style end

* feat: diff calc

* feat: handler

* fix: tracker checkout err

* fix: pass basic richtext handler tests

* fix: pass handler basic marking tests

* fix: pass all peritext criteria

* feat: snapshot encoding for richtext init

* refactor: replace Text with Richtext

* refacotr: rm text code

* fix: richtext checkout err

* refactor: diff of text and map

* refactor: del span

* refactor: event

* fix: fuzz err

* fix: pass all tests

* fix: fuzz err

* fix: list child cache err

* chore: rm debug code

* fix: encode enhanced err

* fix: encode enchanced

* fix: fix several richtext issue

* fix: richtext anchor err

* chore: rm debug code

* fix: richtext fuzz err

* feat: speedup text snapshot decode

* perf: optimize snapshot encoding

* perf: speed up decode & insert

* fix: fugue span merge err

* perf: speedup delete & id cursor map

* fix: fugue merge err

* chore: update utils

* perf: speedup text insert / del

* fix: cursor cache

* perf: reduce conversion by introducing InsertText

* perf: speed up by refined cursor cache

* chore: update gbtree dep

* refactor(wasm): use quill delta format

* chore: fix warnings
2023-10-29 14:02:13 +08:00

68 lines
2 KiB
Rust

use std::time::Instant;
use bench_utils::TextAction;
use loro_internal::LoroDoc;
fn main() {
let actions = bench_utils::get_automerge_actions();
let loro = LoroDoc::default();
let text = loro.get_text("text");
for TextAction { pos, ins, del } in actions.iter() {
let mut txn = loro.txn().unwrap();
text.delete(&mut txn, *pos, *del).unwrap();
text.insert(&mut txn, *pos, ins).unwrap();
txn.commit().unwrap();
}
{
// Delta encoding
// let start = Instant::now();
// for _ in 0..10 {
// loro.export_from(&Default::default());
// }
// println!("Avg encode {}ms", start.elapsed().as_millis() as f64 / 10.0);
let data = loro.export_from(&Default::default());
let start = Instant::now();
for _ in 0..5 {
let b = LoroDoc::default();
b.import(&data).unwrap();
}
println!("Avg decode {}ms", start.elapsed().as_millis() as f64 / 10.0);
println!("size len={}", data.len());
let d = miniz_oxide::deflate::compress_to_vec(&data, 10);
println!("size after compress len={}", d.len());
}
{
// Snapshot encoding
// println!("\n=======================\nSnapshot Encoding:");
// let start = Instant::now();
// for _ in 0..10 {
// loro.export_snapshot();
// }
// println!("Avg encode {}ms", start.elapsed().as_millis() as f64 / 10.0);
// let data = loro.export_snapshot();
// let start = Instant::now();
// let times = 300;
// for _ in 0..times {
// let b = LoroDoc::default();
// b.import(&data).unwrap();
// }
// println!(
// "Avg decode {}ms",
// start.elapsed().as_millis() as f64 / times as f64
// );
// println!("size len={}", data.len());
// let d = miniz_oxide::deflate::compress_to_vec(&data, 10);
// println!("size after compress len={}", d.len());
}
}