Optimize dynamic std types

Author: ironcev

docs/book/src/reference/undefined_behavior.md

@@ -14,3 +14,5 @@ reserve the right to make some of the listed behavior defined in the future.
 * Reading and writing `raw_ptr` and `raw_slice`.
 * Slicing and indexing out of bounds by directly using compiler intrinsics.
 * Modifying collections while iterating over them using `Iterator`s.
+* Accessing a dynamic type instance after it has been moved by a `from_moved_...` constructor.
+* Passing a `raw_slice` that doesn't point to heap memory to a `from_moved_raw_slice` constructor.

sway-lib-std/src/bytes.sw

@@ -170,6 +170,55 @@ impl Bytes {
         }
     }
 
+    /// Constructs a new `Bytes` that takes the ownership of the `slice`.
+    ///
+    /// # Additional Information
+    ///
+    /// `slice` **must point to a heap-allocated memory**.
+    /// `slice`, or its owner, like, e.g., `Vec`, **must not be used
+    ///  after the ownership is transferred to the newly created `Bytes`**.
+    ///
+    /// Violating the above restrictions results in an undefined behavior.
+    ///
+    /// To create a new `Bytes` from a `raw_slice` that copies the slice content
+    /// and does not take the ownership, use `Bytes::from(raw_slice)`.
+    ///
+    /// # Arguments
+    ///
+    /// * `slice`: [raw_slice] - The heap-allocated slice whose ownership is transferred to the `Bytes`.
+    ///
+    /// # Returns
+    ///
+    /// * [Bytes] - A new `Bytes` whose content is the original content of the `slice`.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// use std::bytes::Bytes;
+    /// use std::vec::Vec;
+    ///
+    /// fn foo() {
+    ///     let mut source = Vec::<u8>::new();
+    ///     source.push(1u8);
+    ///
+    ///     let bytes = Bytes::from_moved_raw_slice(source.as_raw_slice());
+    ///
+    ///     // ** `source` must not be used after this point. **
+    ///
+    ///     assert_eq(bytes.get(0).unwrap(), 1u8);
+    /// }
+    /// ```
+    pub fn from_moved_raw_slice(slice: raw_slice) -> Self {
+        let len_and_capacity = slice.number_of_bytes();
+        Self {
+            buf: RawBytes {
+                ptr: slice.ptr(),
+                cap: len_and_capacity,
+            },
+            len: len_and_capacity,
+        }
+    }
+
     /// Appends an element to the back of a `Bytes` collection.
     ///
     /// # Arguments
