Optimize encoding and decoding of Vec<T> when T is trivial

sway-lib-std/src/vec.sw

@@ -822,17 +822,35 @@ where
         false
     }
     fn abi_encode(self, buffer: Buffer) -> Buffer {
-        let len = self.len;
-        let mut buffer = len.abi_encode(buffer);
+        const IS_ELEM_TRIVIAL = is_encode_trivial::<T>();
+
+        if IS_ELEM_TRIVIAL {
+            // TODO: We need to write the length of the vector,
+            //       and then the raw memory of the vector's contents.
+            //       Currently, we don't have a way to write the plain
+            //       memory content without the length. E.g., writing slice
+            //       will write the length of the vector slice in bytes,
+            //       and then the raw memory, but not the length of the
+            //       vector in number of elements.
+            //
+            //       One possibility to solve this would be to have an intrinsic
+            //       that would allow us to write the raw memory of a particular
+            //       length, without the length prefix. E.g.:
+            //          __encode_buffer_append_raw(buffer, ptr, len)
+            self.as_raw_slice().abi_encode(buffer)
+        } else {
+            let len = self.len;
+            let mut buffer = len.abi_encode(buffer);
+
+            let mut i = 0;
+            while i < len {
+                let item = self.get_unchecked(i);
+                buffer = item.abi_encode(buffer);
+                i += 1;
+            }
 
-        let mut i = 0;
-        while i < len {
-            let item = self.get_unchecked(i);
-            buffer = item.abi_encode(buffer);
-            i += 1;
+            buffer
         }
-
-        buffer
     }
 }
 
@@ -844,18 +862,25 @@ where
         false
     }
     fn abi_decode(ref mut buffer: BufferReader) -> Vec<T> {
-        let len = u64::abi_decode(buffer);
+        const IS_ELEM_TRIVIAL = is_decode_trivial::<T>();
 
-        let mut v = Vec::with_capacity(len);
+        if IS_ELEM_TRIVIAL {
+            // TODO: See the comment in `abi_encode` for the trivial case.
+            Self::from(raw_slice::abi_decode(buffer))
+        } else {
+            let len = u64::abi_decode(buffer);
 
-        let mut i = 0;
-        while i < len {
-            let item = T::abi_decode(buffer);
-            v.push(item);
-            i += 1;
-        }
+            let mut v = Vec::with_capacity(len);
+
+            let mut i = 0;
+            while i < len {
+                let item = T::abi_decode(buffer);
+                v.push(item);
+                i += 1;
+            }
 
-        v
+            v
+        }
     }
 }
 

test/src/e2e_vm_tests/test_programs/should_pass/language/raw_ptr/raw_ptr_ret/Forc.lock → test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_encoding_decoding/Forc.lock

@@ -1,8 +1,8 @@
 [[package]]
-name = "raw_ptr_ret"
-source = "member"
-dependencies = ["std"]
+name = "std"
+source = "path+from-root-2158C659FB34C0B1"
 
 [[package]]
-name = "std"
-source = "path+from-root-51D3AF48CE04FAE0"
+name = "vec_encoding_decoding"
+source = "member"
+dependencies = ["std"]

test/src/e2e_vm_tests/test_programs/should_pass/language/raw_ptr/vec_ret/Forc.toml → test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_encoding_decoding/Forc.toml

@@ -2,7 +2,7 @@
 authors = ["Fuel Labs <contact@fuel.sh>"]
 entry = "main.sw"
 license = "Apache-2.0"
-name = "vec_ret"
+name = "vec_encoding_decoding"
 
 [dependencies]
-std = { path = "../../../../../reduced_std_libs/sway-lib-std-vec" }
+std = { path = "../../../../reduced_std_libs/sway-lib-std-vec" }

test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_encoding_decoding/snapshot.toml

@@ -0,0 +1 @@
+cmds = ["forc test --path {root} --release --logs"]

test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_encoding_decoding/src/main.sw

