berkus
/
bincode-orig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added unty dependency and added type checks (#667) 

* Added unty dependency and added type checks

* Bumped unty 0.0.2

* Bump unty to 0.0.3

* Removed unneeded + Sized requirements
Optimize encode for [T; N]
Made BinaryHeap<T> proxy to Vec<T>
Made VecDeque decode/borrowdecode proxy to Vec<T>
Optimize VecDeque::<u8>::Encode to write 2 slices directly
Optimize Vec<u8> borrowdecode implementation

---------

Co-authored-by: Victor Koenders <git@trang.ar>
This commit is contained in:
Trangar 2023-09-28 17:32:11 +02:00 committed by GitHub
parent feae25878a
commit e03c9b06db
4 changed files with 190 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.toml
View File

@ -33,6 +33,7 @@ derive = ["bincode_derive"]
[dependencies]
bincode_derive = { path = "derive", version = "2.0.0-rc.3", optional = true }
serde = { version = "1.0", default-features = false, optional = true }
unty = "0.0.3"
# Used for tests
[dev-dependencies]

64
src/de/impls.rs
View File

@ -441,24 +441,21 @@ impl<'a, 'de: 'a> BorrowDecode<'de> for &'a str {
impl<T, const N: usize> Decode for [T; N]
where
T: Decode + Sized,
T: Decode,
{
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
decoder.claim_bytes_read(core::mem::size_of::<[T; N]>())?;
// TODO: we can't limit `T: 'static` because that would break other things
// but we want to have this optimization
// This will be another contendor for specialization implementation
// if TypeId::of::<u8>() == TypeId::of::<T>() {
// let mut buf = [0u8; N];
// decoder.reader().read(&mut buf)?;
// let ptr = &mut buf as *mut _ as *mut [T; N];
if unty::type_equal::<T, u8>() {
let mut buf = [0u8; N];
decoder.reader().read(&mut buf)?;
let ptr = &mut buf as *mut _ as *mut [T; N];
// // Safety: we know that T is a u8, so it is perfectly safe to
// // translate an array of u8 into an array of T
// let res = unsafe { ptr.read() };
// Ok(res)
// }
// Safety: we know that T is a u8, so it is perfectly safe to
// translate an array of u8 into an array of T
let res = unsafe { ptr.read() };
Ok(res)
} else {
let result = super::impl_core::collect_into_array(&mut (0..N).map(|_| {
// See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<T>());
@ -469,28 +466,26 @@ where
// So this unwrap should never occur
result.unwrap()
}
}
}
impl<'de, T, const N: usize> BorrowDecode<'de> for [T; N]
where
T: BorrowDecode<'de> + Sized,
T: BorrowDecode<'de>,
{
fn borrow_decode<D: BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, DecodeError> {
decoder.claim_bytes_read(core::mem::size_of::<[T; N]>())?;
// TODO: we can't limit `T: 'static` because that would break other things
// but we want to have this optimization
// This will be another contendor for specialization implementation
// if TypeId::of::<u8>() == TypeId::of::<T>() {
// let mut buf = [0u8; N];
// decoder.reader().read(&mut buf)?;
// let ptr = &mut buf as *mut _ as *mut [T; N];
if unty::type_equal::<T, u8>() {
let mut buf = [0u8; N];
decoder.reader().read(&mut buf)?;
let ptr = &mut buf as *mut _ as *mut [T; N];
// // Safety: we know that T is a u8, so it is perfectly safe to
// // translate an array of u8 into an array of T
// let res = unsafe { ptr.read() };
// Ok(res)
// }
// Safety: we know that T is a u8, so it is perfectly safe to
// translate an array of u8 into an array of T
let res = unsafe { ptr.read() };
Ok(res)
} else {
let result = super::impl_core::collect_into_array(&mut (0..N).map(|_| {
// See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<T>());
@ -501,6 +496,7 @@ where
// So this unwrap should never occur
result.unwrap()
}
}
}
impl Decode for () {
@ -547,22 +543,6 @@ where
}
}
// BlockedTODO: https://github.com/rust-lang/rust/issues/37653
//
// We'll want to implement BorrowDecode for both Option<&[u8]> and Option<&[T: Encode]>,
// but those implementations overlap because &'a [u8] also implements BorrowDecode
// impl<'a, 'de: 'a> BorrowDecode<'de> for Option<&'a [u8]> {
// fn borrow_decode<D: BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, DecodeError> {
// match super::decode_option_variant(decoder, core::any::type_name::<Option<&[u8]>>())? {
// Some(_) => {
// let val = BorrowDecode::borrow_decode(decoder)?;
// Ok(Some(val))
// }
// None => Ok(None),
// }
// }
// }
impl<T, U> Decode for Result<T, U>
where
T: Decode,

22
src/enc/impls.rs
View File

@ -280,24 +280,15 @@ impl Encode for char {
}
}
// BlockedTODO: https://github.com/rust-lang/rust/issues/37653
//
// We'll want to implement encoding for both &[u8] and &[T: Encode],
// but those implementations overlap because u8 also implements Encode
// impl Encode for &'_ [u8] {
// fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
// encoder.writer().write(*self)
// }
// }
impl<T> Encode for [T]
where
T: Encode + 'static,
T: Encode,
{
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
super::encode_slice_len(encoder, self.len())?;
if core::any::TypeId::of::<T>() == core::any::TypeId::of::<u8>() {
if unty::type_equal::<T, u8>() {
// Safety: T = u8
let t: &[u8] = unsafe { core::mem::transmute(self) };
encoder.writer().write(t)?;
return Ok(());
@ -355,11 +346,18 @@ where
T: Encode,
{
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
if unty::type_equal::<T, u8>() {
// Safety: this is &[u8; N]
let array_slice: &[u8] =
unsafe { core::slice::from_raw_parts(self.as_ptr().cast(), N) };
encoder.writer().write(array_slice)
} else {
for item in self.iter() {
item.encode(encoder)?;
}
Ok(())
}
}
}
impl<T> Encode for Option<T>

117
src/features/impl_alloc.rs
View File

@ -1,5 +1,5 @@
use crate::{
de::{BorrowDecoder, Decode, Decoder},
de::{read::Reader, BorrowDecoder, Decode, Decoder},
enc::{
self,
write::{SizeWriter, Writer},
@ -8,8 +8,6 @@ use crate::{
error::{DecodeError, EncodeError},
impl_borrow_decode, BorrowDecode, Config,
};
#[cfg(target_has_atomic = "ptr")]
use alloc::sync::Arc;
use alloc::{
borrow::{Cow, ToOwned},
boxed::Box,
@ -19,6 +17,9 @@ use alloc::{
vec::Vec,
};
#[cfg(target_has_atomic = "ptr")]
use alloc::sync::Arc;
#[derive(Default)]
pub(crate) struct VecWriter {
inner: Vec<u8>,
@ -67,18 +68,7 @@ where
T: Decode + Ord,
{
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(decoder)?;
decoder.claim_container_read::<T>(len)?;
let mut map = BinaryHeap::with_capacity(len);
for _ in 0..len {
// See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<T>());
let key = T::decode(decoder)?;
map.push(key);
}
Ok(map)
Ok(Vec::<T>::decode(decoder)?.into())
}
}
impl<'de, T> BorrowDecode<'de> for BinaryHeap<T>
@ -86,18 +76,7 @@ where
T: BorrowDecode<'de> + Ord,
{
fn borrow_decode<D: BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(decoder)?;
decoder.claim_container_read::<T>(len)?;
let mut map = BinaryHeap::with_capacity(len);
for _ in 0..len {
// See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<T>());
let key = T::borrow_decode(decoder)?;
map.push(key);
}
Ok(map)
Ok(Vec::<T>::borrow_decode(decoder)?.into())
}
}
@ -106,6 +85,7 @@ where
T: Encode + Ord,
{
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
// BLOCKEDTODO(https://github.com/rust-lang/rust/issues/83659): we can u8 optimize this with `.as_slice()`
crate::enc::encode_slice_len(encoder, self.len())?;
for val in self.iter() {
val.encode(encoder)?;
@ -229,18 +209,7 @@ where
T: Decode,
{
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(decoder)?;
decoder.claim_container_read::<T>(len)?;
let mut map = VecDeque::with_capacity(len);
for _ in 0..len {
// See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<T>());
let key = T::decode(decoder)?;
map.push_back(key);
}
Ok(map)
Ok(Vec::<T>::decode(decoder)?.into())
}
}
impl<'de, T> BorrowDecode<'de> for VecDeque<T>
@ -248,18 +217,7 @@ where
T: BorrowDecode<'de>,
{
fn borrow_decode<D: BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(decoder)?;
decoder.claim_container_read::<T>(len)?;
let mut map = VecDeque::with_capacity(len);
for _ in 0..len {
// See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<T>());
let key = T::borrow_decode(decoder)?;
map.push_back(key);
}
Ok(map)
Ok(Vec::<T>::borrow_decode(decoder)?.into())
}
}
@ -269,9 +227,23 @@ where
{
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
crate::enc::encode_slice_len(encoder, self.len())?;
if unty::type_equal::<T, u8>() {
let slices: (&[T], &[T]) = self.as_slices();
// Safety: T is u8 so turning this into `&[u8]` is okay
let slices: (&[u8], &[u8]) = unsafe {
(
core::slice::from_raw_parts(slices.0.as_ptr().cast(), slices.0.len()),
core::slice::from_raw_parts(slices.1.as_ptr().cast(), slices.1.len()),
)
};
encoder.writer().write(slices.0)?;
encoder.writer().write(slices.1)?;
} else {
for item in self.iter() {
item.encode(encoder)?;
}
}
Ok(())
}
}
@ -283,18 +255,15 @@ where
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(decoder)?;
// TODO: we can't limit `T: 'static` because that would break other things
// but we want to have this optimization
// This will be another contendor for specialization implementation
// if core::any::TypeId::of::<T>() == core::any::TypeId::of::<u8>() {
// decoder.claim_container_read::<T>(len)?;
// // optimize for reading u8 vecs
// let mut vec = Vec::new();
// vec.resize(len, 0u8);
// decoder.reader().read(&mut vec)?;
// // Safety: Vec<T> is Vec<u8>
// return Ok(unsafe { core::mem::transmute(vec) });
// }
if unty::type_equal::<T, u8>() {
decoder.claim_container_read::<T>(len)?;
// optimize for reading u8 vecs
let mut vec = Vec::new();
vec.resize(len, 0u8);
decoder.reader().read(&mut vec)?;
// Safety: Vec<T> is Vec<u8>
Ok(unsafe { core::mem::transmute(vec) })
} else {
decoder.claim_container_read::<T>(len)?;
let mut vec = Vec::with_capacity(len);
@ -306,6 +275,7 @@ where
}
Ok(vec)
}
}
}
impl<'de, T> BorrowDecode<'de> for Vec<T>
@ -314,6 +284,16 @@ where
{
fn borrow_decode<D: BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(decoder)?;
if unty::type_equal::<T, u8>() {
decoder.claim_container_read::<T>(len)?;
// optimize for reading u8 vecs
let mut vec = Vec::new();
vec.resize(len, 0u8);
decoder.reader().read(&mut vec)?;
// Safety: Vec<T> is Vec<u8>
Ok(unsafe { core::mem::transmute(vec) })
} else {
decoder.claim_container_read::<T>(len)?;
let mut vec = Vec::with_capacity(len);
@ -325,24 +305,27 @@ where
}
Ok(vec)
}
}
}
impl<T> Encode for Vec<T>
where
T: Encode + 'static,
T: Encode,
{
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
crate::enc::encode_slice_len(encoder, self.len())?;
if core::any::TypeId::of::<T>() == core::any::TypeId::of::<u8>() {
if unty::type_equal::<T, u8>() {
// Safety: T == u8
let slice: &[u8] = unsafe { core::mem::transmute(self.as_slice()) };
encoder.writer().write(slice)?;
return Ok(());
}
Ok(())
} else {
for item in self.iter() {
item.encode(encoder)?;
}
Ok(())
}
}
}
impl Decode for String {