split 与 freeze

    pub fn split_off(&mut self, at: usize) -> BytesMut {
        assert!(
            at <= self.capacity(),
            "split_off out of bounds: {:?} <= {:?}",
            at,
            self.capacity(),
        );
        unsafe {
            // ...
            let mut other = self.shallow_clone();
            // SAFETY: We've checked that `at` <= `self.capacity()` above.
            other.advance_unchecked(at);
            self.cap = at;
            self.len = cmp::min(self.len, at);
            other
        }
    }

    pub fn split_to(&mut self, at: usize) -> BytesMut {
        assert!(
            at <= self.len(),
            "split_to out of bounds: {:?} <= {:?}",
            at,
            self.len(),
        );

        unsafe {
            // ...
            let mut other = self.shallow_clone();
            // ...
            self.advance_unchecked(at);
            other.cap = at;
            other.len = at;
            other
        }
    }

    unsafe fn shallow_clone(&mut self) -> BytesMut {
        if self.kind() == KIND_ARC {
            increment_shared(self.data);
            ptr::read(self)
        } else {
            self.promote_to_shared(/*ref_count = */ 2);
            ptr::read(self)
        }
    }

        let shared = Box::new(MaybeUninit::<Shared>::uninit());
        let shared = Shared::init_to_raw(
            shared,
            Shared {
                vec: rebuild_vec(self.ptr.as_ptr(), self.len, self.cap, off),
                original_capacity_repr,
                ref_count: AtomicUsize::new(ref_cnt),
            },
        );
        // ...
        self.data = shared;

bytes = "=1.12.1"

use bytes::{BufMut, BytesMut};

#[path = "../common.rs"]
mod common;
use common::*;

fn show(name: &str, b: &BytesMut, base: *const u8) -> String {
  format!("{name}: ptr={} len={} cap={}", at(b.as_ptr(), base, 64), b.len(), b.capacity())
}

fn main() {
  let mut buf = BytesMut::with_capacity(64);
  buf.put_slice(b"aaabbbcccddd");
  let base = buf.as_ptr();

  let (mut tail, d) = count(|| buf.split_off(6));
  println!("{:<18} {d}  {} | {}", "split_off(6)", show("buf", &buf, base), show("tail", &tail, base));

  let (mid, d) = count(|| tail.split_to(3));
  println!("{:<18} {d}  {} | {}", "tail.split_to(3)", show("mid", &mid, base), show("tail", &tail, base));

  let (rest, d) = count(|| tail.split());
  println!("{:<18} {d}  {} | {}", "tail.split()", show("rest", &rest, base), show("tail", &tail, base));

  let (_, d) = count(|| buf.unsplit(mid));
  println!("{:<18} {d}  {}", "buf.unsplit(mid)", show("buf", &buf, base));
  let (_, d) = count(|| buf.unsplit(rest));
  println!("{:<18} {d}  {}", "buf.unsplit(rest)", show("buf", &buf, base));
  let (_, d) = count(|| buf.unsplit(tail));
  println!("{:<18} {d}  {}", "buf.unsplit(tail)", show("buf", &buf, base));
  println!("{:<18} {:?}", "content", std::str::from_utf8(&buf).unwrap());

  let (_, d) = count(|| drop(buf));
  println!("{:<18} {d}", "drop(buf)");

  // 空的也会提升
  let mut empty = BytesMut::with_capacity(64);
  let (e, d) = count(|| empty.split());
  println!("{:<18} {d}  e.len={} e.cap={} empty.cap={}", "empty.split()", e.len(), e.capacity(), empty.capacity());
  let mut zero = BytesMut::new();
  let (z, d) = count(|| zero.split());
  println!("{:<18} {d}  z.cap={}", "new().split()", z.capacity());
}

split_off(6)       alloc+1 (40B) free+0  buf: ptr=base+0 len=6 cap=6 | tail: ptr=base+6 len=6 cap=58
tail.split_to(3)   alloc+0 (0B) free+0  mid: ptr=base+6 len=3 cap=3 | tail: ptr=base+9 len=3 cap=55
tail.split()       alloc+0 (0B) free+0  rest: ptr=base+9 len=3 cap=3 | tail: ptr=base+12 len=0 cap=52
buf.unsplit(mid)   alloc+0 (0B) free+0  buf: ptr=base+0 len=9 cap=9
buf.unsplit(rest)  alloc+0 (0B) free+0  buf: ptr=base+0 len=12 cap=12
buf.unsplit(tail)  alloc+0 (0B) free+0  buf: ptr=base+0 len=12 cap=64
content            "aaabbbcccddd"
drop(buf)          alloc+0 (0B) free+2