@@ -541,6 +590,9 @@ impl Bytes {
 
     /// Clears the `Bytes`, removing all values.
     ///
+    /// Note that this method has no effect on the allocated capacity
+    /// of the `Bytes`.
+    ///
     /// # Examples
     ///
     /// ```sway
@@ -554,7 +606,6 @@ impl Bytes {
     /// }
     /// ```
     pub fn clear(ref mut self) {
-        self.buf = RawBytes::new();
         self.len = 0;
     }
 
@@ -752,11 +803,12 @@ impl Bytes {
 
         // reallocate with combined capacity, write `slice`, set buffer capacity
         if self.buf.cap < both_len {
-            let new_slice = raw_slice::from_parts::<u8>(
-                realloc_bytes(self.buf.ptr, self.buf.cap, both_len),
-                both_len,
-            );
-            self.buf = RawBytes::from(new_slice);
+            // `realloc_bytes` already returns a fresh buffer that owns the
+            // existing content, so we take its ownership directly into `RawBytes`
+            self.buf = RawBytes {
+                ptr: realloc_bytes(self.buf.ptr, self.buf.cap, both_len),
+                cap: both_len,
+            };
         }
 
         let new_ptr = self.buf.ptr.add_uint_offset(other_start);
@@ -1104,7 +1156,15 @@ impl TryInto<b256> for Bytes {
 impl From<raw_slice> for Bytes {
     /// Creates a `Bytes` from a `raw_slice`.
     ///
-    /// ### Examples
+    /// # Additional Information
+    ///
+    /// The content of the `slice` gets copied to a newly created `Bytes`
+    /// that allocates its own buffer.
+    ///
+    /// To take the ownership of the `slice` and move it to the newly
+    /// created `Bytes` without copying the content, use `Bytes::from_moved_raw_slice`.
+    ///
+    /// # Examples
     ///
     /// ```sway
     /// use std:bytes::Bytes;
@@ -1121,10 +1181,10 @@ impl From<raw_slice> for Bytes {
     /// let vec_as_raw_slice = vec.as_raw_slice();
     /// let bytes = Bytes::from(vec_as_raw_slice);
     ///
-    /// assert(bytes.len == 3);
-    /// assert(bytes.get(0).unwrap() == a);
-    /// assert(bytes.get(1).unwrap() == b);
-    /// assert(bytes.get(2).unwrap() == c);
+    /// assert_eq(bytes.len, 3);
+    /// assert_eq(bytes.get(0).unwrap(), a);
+    /// assert_eq(bytes.get(1).unwrap(), b);
+    /// assert_eq(bytes.get(2).unwrap(), c);
     /// ```
     fn from(slice: raw_slice) -> Self {
         Self {

sway-lib-std/src/codec.sw

@@ -1769,7 +1769,7 @@ where
         };
         *item
     } else {
-        let mut buffer = BufferReader::from_parts(data.ptr(), data.len::<u8>());
+        let mut buffer = BufferReader::from_parts(data.ptr(), data.number_of_bytes());
         T::abi_decode(buffer)
     }
 }

sway-lib-std/src/hash.sw

@@ -451,13 +451,33 @@ where
 
 /// Returns the `Hasher`'s initial capacity optimal for hashing
 /// an instance of type `T`.
+#[cfg(experimental_new_hashing = false)]
 fn get_initial_capacity<T>() -> u64 {
     if __is_str_array::<T>() {
         __size_of_str_array::<T>()
     } else {
-        // This will work accurately for all non-heap types.
-        // For heap types, it still gives a slightly better
-        // start then having the empty buffer.
+        // This will work accurately for all non-dynamic types.
+        // For dynamic types, it might give a slightly better
+        // start then having an empty buffer, or a useless
+        // initial allocation, depending on the size of the
+        // content.
+        __size_of::<T>()
+    }
+}
+
+/// Returns the `Hasher`'s initial capacity optimal for hashing
+/// an instance of type `T`.
+#[cfg(experimental_new_hashing = true)]
+fn get_initial_capacity<T>() -> u64 {
+    if __is_str_array::<T>() {
+        // Add 8 bytes for the length prefix.
+        __size_of_str_array::<T>() + 8
+    } else {
+        // This will work accurately for all non-dynamic types.
+        // For dynamic types, it might give a slightly better
+        // start then having an empty buffer, or a useless
+        // initial allocation, depending on the size of the
+        // content.
         __size_of::<T>()
     }
 }

sway-lib-std/src/raw_slice.sw

@@ -143,11 +143,16 @@ impl raw_slice {
         into_parts(self).0
     }
 
-    /// Returns the number of elements in the slice.
+    /// Returns the number of elements in the slice, where each element has a `__size_of::<T>`.
+    ///
+    /// # Additional information
+    ///
+    /// If the slice size in bytes is not a multiple of `__size_of::<T>`, the return length
+    /// is the maximum number of elements of type `T` that can fit into the slice.
     ///
     /// # Returns
     ///
-    /// * [u64] - The length of the slice based on `size_of::<T>`.
+    /// * [u64] - The length of the slice based on `__size_of::<T>`.
     ///
     /// # Examples
     ///
@@ -165,9 +170,9 @@ impl raw_slice {
     ///
     /// * When `T` is a zero-sized type.
     pub fn len<T>(self) -> u64 {
-        let len = __size_of::<T>();
-        if len != 0 {
-            into_parts(self).1 / len
+        const SIZE_OF_T: u64 = __size_of::<T>();
+        if SIZE_OF_T != 0 {
+            into_parts(self).1 / SIZE_OF_T
         } else {
             __revert(REVERT_WITH_RAW_SLICE_LEN_ZST);
         }

sway-lib-std/src/storage/storage_bytes.sw

@@ -86,7 +86,9 @@ impl StorableSlice<Bytes> for StorageKey<StorageBytes> {
     fn read_slice(self) -> Option<Bytes> {
         match read_slice_quads(self.field_id()) {
             Some(slice) => {
-                Some(Bytes::from(slice))
+                // `read_slice_quads` returns a freshly heap-allocated slice that
+                // is used only here, so we take its ownership instead of copying.
+                Some(Bytes::from_moved_raw_slice(slice))
             },
             None => None,
         }
@@ -238,7 +240,9 @@ impl StorableSlice<Bytes> for StorageKey<StorageBytes> {
     fn read_slice(self) -> Option<Bytes> {
         match read_slice_slot(self.field_id()) {
             Some(slice) => {
-                Some(Bytes::from(slice))
+                // `read_slice_slot` returns a freshly heap-allocated slice that
+                // is used only here, so we take its ownership instead of copying.
+                Some(Bytes::from_moved_raw_slice(slice))
             },
             None => None,
         }

sway-lib-std/src/storage/storage_string.sw

@@ -82,7 +82,9 @@ impl StorableSlice<String> for StorageKey<StorageString> {
     fn read_slice(self) -> Option<String> {
         match read_slice_quads(self.field_id()) {
             Some(slice) => {
-                Some(String::from(slice))
+                // `read_slice_quads` returns a freshly heap-allocated slice that
+                // is used only here, so we take its ownership instead of copying.
+                Some(String::from_moved_raw_slice(slice))
             },
             None => None,
         }
@@ -223,7 +225,9 @@ impl StorableSlice<String> for StorageKey<StorageString> {
     fn read_slice(self) -> Option<String> {
         match read_slice_slot(self.field_id()) {
             Some(slice) => {
-                Some(String::from(slice))
+                // `read_slice_slot` returns a freshly heap-allocated slice that
+                // is used only here, so we take its ownership instead of copying.
+                Some(String::from_moved_raw_slice(slice))
             },
             None => None,
         }

sway-lib-std/src/storage/storage_vec.sw

@@ -1071,9 +1071,9 @@ impl<V> StorageKey<StorageVec<V>> {
                         i += 1;
                     }
 
-                    Vec::from(__transmute::<(raw_ptr, u64), raw_slice>((new_vec, len_bytes)))
+                    Vec::from_moved_raw_slice(__transmute::<(raw_ptr, u64), raw_slice>((new_vec, len_bytes)))
                 } else {
-                    Vec::from(__transmute::<(raw_ptr, u64), raw_slice>((ptr, bytes)))
+                    Vec::from_moved_raw_slice(__transmute::<(raw_ptr, u64), raw_slice>((ptr, bytes)))
                 }
             }
         }
@@ -2862,7 +2862,7 @@ impl<V> StorageKey<StorageVec<V>> {
                 }
             }
 
-            Vec::from(raw_slice::from_parts::<V>(elements_ptr, len))
+            Vec::from_moved_raw_slice(raw_slice::from_parts::<V>(elements_ptr, len))
         }
     }