feat: implement mismatched model id + improvement

libraries/native_model/benches/overhead.rs

@@ -14,7 +14,7 @@ fn native_model_decode_body<T: Decode>(data: Vec<u8>) -> Result<T, bincode::erro
 #[native_model(id = 1, version = 1)]
 struct Data(Vec<u8>);
 
-fn wrapper(data: &mut Vec<u8>) {
+fn wrap(data: &mut Vec<u8>) {
     native_model::wrapper::native_model_encode(data, 1, 1);
 }
 
@@ -31,16 +31,16 @@ fn criterion_benchmark(c: &mut Criterion) {
 
         // encode
         let data = Data(vec![1; nb_bytes]);
-        let encode_body = native_model_encode_body(&data).unwrap();
+        let mut encode_body = native_model_encode_body(&data).unwrap();
         group.bench_function(BenchmarkId::new("encode", nb_bytes), |b| {
-            b.iter(|| wrapper(&mut encode_body.clone()))
+            b.iter(|| wrap(&mut encode_body))
         });
 
         // decode
         let data = Data(vec![1; nb_bytes]);
-        let encode_body = native_model::encode(&data).unwrap();
+        let mut encode_body = native_model::encode(&data).unwrap();
         group.bench_function(BenchmarkId::new("decode", nb_bytes), |b| {
-            b.iter(|| unwrap(&mut encode_body.clone()))
+            b.iter(|| unwrap(&mut encode_body))
         });
     }
 }

libraries/native_model/benches/prepend_bytes.rs

@@ -0,0 +1,28 @@
+/// Found a way to prepend bytes at the beginning of a Vec<u8> with a constant overhead.
+use bincode::{Decode, Encode};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("encode");
+
+    // 1 byte, 1KB, 1MB, 10MB, 100MB
+    for nb_bytes in [1, 1024, 1024 * 1024, 10 * 1024 * 1024, 100 * 1024 * 1024].into_iter() {
+        group.throughput(criterion::Throughput::Bytes(nb_bytes as u64));
+
+        let header: Vec<u8> = vec![0; 4];
+        let mut data: Vec<u8> = vec![1; nb_bytes];
+        group.bench_function(BenchmarkId::new("prepend_bytes", nb_bytes), |b| {
+            b.iter(|| {
+                // Fastest way to prepend bytes to data
+                let mut header = header.clone();
+                header.append(&mut data);
+                // prepend bytes to data
+                // let mut header = header.clone();
+                // header.extend_from_slice(&data);
+            });
+        });
+    }
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);