empty.split()      alloc+1 (40B) free+0  e.len=0 e.cap=0 empty.cap=64
new().split()      alloc+1 (40B) free+0  z.cap=0

use std::panic;

use bytes::{BufMut, BytesMut};

fn main() {
  panic::set_hook(Box::new(|info| {
    let msg = info.payload().downcast_ref::<String>().cloned()
      .or_else(|| info.payload().downcast_ref::<&str>().map(|s| s.to_string()))
      .unwrap_or_default();
    let loc = info.location().unwrap();
    let file = loc.file().rsplit("bytes-1.12.1/").next().unwrap();
    println!("    panicked at {file}:{}: {msg}", loc.line());
  }));

  let make = || {
    let mut b = BytesMut::with_capacity(64);
    b.put_slice(b"hello world"); // len 11, cap 64
    b
  };
  let cases: Vec<(&str, Box<dyn Fn()>)> = vec![
    ("split_to(20)", Box::new(move || drop(make().split_to(20)))),
    ("split_off(65)", Box::new(move || drop(make().split_off(65)))),
  ];
  for (name, f) in cases {
    println!("{name}");
    let _ = panic::catch_unwind(panic::AssertUnwindSafe(f));
  }
  let mut b = make();
  let t = b.split_off(20);
  println!("split_off(20): no panic, self len={} cap={}, other len={} cap={}",
    b.len(), b.capacity(), t.len(), t.capacity());
}

split_to(20)
    panicked at src/bytes_mut.rs:408: split_to out of bounds: 20 <= 11
split_off(65)
    panicked at src/bytes_mut.rs:329: split_off out of bounds: 65 <= 64
split_off(20): no panic, self len=11 cap=20, other len=0 cap=44

    pub fn freeze(self) -> Bytes {
        let bytes = ManuallyDrop::new(self);
        if bytes.kind() == KIND_VEC {
            // Just re-use `Bytes` internal Vec vtable
            unsafe {
                let off = bytes.get_vec_pos();
                let vec = rebuild_vec(bytes.ptr.as_ptr(), bytes.len, bytes.cap, off);
                let mut b: Bytes = vec.into();
                b.advance(off);
                b
            }
        } else {
            debug_assert_eq!(bytes.kind(), KIND_ARC);

            let ptr = bytes.ptr.as_ptr();
            let len = bytes.len;
            let data = AtomicPtr::new(bytes.data.cast());
            unsafe { Bytes::with_vtable(ptr, len, data, &SHARED_VTABLE) }
        }
    }

impl Clone for BytesMut {
    fn clone(&self) -> BytesMut {
        BytesMut::from(&self[..])
    }
}

    fn from(bytes: Bytes) -> Self {
        let mut bytes = ManuallyDrop::new(bytes);
        let data = bytes.data_mut();
        unsafe { (bytes.vtable.into_mut)(data, bytes.ptr, bytes.len) }
    }

    if (*shared).is_unique() {
        let shared = &mut *shared;

        // The capacity is always the original capacity of the buffer
        // minus the offset from the start of the buffer
        let v = &mut shared.vec;
        let v_capacity = v.capacity();
        let v_ptr = v.as_mut_ptr();
        let offset = ptr.offset_from(v_ptr) as usize;
        let cap = v_capacity - offset;

        let ptr = vptr(ptr as *mut u8);

        BytesMut {
            ptr,
            len,
            cap,
            data: shared,
        }
    } else {
        let v = slice::from_raw_parts(ptr, len).to_vec();
        release_shared(shared);
        BytesMut::from_vec(v)
    }

use bytes::{BufMut, Bytes, BytesMut};

#[path = "../common.rs"]
mod common;
use common::*;

fn fresh() -> (BytesMut, *const u8) {
  let mut buf = BytesMut::with_capacity(64);
  buf.put_slice(b"aaabbbcccddd");
  let base = buf.as_ptr();
  (buf, base)
}

fn show(b: &BytesMut, base: *const u8) -> String {
  format!("ptr={} len={} cap={}", at(b.as_ptr(), base, 64), b.len(), b.capacity())
}