@@ -0,0 +1,121 @@
+script;
+
+fn main(trivial: Vec<u64>, non_trivial: Vec<u32>) -> (Vec<u64>, Vec<u32>) {
+    assert_eq(trivial.len(), 3);
+    assert_eq(trivial.get(0).unwrap_or(0), 124);
+    assert_eq(trivial.get(1).unwrap_or(0), 124);
+    assert_eq(trivial.get(2).unwrap_or(0), 124);
+
+    let mut trivial = Vec::from(trivial.as_raw_slice());
+    trivial.push(124);
+    trivial.push(124);
+    trivial.push(124);
+
+    assert_eq(non_trivial.len(), 3);
+    assert_eq(non_trivial.get(0).unwrap_or(0), 124);
+    assert_eq(non_trivial.get(1).unwrap_or(0), 124);
+    assert_eq(non_trivial.get(2).unwrap_or(0), 124);
+
+    let mut non_trivial = Vec::from(non_trivial.as_raw_slice());
+    non_trivial.push(124);
+    non_trivial.push(124);
+    non_trivial.push(124);
+
+    (trivial, non_trivial)
+}
+
+#[test]
+fn vec_trivial() {
+    let vec = create_vec_trivial(10);
+    let encoded_decoded: Vec<u64> = abi_decode(encode(vec));
+    assert_eq(encoded_decoded, vec);
+
+    let encoded_as_alias = encode_allow_alias(&encoded_decoded);
+    let encoded_decoded: Vec<u64> = abi_decode(encoded_as_alias);
+    assert_eq(encoded_decoded, vec);
+
+    log(encoded_decoded);
+}
+
+#[test]
+fn nested_vec_trivial() {
+    let vec = create_nested_vec_trivial(10);
+    let encoded_decoded: Vec<Vec<u64>> = abi_decode(encode(vec));
+    assert_eq(encoded_decoded, vec);
+
+    let encoded_as_alias = encode_allow_alias(&encoded_decoded);
+    let encoded_decoded: Vec<Vec<u64>> = abi_decode(encoded_as_alias);
+    assert_eq(encoded_decoded, vec);
+
+    log(encoded_decoded);
+}
+
+#[test]
+fn vec_non_trivial() {
+    let vec = create_vec_trivial(10);
+    let encoded_decoded: Vec<u64> = abi_decode(encode(vec));
+    assert_eq(encoded_decoded, vec);
+
+    let encoded_as_alias = encode_allow_alias(&encoded_decoded);
+    let encoded_decoded: Vec<u64> = abi_decode(encoded_as_alias);
+    assert_eq(encoded_decoded, vec);
+
+    log(encoded_decoded);
+}
+
+#[test]
+fn nested_vec_non_trivial() {
+    let vec = create_nested_vec_non_trivial(10);
+    let encoded_decoded: Vec<Vec<u32>> = abi_decode(encode(vec));
+    assert_eq(encoded_decoded, vec);
+
+    let encoded_as_alias = encode_allow_alias(&encoded_decoded);
+    let encoded_decoded: Vec<Vec<u32>> = abi_decode(encoded_as_alias);
+    assert_eq(encoded_decoded, vec);
+
+    log(encoded_decoded);
+}
+
+#[allow(dead_code)]
+fn create_vec_trivial(n: u64) -> Vec<u64> {
+    let mut vec = Vec::<u64>::new();
+    let mut i: u64 = 0;
+    while i < n {
+        vec.push(i);
+        i += 1;
+    }
+    vec
+}
+
+#[allow(dead_code)]
+fn create_nested_vec_trivial(n: u64) -> Vec<Vec<u64>> {
+    let mut vec = Vec::<Vec<u64>>::new();
+    let mut i: u64 = 0;
+    while i < n {
+        vec.push(create_vec_trivial(i));
+        i += 1;
+    }
+    vec
+}
+
+#[allow(dead_code)]
+fn create_vec_non_trivial(n: u32) -> Vec<u32> {
+    let mut vec = Vec::<u32>::new();
+    let mut i: u32 = 0;
+    while i < n {
+        vec.push(i);
+        i += 1;
+    }
+    vec
+}
+
+#[allow(dead_code)]
+fn create_nested_vec_non_trivial(n: u32) -> Vec<Vec<u32>> {
+    let mut vec = Vec::<Vec<u32>>::new();
+    let mut i: u32 = 0;
+    while i < n {
+        vec.push(create_vec_non_trivial(i));
+        i += 1;
+    }
+    vec
+}

test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_encoding_decoding/test.run.toml

@@ -0,0 +1,4 @@
+category = "run"
+
+script_data_new_encoding = "0000000000000003000000000000007c000000000000007c000000000000007c 00000000000000030000007c0000007c0000007c"
+expected_result_new_encoding = { action = "return_data", value = "0000000000000006000000000000007c000000000000007c000000000000007c000000000000007c000000000000007c000000000000007c 00000000000000060000007c0000007c0000007c0000007c0000007c0000007c" }

test/src/e2e_vm_tests/test_programs/should_pass/stdlib/vec_encoding_decoding/test.toml

@@ -0,0 +1 @@
+category = "unit_tests_pass"