Re:How Rust 1.26 more than tripled the speed of my code
by ajross on Monday May 14, 2018 @10:38AM
(#17065899)
PUSH/POPF* instructions push the flags register to save comparison results when you need to reuse the registers containing the original comparison arguments. They're well-pipelined, integrated with the stack engine and very fast on modern CPUs, and I've definitely seen the compiler emit them (more on i686 than x86_64 to be fair).
I won't speak to the quality of the generated code otherwise, but this bit of evidence by itself doesn't seem persuasive.
(edit: pbsd is right: per Agner Fog, these guys are slow. It's likely that the L/SAHF trick is the one I was remembering.)
Re:How Rust 1.26 more than tripled the speed of my code
by pbsd on Monday May 14, 2018 @10:41AM
(#17065914)
Where are you getting that from? `pushfd` is OK-ish, but `popfd` is microcoded, requires 9 uops, and can only be issued once every ~20 cycles. That's not what I would call well-pipelined.
You could probably achieve the same result (assuming you want to avoid adc instructions, for some reason) by using setc r8 plus shr r8, 1 to get the carry back.
Re:How Rust 1.26 more than tripled the speed of my code
by nonsince on Monday May 14, 2018 @10:44AM
(#17065954)
If you use `-C target-cpu=native` (Rust's equivalent of `-march=native`) you get code that uses `mulxq` in order to avoid `pushf`/`popf`. https://gist.github.com/Vurich/5cb83c773e90fc7a463ccb58e1dad...
Re:How Rust 1.26 more than tripled the speed of my code
by pbsd on Monday May 14, 2018 @10:51AM
(#17066015)
It's still doing it, but now it uses `lahf` + `sahf` instead to (re)store the flags. These are better than pushf + popf for sure, but they cannot be used in general code because some early x86_64 chips forgot to implement them.
Re:How Rust 1.26 more than tripled the speed of my code
by deaddodo on Monday May 14, 2018 @03:56PM
(#17068889)
If your general code is only intended to be used on newer versions of Windows, you can. Windows has required it since 8.1.
Re:How Rust 1.26 more than tripled the speed of my code
by nonsince on Monday May 14, 2018 @10:33AM
(#17065862)
It's possible that `pushfq`+`popfq` get turned into a `mov` from the flag register into a the output register due to microcode-level optimisations.
Re:How Rust 1.26 more than tripled the speed of my code
by pbsd on Monday May 14, 2018 @10:38AM
(#17065901)
That is not the case. On a Skylake chip, a pushfd + popfd roundtrip costs 24 cycles.
Re:How Rust 1.26 more than tripled the speed of my code
by feikname on Monday May 14, 2018 @11:43AM
(#17066427)
Just out of curiosity, how do you know this? Is it some kind of measurement you made yourself, written on Intel docs somewhere or something else?
I've been wondering about how much instructions cost lately and would like to be able to know this without the need of asking others.
Re:How Rust 1.26 more than tripled the speed of my code
by pbsd on Monday May 14, 2018 @11:52AM
(#17066510)
Agner's instruction listings [1] and InstLatX64 [2] are good sources for a variety of chips. The 24 cycle figure above can be seen at https://github.com/InstLatx64/InstLatx64/blob/ee13abcfb1e2bb...
Re:How Rust 1.26 more than tripled the speed of my code
by koverstreet on Monday May 14, 2018 @01:28PM
(#17067406)
There's also the intel optimization manuals.
The disassembly for the Rust output of `u256_full_mul` at the end is also terrible, and it looks like the output of a debug build. There's no reason an optimizing compiler should be outputting `pushfd` and `popfd` in performant code. The benchmarked loop does not have those instructions.