slightly optimize Layout::repeat_packed

Author: echohumm

.github/workflows/test.macos.tmp.yml

@@ -142,7 +142,6 @@ impl Dealloc for CAlloc {
         Ok(())
     }
 }
-// TODO: now that grow and shrink are gone, a manual realloc may actually be good
 impl Realloc for CAlloc {}
 
 pub use crate::ffi::c_alloc as ffi;

src/allocs/c_alloc.rs

@@ -176,6 +176,17 @@ impl Layout {
         let new_align = if a_aln > b_aln { a_aln } else { b_aln };
 
         // check the total size fits within limits and doesn't overflow.
+        // TODO: maybe use the overflow check trick here instead too
+        //  DRAFT:
+        //         if a_sz > usize::MAX - offset {
+        //             return Err(LayoutErr::ArithErr(ArithErr(a_sz, ArithOp::Add, offset)));
+        //         }
+        //         let total = a_sz + offset;
+        //         if total > USIZE_MAX_NO_HIGH_BIT {
+        //             return Err(LayoutErr::ExceedsMax(offset, new_align, 1));
+        //         }
+        //         // SAFETY: we validated alignment and size constraints above.
+        //         Ok((unsafe { Layout::from_size_align_unchecked(total, new_align) }, offset))
         match checked_op(a_sz, ArithOp::Add, offset) {
             Ok(total) if total <= USIZE_MAX_NO_HIGH_BIT => {
                 // SAFETY: we validated alignment and size constraints above.
@@ -419,13 +430,11 @@ impl Layout {
     #[::rustversion::attr(since(1.47), const)]
     #[inline]
     pub fn repeat_packed(&self, count: usize) -> Result<Layout, LayoutErr> {
-        // TODO: use the overflow check trick here? alternatively, use checked_op more elsewhere?
-        //  need to test both for speed.
-        let size = match checked_op(self.size(), ArithOp::Mul, count) {
-            Ok(s) => s,
-            Err(e) => return Err(LayoutErr::ArithErr(e))
-        };
-        match Layout::from_size_align(size, self.align()) {
+        // this is ~1.6x faster than using checked_op
+        if count > usize::MAX / self.size() {
+            return Err(LayoutErr::ArithErr(ArithErr(self.size(), ArithOp::Mul, count)));
+        }
+        match Layout::from_size_align(self.size() * count, self.align()) {
             Ok(layout) => Ok(layout),
             Err(e) => Err(e)
         }