fn main() {
  // BytesMut::clone
  let (buf, base) = fresh();
  let (c, d) = count(|| buf.clone());
  println!("{:<30} {d}  {}", "clone", show(&c, base));

  // KIND_VEC：freeze 再转回来
  let (buf, base) = fresh();
  let (b, d) = count(|| buf.freeze());
  println!("{:<30} {d}", "KIND_VEC freeze");
  let (m, d) = count(|| BytesMut::from(b));
  println!("{:<30} {d}  {}", "  -> BytesMut::from", show(&m, base));

  // KIND_ARC：另一半还活着
  let (mut buf, base) = fresh();
  let head = buf.split_to(6).freeze();
  let (m, d) = count(|| BytesMut::from(head));
  println!("{:<30} {d}  {}", "KIND_ARC, other alive", show(&m, base));
  drop(m);
  drop(buf);

  // KIND_ARC：另一半先 drop
  let (mut buf, base) = fresh();
  let head = buf.split_to(6).freeze();
  drop(buf);
  let (m, d) = count(|| BytesMut::from(head));
  println!("{:<30} {d}  {}", "KIND_ARC, other dropped", show(&m, base));

  // 静态
  let s = Bytes::from_static(b"static");
  let (m, d) = count(|| BytesMut::from(s));
  println!("{:<30} {d}  len={} cap={}", "from_static", m.len(), m.capacity());
}

clone                          alloc+1 (12B) free+0  ptr=elsewhere len=12 cap=12
KIND_VEC freeze                alloc+1 (24B) free+0
  -> BytesMut::from            alloc+0 (0B) free+1  ptr=base+0 len=12 cap=64
KIND_ARC, other alive          alloc+1 (6B) free+0  ptr=elsewhere len=6 cap=6
KIND_ARC, other dropped        alloc+0 (0B) free+0  ptr=base+0 len=6 cap=64
from_static                    alloc+1 (6B) free+0  len=6 cap=6

    pub fn unsplit(&mut self, other: BytesMut) {
        if self.is_empty() {
            *self = other;
            return;
        }

        if let Err(other) = self.try_unsplit(other) {
            self.extend_from_slice(other.as_ref());
        }
    }

    pub fn try_unsplit(&mut self, other: BytesMut) -> Result<(), BytesMut> {
        if other.capacity() == 0 {
            return Ok(());
        }

        let ptr = unsafe { self.ptr.as_ptr().add(self.len) };
        if ptr == other.ptr.as_ptr()
            && self.kind() == KIND_ARC
            && other.kind() == KIND_ARC
            && self.data == other.data
        {
            // Contiguous blocks, just combine directly
            self.len += other.len;
            self.cap += other.cap;
            Ok(())
        } else {
            Err(other)
        }
    }

use bytes::{BufMut, BytesMut};

#[path = "../common.rs"]
mod common;
use common::*;

// base 是最初那块缓冲的 (起点, 容量)
fn fresh(cap: usize) -> (BytesMut, (*const u8, usize)) {
  let mut buf = BytesMut::with_capacity(cap);
  buf.put_slice(b"aaabbbcccddd");
  let base = (buf.as_ptr(), buf.capacity());
  (buf, base)
}

fn show(b: &BytesMut, base: (*const u8, usize)) -> String {
  format!("{:?} ptr={} len={} cap={}",
    std::str::from_utf8(b).unwrap(), at(b.as_ptr(), base.0, base.1), b.len(), b.capacity())
}

fn main() {
  // 1. 相邻：split_off 出去再并回来
  let (mut buf, base) = fresh(64);
  let tail = buf.split_off(6);
  let (_, d) = count(|| buf.unsplit(tail));
  println!("{:<24} {d}  {}", "contiguous", show(&buf, base));

  // 2. 顺序反了：后半段 unsplit 前半段，后面还有空位
  let (mut buf, base) = fresh(64);
  let head = buf.split_to(6);
  let (_, d) = count(|| buf.unsplit(head));
  println!("{:<24} {d}  {}", "reversed, spare cap", show(&buf, base));

  // 3. 顺序反了，而且没有空位（len == cap）
  let (mut buf, base) = fresh(12);
  let head = buf.split_to(6);
  let (_, d) = count(|| buf.unsplit(head));
  println!("{:<24} {d}  {}", "reversed, full", show(&buf, base));

  // 4. 中间隔着一段
  let (mut buf, base) = fresh(64);
  let mut a = buf.split_to(3);
  let _gap = buf.split_to(3);
  let (_, d) = count(|| a.unsplit(buf));
  println!("{:<24} {d}  {}", "gap in between", show(&a, base));

  // 5. 两块不同的分配
  let (mut x, base) = fresh(12);
  let y = BytesMut::from(&b"zz"[..]);
  let (_, d) = count(|| x.unsplit(y));
  println!("{:<24} {d}  {}", "different allocation", show(&x, base));

  // 6. self 是空的：直接换成 other
  let (mut buf, base) = fresh(64);
  let all = buf.split();
  let (_, d) = count(|| buf.unsplit(all));
  println!("{:<24} {d}  {}", "self empty", show(&buf, base));
  // 反过来并：all 在前，buf 在后
  let (mut buf, base) = fresh(64);
  let mut all = buf.split();
  let (_, d) = count(|| all.unsplit(buf));
  println!("{:<24} {d}  {}", "other empty, cap 52", show(&all, base));
}

