A few minor `write_str` optimizations #2697

nyurik · 2024-02-12T21:06:56Z

Apparently write! generates more code than write_str when used with a simple string, so optimizing it.

Apparently `write!` generates more code than `write_str` when used with a simple string, so optimizing it.

oli-obk · 2024-02-12T21:14:13Z

This sounds like something we could fix directly in libstd. Do you know of any attempts of doing that, or why it hasn't been done? We do similar trickery for format! after all

nyurik · 2024-02-12T21:26:27Z

I tried it with https://rust.godbolt.org/z/Y8djWsq1P

This issue is also tracked in rust-lang/rust#99012 - but it appears to be highly complex and nowhere near being solved in a near future, thus warranting a workaround at least in the popular crates.

dtolnay · 2024-02-13T03:45:09Z

(I have not read most of rust-lang/rust#99012.)

As I understand it, write!(f, "...") does not optimize in a straightforward way to f.write_str("...") because:

write! does not get to assume f implements core::fmt::Write, or std::io::Write. The only thing it gets to assume about f is that f.write_fmt(...) is callable and takes 1 argument of type core::fmt::Arguments. It would not be backward compatible for write!(f, "...") to expand to anything other than f.write_fmt(...).
- It does not even get to assume whether write_fmt takes &mut self or &self or self or Box<Self>, which makes it extremely challenging to even apply autoref-based specialization or similar hack.
- This limitation came up previously in regression: "self" in writeln! drops too early rust-lang/rust#99684 (comment) with some language suggestions, but they are far-fetched.
- See also Revert write! and writeln! to late drop temporaries rust-lang/rust#99689 where it says "desired (unimplementable)".
We do not want any part of any write_fmt method from the standard library to be inlined. They are called so often that this is practically guaranteed to regress compile times.

I think there is a libstd fix and a compiler fix that are worth trying:

Standard library: change core::fmt::Formatter::write_fmt (and maybe others) to the following, and see how bad the regression is.

+ #[inline]
  pub fn write_fmt(&mut self, f: fmt::Arguments) -> fmt::Result {
+     if let ([s], []) = (f.pieces, f.args) {
+         self.buf.write_str(s)
+     } else {
          write(self.buf, f)
+     }
  }

Compiler voodoo. Make write! lower directly to a dedicated AST node, the way format_args! does since Move format_args!() into AST (and expand it during AST lowering) rust-lang/rust#106745. If the receiver ends up being core::fmt::Formatter (or one of a small hardcoded set of other types) then it turns into write_str, otherwise it needs to be handled in a way that is indistinguishable from f.write_fmt(...) — no idea how feasible this is.

dtolnay

Thanks nyurik!

nyurik · 2024-02-13T04:00:43Z

@dtolnay thx so much for the in-depth write-up! TIL. I can try the first approach (relatively simple). The second one clearly involves a lot more in-depth compiler knowledge... maybe someday

nyurik · 2024-02-13T04:26:53Z

P.S. Turns out Arguments::as_str already does all the needed detections!

@dtolnay

Per @dtolnay suggestion in serde-rs/serde#2697 (comment) - attempt to speed up performance in the cases of a simple string format without arguments: ```rust write!(f, "text") -> f.write_str("text") ```

@dtolnay

Per @dtolnay suggestion in serde-rs/serde#2697 (comment) - attempt to speed up performance in the cases of a simple string format without arguments: ```rust write!(f, "text") -> f.write_str("text") ```

perf: improve write_fmt to handle simple strings Per `@dtolnay` suggestion in serde-rs/serde#2697 (comment) - attempt to speed up performance in the cases of a simple string format without arguments: ```rust write!(f, "text") -> f.write_str("text") ``` ```diff + #[inline] pub fn write_fmt(&mut self, f: fmt::Arguments) -> fmt::Result { + if let Some(s) = f.as_str() { + self.buf.write_str(s) + } else { write(self.buf, f) + } } ``` Hopefully it will improve the simple case for the rust-lang#99012 CC: `@m-ou-se` as probably the biggest expert in everything `format!`

nyurik · 2024-02-13T07:37:21Z

I tried the above suggestion, and it seems to already produce a significantly smaller assembly as seen in rust-lang/rust#121001 (comment)

My only concern is that it will impact either the build time or the bin size in some other case... guess will have to wait for the results...

write! with a single string argument is not properly optimized and using write_str generates better code: serde-rs/serde#2697 rust-lang/rust#121001

@dtolnay

Per @dtolnay suggestion in serde-rs/serde#2697 (comment) - attempt to speed up performance in the cases of a simple string format without arguments: ```rust write!(f, "text") -> f.write_str("text") ```

@dtolnay

Per @dtolnay suggestion in serde-rs/serde#2697 (comment) - attempt to speed up performance in the cases of a simple string format without arguments: ```rust write!(f, "text") -> f.write_str("text") ```

perf: improve write_fmt to handle simple strings Per `@dtolnay` suggestion in serde-rs/serde#2697 (comment) - attempt to speed up performance in the cases of a simple string format without arguments: ```rust write!(f, "text") -> f.write_str("text") ``` ```diff + #[inline] pub fn write_fmt(&mut self, f: fmt::Arguments) -> fmt::Result { + if let Some(s) = f.as_str() { + self.buf.write_str(s) + } else { write(self.buf, f) + } } ``` * Hopefully it will improve the simple case for the rust-lang#99012 * Another related (original?) issues rust-lang#10761 * Previous similar attempt to fix it by by `@Kobzol` rust-lang#100700 CC: `@m-ou-se` as probably the biggest expert in everything `format!`

@dtolnay

Per @dtolnay suggestion in serde-rs/serde#2697 (comment) - attempt to speed up performance in the cases of a simple string format without arguments: ```rust write!(f, "text") -> f.write_str("text") ```

perf: improve write_fmt to handle simple strings In case format string has no arguments, simplify its implementation with a direct call to `output.write_str(value)`. This builds on `@dtolnay` original [suggestion](serde-rs/serde#2697 (comment)). This does not change any expectations because the original `fn write()` implementation calls `write_str` for parts of the format string. ```rust write!(f, "text") -> f.write_str("text") ``` ```diff /// [`write!`]: crate::write! +#[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn write(output: &mut dyn Write, args: Arguments<'_>) -> Result { + if let Some(s) = args.as_str() { output.write_str(s) } else { write_internal(output, args) } +} + +/// Actual implementation of the [`write`], but without the simple string optimization. +fn write_internal(output: &mut dyn Write, args: Arguments<'_>) -> Result { let mut formatter = Formatter::new(output); let mut idx = 0; ``` * Hopefully it will improve the simple case for the rust-lang#99012 * Another related (original?) issues rust-lang#10761 * Previous similar attempt to fix it by by `@Kobzol` rust-lang#100700 CC: `@m-ou-se` as probably the biggest expert in everything `format!`

perf: improve write_fmt to handle simple strings In case format string has no arguments, simplify its implementation with a direct call to `output.write_str(value)`. This builds on `@dtolnay` original [suggestion](serde-rs/serde#2697 (comment)). This does not change any expectations because the original `fn write()` implementation calls `write_str` for parts of the format string. ```rust write!(f, "text") -> f.write_str("text") ``` ```diff /// [`write!`]: crate::write! +#[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn write(output: &mut dyn Write, args: Arguments<'_>) -> Result { + if let Some(s) = args.as_str() { output.write_str(s) } else { write_internal(output, args) } +} + +/// Actual implementation of the [`write`], but without the simple string optimization. +fn write_internal(output: &mut dyn Write, args: Arguments<'_>) -> Result { let mut formatter = Formatter::new(output); let mut idx = 0; ``` * Hopefully it will improve the simple case for the rust-lang/rust#99012 * Another related (original?) issues #10761 * Previous similar attempt to fix it by by `@Kobzol` #100700 CC: `@m-ou-se` as probably the biggest expert in everything `format!`

perf: improve write_fmt to handle simple strings In case format string has no arguments, simplify its implementation with a direct call to `output.write_str(value)`. This builds on `@dtolnay` original [suggestion](serde-rs/serde#2697 (comment)). This does not change any expectations because the original `fn write()` implementation calls `write_str` for parts of the format string. ```rust write!(f, "text") -> f.write_str("text") ``` ```diff /// [`write!`]: crate::write! +#[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn write(output: &mut dyn Write, args: Arguments<'_>) -> Result { + if let Some(s) = args.as_str() { output.write_str(s) } else { write_internal(output, args) } +} + +/// Actual implementation of the [`write`], but without the simple string optimization. +fn write_internal(output: &mut dyn Write, args: Arguments<'_>) -> Result { let mut formatter = Formatter::new(output); let mut idx = 0; ``` * Hopefully it will improve the simple case for the rust-lang/rust#99012 * Another related (original?) issues rust-lang#10761 * Previous similar attempt to fix it by by `@Kobzol` #100700 CC: `@m-ou-se` as probably the biggest expert in everything `format!`

A few minor write_str optimizations and inlining

b8fafef

Apparently `write!` generates more code than `write_str` when used with a simple string, so optimizing it.

nyurik force-pushed the format-str branch from 8140bea to b8fafef Compare February 12, 2024 21:12

nyurik changed the title ~~A few minor write_str optimizations and inlining~~ A few minor write_str optimizations Feb 12, 2024

dtolnay approved these changes Feb 13, 2024

View reviewed changes

dtolnay merged commit 1d54973 into serde-rs:master Feb 13, 2024
15 checks passed

nyurik deleted the format-str branch February 13, 2024 03:50

nyurik mentioned this pull request Feb 13, 2024

perf: improve write_fmt to handle simple strings rust-lang/rust#121001

Merged

jonasbb mentioned this pull request Feb 13, 2024

Replace uses of write! with write_str and write_fmt jonasbb/serde_with#699

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

A few minor `write_str` optimizations #2697

A few minor `write_str` optimizations #2697

nyurik commented Feb 12, 2024

oli-obk commented Feb 12, 2024

nyurik commented Feb 12, 2024

dtolnay commented Feb 13, 2024

dtolnay left a comment

nyurik commented Feb 13, 2024

nyurik commented Feb 13, 2024

nyurik commented Feb 13, 2024

A few minor write_str optimizations #2697

A few minor write_str optimizations #2697

Conversation

nyurik commented Feb 12, 2024

oli-obk commented Feb 12, 2024

nyurik commented Feb 12, 2024

dtolnay commented Feb 13, 2024

dtolnay left a comment

Choose a reason for hiding this comment

nyurik commented Feb 13, 2024

nyurik commented Feb 13, 2024

nyurik commented Feb 13, 2024

A few minor `write_str` optimizations #2697

A few minor `write_str` optimizations #2697