segwit: Add a buffer when writing

Currently we call `fmt::Write::write_char` and `io::Write::write_all`
in a loop while iterating over the encoded characters of a bech32
string. This is inefficient.

Add a buffer and copy ASCII bytes into it while looping the write the
whole buffer out in a single call. The buffer has a size of 90 bytes
because we know the bech32 string is guaranteed to be 90 chars or less.

Author: tcharding

src/segwit.rs

@@ -156,19 +156,30 @@ pub fn encode_lower_to_fmt_unchecked<W: fmt::Write>(
     witness_version: Fe32,
     witness_program: &[u8],
 ) -> fmt::Result {
+    let mut buf = [0u8; MAX_STRING_LENGTH];
+    let mut pos = 0;
+
     let iter = witness_program.iter().copied().bytes_to_fes();
     match witness_version {
         VERSION_0 => {
-            for c in iter.with_checksum::<Bech32>(&hrp).with_witness_version(VERSION_0).chars() {
-                fmt.write_char(c)?;
-            }
+            let chars = iter.with_checksum::<Bech32>(&hrp).with_witness_version(VERSION_0).chars();
+            buf.iter_mut().zip(chars).for_each(|(b, c)| {
+                *b = c as u8;
+                pos += 1;
+            });
         }
         version => {
-            for c in iter.with_checksum::<Bech32m>(&hrp).with_witness_version(version).chars() {
-                fmt.write_char(c)?;
-            }
+            let chars = iter.with_checksum::<Bech32m>(&hrp).with_witness_version(version).chars();
+            buf.iter_mut().zip(chars).for_each(|(b, c)| {
+                *b = c as u8;
+                pos += 1;
+            });
         }
     }
+
+    let s = core::str::from_utf8(&buf[..pos]).expect("we only write ASCII");
+    fmt.write_str(s)?;
+
     Ok(())
 }
 
@@ -185,20 +196,30 @@ pub fn encode_upper_to_fmt_unchecked<W: fmt::Write>(
     witness_version: Fe32,
     witness_program: &[u8],
 ) -> fmt::Result {
+    let mut buf = [0u8; MAX_STRING_LENGTH];
+    let mut pos = 0;
+
     let iter = witness_program.iter().copied().bytes_to_fes();
     match witness_version {
         VERSION_0 => {
-            for c in iter.with_checksum::<Bech32>(&hrp).with_witness_version(VERSION_0).chars() {
-                fmt.write_char(c.to_ascii_uppercase())?;
-            }
+            let chars = iter.with_checksum::<Bech32>(&hrp).with_witness_version(VERSION_0).chars();
+            buf.iter_mut().zip(chars).for_each(|(b, c)| {
+                *b = c.to_ascii_uppercase() as u8;
+                pos += 1;
+            });
         }
         version => {
-            for c in iter.with_checksum::<Bech32m>(&hrp).with_witness_version(version).chars() {
-                fmt.write_char(c.to_ascii_uppercase())?;
-            }
+            let chars = iter.with_checksum::<Bech32m>(&hrp).with_witness_version(version).chars();
+            buf.iter_mut().zip(chars).for_each(|(b, c)| {
+                *b = c.to_ascii_uppercase() as u8;
+                pos += 1;
+            });
         }
     }
 
+    let s = core::str::from_utf8(&buf[..pos]).expect("we only write ASCII");
+    fmt.write_str(s)?;
+
     Ok(())
 }
 
@@ -229,19 +250,29 @@ pub fn encode_lower_to_writer_unchecked<W: std::io::Write>(
     witness_version: Fe32,
     witness_program: &[u8],
 ) -> std::io::Result<()> {
+    let mut buf = [0u8; MAX_STRING_LENGTH];
+    let mut pos = 0;
+
     let iter = witness_program.iter().copied().bytes_to_fes();
     match witness_version {
         VERSION_0 => {
-            for c in iter.with_checksum::<Bech32>(&hrp).with_witness_version(VERSION_0).chars() {
-                w.write_all(&[c.to_ascii_lowercase() as u8])?;
-            }
+            let chars = iter.with_checksum::<Bech32>(&hrp).with_witness_version(VERSION_0).chars();
+            buf.iter_mut().zip(chars).for_each(|(b, c)| {
+                *b = c as u8; // The chars iter yields lowercase characters.
+                pos += 1;
+            });
         }
         version => {
-            for c in iter.with_checksum::<Bech32m>(&hrp).with_witness_version(version).chars() {
-                w.write_all(&[c.to_ascii_lowercase() as u8])?;
-            }
+            let chars = iter.with_checksum::<Bech32m>(&hrp).with_witness_version(version).chars();
+            buf.iter_mut().zip(chars).for_each(|(b, c)| {
+                *b = c as u8;
+                pos += 1;
+            });
         }
     }
+
+    w.write_all(&buf[..pos])?;
+
     Ok(())
 }
 
@@ -259,20 +290,29 @@ pub fn encode_upper_to_writer_unchecked<W: std::io::Write>(
     witness_version: Fe32,
     witness_program: &[u8],
 ) -> std::io::Result<()> {
+    let mut buf = [0u8; MAX_STRING_LENGTH];
+    let mut pos = 0;
+
     let iter = witness_program.iter().copied().bytes_to_fes();
     match witness_version {
         VERSION_0 => {
-            for c in iter.with_checksum::<Bech32>(&hrp).with_witness_version(VERSION_0).chars() {
-                w.write_all(&[c.to_ascii_uppercase() as u8])?;
-            }
+            let chars = iter.with_checksum::<Bech32>(&hrp).with_witness_version(VERSION_0).chars();
+            buf.iter_mut().zip(chars).for_each(|(b, c)| {
+                *b = c.to_ascii_uppercase() as u8;
+                pos += 1;
+            });
         }
         version => {
-            for c in iter.with_checksum::<Bech32m>(&hrp).with_witness_version(version).chars() {
-                w.write_all(&[c.to_ascii_uppercase() as u8])?;
-            }
+            let chars = iter.with_checksum::<Bech32m>(&hrp).with_witness_version(version).chars();
+            buf.iter_mut().zip(chars).for_each(|(b, c)| {
+                *b = c.to_ascii_uppercase() as u8;
+                pos += 1;
+            });
         }
     }
 
+    w.write_all(&buf[..pos])?;
+
     Ok(())
 }