Optimizing runtime performance for the literal string case

[nyurik]

Rust compiler at present is unable to generate as efficient code for write!(f, "string") as it can do for f.write_str("string"). I tried to look through the code, but it seems fairly complex in how you generate the output token stream. Would it be possible to handle the case when the string is known ahead of time and does not contain either { or } characters, and use the write_str instead?

[frozenlib]

parse-display/parse-display-derive/src/lib.rs

Lines 1079 to 1085 in 6134916

	fn format_args(
	&self,
	context: DisplayContext,
	with: &Option<Expr>,
	bounds: &mut Bounds,
	generics: &GenericParamSet,
	) -> Result<TokenStream> {

Currently, TokenStream used as an argument for write_str is being generated by the format_args function above. However, it seems possible to generate code that uses write_str instead of write! by changing the format_args function to generate something like Vec<FormatPart> below instead of TokenStream.

enum FormatPart {
  Str(String),
  Placeholder {
    format_specifier: String,
    expr : Expr,
  }
}

I would like to make this change in the future if the performance impact is significant.

[nyurik]

Thanks! I made a similar suggestion in dtolnay/thiserror#285 and the pending pull request in dtolnay/thiserror#286 . You can see the assembly difference here Profiling would be fairly tricky though, as it would have to have some sort of a re-usable buffer whose allocation would not impact the profiling results.

It does sound the code here is much more involved than in the thiserror. There it first forms a struct with all the relevant info, and then converts that struct into a tokenstream. I will try to decipher it, but might take a bit of time :)

[nyurik]

P.S. Note that there an another optimizations added to thiserror - dtolnay/thiserror@8a5c4d1 - in case when there is an unused comma, e.g. #[display("{}",)]

[frozenlib]

Thanks for the info.

[ ] Make sure write!(f, "literal") is just as efficient as f.write_str("literal")
source: rust-lang/rust#99012

Since ::core::write!() will be optimized in the future, I thought it would be better to modify it in a way that would make it easier to revert, and I came up with a simple way to do so and implemented it.

I also did some benchmarking and it seems to make quite a difference.

before:

test no_placeholder_by_hand_write_str ... bench:           7 ns/iter (+/- 0)
test no_placeholder_derive            ... bench:          12 ns/iter (+/- 0)

after:

test no_placeholder_by_hand_write_str ... bench:           7 ns/iter (+/- 0)
test no_placeholder_derive            ... bench:           7 ns/iter (+/- 1)