libcc2rs optimizations to speedup Brunsli

Author: nunoplopes

libcc2rs-macros/src/record.rs

@@ -39,7 +39,7 @@ pub fn expand(input: TokenStream) -> TokenStream {
     // The field that contains a byte is one that starts before it, usually
     // the last one, as fields are usually declared in the order of their
     // offsets.
-    let locate = fields.iter().rev().map(|(ident, _)| {
+    let locate = search_fields(&fields, &|ident| {
         quote! {
             if offset >= Self::OFFSETS.#ident {
                 if let ::core::option::Option::Some(field) = ::libcc2rs::__locate_field!(
@@ -49,7 +49,7 @@ pub fn expand(input: TokenStream) -> TokenStream {
             }
         }
     });
-    let locate_mut = fields.iter().rev().map(|(ident, _)| {
+    let locate_mut = search_fields(&fields, &|ident| {
         quote! {
             if offset >= Self::OFFSETS.#ident {
                 if let ::core::option::Option::Some(field) = ::libcc2rs::__locate_field_mut!(
@@ -59,7 +59,7 @@ pub fn expand(input: TokenStream) -> TokenStream {
             }
         }
     });
-    let len_at = fields.iter().rev().map(|(ident, _)| {
+    let len_at = search_fields(&fields, &|ident| {
         quote! {
             if offset >= Self::OFFSETS.#ident {
                 if let ::core::option::Option::Some(len) = ::libcc2rs::__len_field!(
@@ -91,7 +91,7 @@ pub fn expand(input: TokenStream) -> TokenStream {
                 if offset == 0 && ty == ::std::any::TypeId::of::<Self>() {
                     return ::core::option::Option::Some(self);
                 }
-                #(#locate)*
+                #locate
                 ::core::option::Option::None
             }
 
@@ -105,16 +105,42 @@ pub fn expand(input: TokenStream) -> TokenStream {
                 if offset == 0 && ty == ::std::any::TypeId::of::<Self>() {
                     return ::core::option::Option::Some(self);
                 }
-                #(#locate_mut)*
+                #locate_mut
                 ::core::option::Option::None
             }
 
             #[allow(unused_comparisons)]
             fn len_at(&self, offset: usize) -> ::core::option::Option<usize> {
-                #(#len_at)*
+                #len_at
                 ::core::option::Option::None
             }
         }
     }
     .into()
 }
+
+// The searches of `fields`, from the last one to the first one, for the field
+// that contains byte `offset`. Those in the second half of the fields are
+// skipped if all of them start after the byte, which is checked against the
+// smallest of their offsets, so the fields can be in any order.
+fn search_fields(
+    fields: &[(Ident, Expr)],
+    search: &dyn Fn(&Ident) -> proc_macro2::TokenStream,
+) -> proc_macro2::TokenStream {
+    if fields.len() <= 4 {
+        let searches = fields.iter().rev().map(|(ident, _)| search(ident));
+        return quote! { #(#searches)* };
+    }
+    let (first, second) = fields.split_at(fields.len() / 2);
+    let starts = second
+        .iter()
+        .map(|(ident, _)| quote! { Self::OFFSETS.#ident });
+    let first = search_fields(first, search);
+    let second = search_fields(second, search);
+    quote! {
+        if offset >= const { ::libcc2rs::__field::min_offset(&[#(#starts),*]) } {
+            #second
+        }
+        #first
+    }
+}

libcc2rs/src/field.rs

@@ -449,9 +449,16 @@ where
     G: Fn(&S) -> &Vec<T> + Copy + 'static,
     M: Fn(&mut S) -> &mut Vec<T> + Copy + 'static,
 {
+    // The elements are reached through the struct, rather than through a
+    // pointer to the vector, which would be a parent of every access to them.
     #[inline]
     fn decay(&self) -> Ptr<T> {
-        self.as_pointer().decay()
+        match &self.base.kind {
+            PtrKind::Field(_, _, FieldShape::Single) => self.as_pointer().decay(),
+            _ => self
+                .base
+                .elems_of(self.get, self.get_mut, (self.offset)(&S::OFFSETS), false),
+        }
     }
 }
 
@@ -1020,7 +1027,6 @@ impl<S: Record, T: ByteRepr> VecElem<'_, S, T> {
         let elems: Ptr<T> = self
             .base
             .field_ref(self.get, self.get_mut, self.offset)
-            .as_pointer()
             .decay();
         elems.offset(self.idx).upgrade()
     }
@@ -1201,6 +1207,21 @@ macro_rules! __len_field {
     }};
 }
 
+// The smallest of the offsets of some fields, which Record::locate compares
+// the offset that it looks for with to skip all of them.
+#[doc(hidden)]
+pub const fn min_offset(offsets: &[usize]) -> usize {
+    let mut min = usize::MAX;
+    let mut i = 0;
+    while i < offsets.len() {
+        if offsets[i] < min {
+            min = offsets[i];
+        }
+        i += 1;
+    }
+    min
+}
+
 impl<T: 'static> Ptr<T> {
     // Borrows the field at byte `offset` of `root`.
     #[inline]
@@ -1655,6 +1676,49 @@ mod tests {
         assert_ne!(a.offset(2), array_field_ptr!(other, b));
     }
 
+    // A struct with enough fields for Record::locate to search them in
+    // halves, which are not in the order of their offsets, as in some libc
+    // structs.
+    #[derive(Default, Record, ByteRepr)]
+    #[byte_size(28)]
+    struct Shuffled {
+        #[offset(20)]
+        f: i32,
+        #[offset(0)]
+        a: i32,
+        #[offset(4)]
+        b: i32,
+        #[offset(16)]
+        e: i32,
+        #[offset(8)]
+        inner: Inner,
+        #[offset(24)]
+        g: i32,
+    }
+
+    #[test]
+    fn fields_out_of_order() {
+        let s: Value<Shuffled> = Rc::new(RefCell::new(Shuffled::default()));
+        let fields = [
+            field_ptr!(s, a),
+            field_ptr!(s, b),
+            field_ptr!(field_ptr!(s, inner), a),
+            field_ptr!(field_ptr!(s, inner), b),
+            field_ptr!(s, e),
+            field_ptr!(s, f),
+            field_ptr!(s, g),
+        ];
+        for (i, p) in fields.iter().enumerate() {
+            p.write(i as i32 + 1);
+        }
+        for (i, p) in fields.iter().enumerate() {
+            assert_eq!(p.read(), i as i32 + 1);
+        }
+        let s = s.borrow();
+        assert_eq!((s.a, s.b, s.inner.a, s.inner.b), (1, 2, 3, 4));
+        assert_eq!((s.e, s.f, s.g), (5, 6, 7));
+    }
+
     #[test]
     fn pointer_size() {
         // Pointers to elements of fields are no larger than other pointers.

libcc2rs/src/lib.rs

@@ -18,7 +18,7 @@ pub use field::{
 pub mod __field {
     pub use crate::field::{
         LenLeaf, LenOf, LenRecord, LenSlice, Locate, LocateLeaf, LocateLeafMut, LocateMut,
-        LocateRecord, LocateRecordMut, size_of_pointee,
+        LocateRecord, LocateRecordMut, min_offset, size_of_pointee,
     };
 }