contiguous               alloc+0 (0B) free+0  "aaabbbcccddd" ptr=base+0 len=12 cap=64
reversed, spare cap      alloc+0 (0B) free+0  "cccdddaaabbb" ptr=base+6 len=12 cap=58
reversed, full           alloc+1 (12B) free+2  "cccdddaaabbb" ptr=elsewhere len=12 cap=12
gap in between           alloc+1 (9B) free+0  "aaacccddd" ptr=elsewhere len=9 cap=9
different allocation     alloc+1 (24B) free+2  "aaabbbcccdddzz" ptr=elsewhere len=14 cap=24
self empty               alloc+0 (0B) free+0  "aaabbbcccddd" ptr=base+0 len=12 cap=12
other empty, cap 52      alloc+0 (0B) free+0  "aaabbbcccddd" ptr=base+0 len=12 cap=64

use bytes::{BufMut, BytesMut};

#[path = "../common.rs"]
mod common;
use common::*;

fn fresh() -> BytesMut {
  let mut buf = BytesMut::with_capacity(64);
  buf.put_slice(b"aaabbbcccddd");
  buf
}

fn report(name: &str, buf: &mut BytesMut, other: BytesMut) {
  let other_ptr = other.as_ptr();
  let (r, d) = count(|| buf.try_unsplit(other));
  match r {
    Ok(()) => println!("{name:<26} {d}  Ok   self len={} cap={}", buf.len(), buf.capacity()),
    Err(o) => println!("{name:<26} {d}  Err  same handle={} len={} cap={} | self len={} cap={}",
      o.as_ptr() == other_ptr, o.len(), o.capacity(), buf.len(), buf.capacity()),
  }
}

fn main() {
  // 1. 顺序反了
  let mut buf = fresh();
  let head = buf.split_to(6);
  report("reversed", &mut buf, head);

  // 2. 中间隔着一段
  let mut buf = fresh();
  let mut a = buf.split_to(3);
  let _gap = buf.split_to(3);
  report("gap in between", &mut a, buf);

  // 3. split_off 的位置超过 len：self 后面有没写的容量
  let mut buf = BytesMut::with_capacity(64);
  buf.put_slice(b"aaabbb");
  let tail = buf.split_off(10);
  report("split_off past len", &mut buf, tail);

  // 4. self 从没 split 过（KIND_VEC），other 来自别处
  let mut x = fresh();
  report("self never split", &mut x, BytesMut::from(&b"zz"[..]));

  // 5. 两边各自 split 过，但不是同一块分配
  let mut x = fresh();
  let _x2 = x.split_off(12);
  let mut y = fresh();
  let y2 = y.split_off(0);
  report("two different Shared", &mut x, y2);

  // 6. other 容量为 0：直接 Ok，哪怕它来自别处
  let mut x = fresh();
  report("other cap 0 (new())", &mut x, BytesMut::new());
}

reversed                   alloc+0 (0B) free+0  Err  same handle=true len=6 cap=6 | self len=6 cap=58
gap in between             alloc+0 (0B) free+0  Err  same handle=true len=6 cap=58 | self len=3 cap=3
split_off past len         alloc+0 (0B) free+0  Err  same handle=true len=0 cap=54 | self len=6 cap=10
self never split           alloc+0 (0B) free+0  Err  same handle=true len=2 cap=2 | self len=12 cap=64
two different Shared       alloc+0 (0B) free+0  Err  same handle=true len=12 cap=64 | self len=12 cap=12
other cap 0 (new())        alloc+0 (0B) free+0  Ok   self len=12 cap=64

before: buf len=11 cap=20, tail len=0 cap=44
unsplit: alloc+0 (0B) free+0
after:  buf len=11 cap=20