Optimize Bytes::copy_from_slice

[stepancheg]

Create a new SharedInline Bytes representation, which is:

struct SharedInline {
    ref_cnt: AtomicUsize,
    cap: usize,
    // data: [u8; cap],
}

The advantage of this representation is that we do not need an extra
allocation when cloning Bytes which makes such cloning much faster
and without extra allocation.

The drawback is a slightly lower performance of such object destruction
due to atomic decrement.

The bench:

#[bench]
fn copy_from_slice_and_clone(b: &mut Bencher) {
    b.iter(|| {
        Bytes::copy_from_slice(b"abcdef").clone()
    });
}

becomes two times faster (210ns/iter vs 110ns/iter).

While non-shared bench:

#[bench]
fn copy_from_slice(b: &mut Bencher) {
    b.iter(|| {
        Bytes::copy_from_slice(b"abcdef")
    });
}

becomes a little slower (85ns/iter vs 90ns/iter).

[seanmonstar]

I didn't understand at first, but now I get it:

• When built with an existing Vec, there's 2 allocations, the Shared which is a skinny Arc, and then the Vec inside it.
• When we'd need to allocate a Vec ourselves, we could just allocate once, and smash the Arc and Vec into 1.

[seanmonstar]

Can this just be an actual DST? Admittedly I haven't tried to use that part of Rust much...

[stepancheg]

@seanmonstar it can't because *mut SharedInline must be one word size (to fit into AtomicPtr()), and DST is two words.