mirror of
https://github.com/rust-lang/rust-analyzer
synced 2025-01-25 19:35:06 +00:00
No description
1bc05d203b
Improve performance of `rem_euclid()` for signed integers such code is copy from https://github.com/rust-lang/rust/blob/master/library/std/src/f32.rs and https://github.com/rust-lang/rust/blob/master/library/std/src/f64.rs using `r+rhs.abs()` is faster than calc it with an if clause. Bench result: ``` $ cargo bench Compiling div-euclid v0.1.0 (/me/div-euclid) Finished bench [optimized] target(s) in 1.01s Running unittests src/lib.rs (target/release/deps/div_euclid-7a4530ca7817d1ef) running 7 tests test tests::it_works ... ignored test tests::bench_aaabs ... bench: 10,498,793 ns/iter (+/- 104,360) test tests::bench_aadefault ... bench: 11,061,862 ns/iter (+/- 94,107) test tests::bench_abs ... bench: 10,477,193 ns/iter (+/- 81,942) test tests::bench_default ... bench: 10,622,983 ns/iter (+/- 25,119) test tests::bench_zzabs ... bench: 10,481,971 ns/iter (+/- 43,787) test tests::bench_zzdefault ... bench: 11,074,976 ns/iter (+/- 29,633) test result: ok. 0 passed; 0 failed; 1 ignored; 6 measured; 0 filtered out; finished in 19.35s ``` It seems that, default `rem_euclid` triggered a branch prediction, thus `bench_default` is faster than `bench_aadefault` and `bench_aadefault`, which shuffles the order of calculations. but all of them slower than what it was in `f64`'s and `f32`'s `rem_euclid`, thus I submit this PR. bench code: ```rust #![feature(test)] extern crate test; fn rem_euclid(a:i32,rhs:i32)->i32{ let r = a % rhs; if r < 0 { r + rhs.abs() } else { r } } #[cfg(test)] mod tests { use super::*; use test::Bencher; use rand::prelude::*; use rand::rngs::SmallRng; const N:i32=1000; #[test] fn it_works() { let a: i32 = 7; // or any other integer type let b = 4; let d:Vec<i32>=(-N..=N).collect(); let n:Vec<i32>=(-N..0).chain(1..=N).collect(); for i in &d { for j in &n { assert_eq!(i.rem_euclid(*j),rem_euclid(*i,*j)); } } assert_eq!(rem_euclid(a,b), 3); assert_eq!(rem_euclid(-a,b), 1); assert_eq!(rem_euclid(a,-b), 3); assert_eq!(rem_euclid(-a,-b), 1); } #[bench] fn bench_aaabs(b: &mut Bencher) { let mut d:Vec<i32>=(-N..=N).collect(); let mut n:Vec<i32>=(-N..0).chain(1..=N).collect(); let mut rng=SmallRng::from_seed([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,21]); n.shuffle(&mut rng); d.shuffle(&mut rng); n.shuffle(&mut rng); b.iter(||{ let mut res=0; for i in &d { for j in &n { res+=rem_euclid(*i,*j); } } res }); } #[bench] fn bench_aadefault(b: &mut Bencher) { let mut d:Vec<i32>=(-N..=N).collect(); let mut n:Vec<i32>=(-N..0).chain(1..=N).collect(); let mut rng=SmallRng::from_seed([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,21]); n.shuffle(&mut rng); d.shuffle(&mut rng); n.shuffle(&mut rng); b.iter(||{ let mut res=0; for i in &d { for j in &n { res+=i.rem_euclid(*j); } } res }); } #[bench] fn bench_abs(b: &mut Bencher) { let d:Vec<i32>=(-N..=N).collect(); let n:Vec<i32>=(-N..0).chain(1..=N).collect(); b.iter(||{ let mut res=0; for i in &d { for j in &n { res+=rem_euclid(*i,*j); } } res }); } #[bench] fn bench_default(b: &mut Bencher) { let d:Vec<i32>=(-N..=N).collect(); let n:Vec<i32>=(-N..0).chain(1..=N).collect(); b.iter(||{ let mut res=0; for i in &d { for j in &n { res+=i.rem_euclid(*j); } } res }); } #[bench] fn bench_zzabs(b: &mut Bencher) { let mut d:Vec<i32>=(-N..=N).collect(); let mut n:Vec<i32>=(-N..0).chain(1..=N).collect(); let mut rng=SmallRng::from_seed([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,21]); d.shuffle(&mut rng); n.shuffle(&mut rng); d.shuffle(&mut rng); b.iter(||{ let mut res=0; for i in &d { for j in &n { res+=rem_euclid(*i,*j); } } res }); } #[bench] fn bench_zzdefault(b: &mut Bencher) { let mut d:Vec<i32>=(-N..=N).collect(); let mut n:Vec<i32>=(-N..0).chain(1..=N).collect(); let mut rng=SmallRng::from_seed([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,21]); d.shuffle(&mut rng); n.shuffle(&mut rng); d.shuffle(&mut rng); b.iter(||{ let mut res=0; for i in &d { for j in &n { res+=i.rem_euclid(*j); } } res }); } } ``` |
||
|---|---|---|
| .cargo | ||
| .github | ||
| .vscode | ||
| assets | ||
| bench_data | ||
| crates | ||
| docs | ||
| editors/code | ||
| lib | ||
| xtask | ||
| .editorconfig | ||
| .git-blame-ignore-revs | ||
| .gitattributes | ||
| .gitignore | ||
| Cargo.lock | ||
| Cargo.toml | ||
| LICENSE-APACHE | ||
| LICENSE-MIT | ||
| PRIVACY.md | ||
| README.md | ||
| rustfmt.toml | ||
| triagebot.toml | ||
rust-analyzer is a modular compiler frontend for the Rust language. It is a part of a larger rls-2.0 effort to create excellent IDE support for Rust.
Quick Start
https://rust-analyzer.github.io/manual.html#installation
Documentation
If you want to contribute to rust-analyzer or are just curious about how things work under the hood, check the ./docs/dev folder.
If you want to use rust-analyzer's language server with your editor of choice, check the manual folder. It also contains some tips & tricks to help you be more productive when using rust-analyzer.
Security and Privacy
See the corresponding sections of the manual.
Communication
For usage and troubleshooting requests, please use "IDEs and Editors" category of the Rust forum:
https://users.rust-lang.org/c/ide/14
For questions about development and implementation, join rust-analyzer working group on Zulip:
https://rust-lang.zulipchat.com/#narrow/stream/185405-t-compiler.2Frust-analyzer
Quick Links
- Website: https://rust-analyzer.github.io/
- Metrics: https://rust-analyzer.github.io/metrics/
- API docs: https://rust-lang.github.io/rust-analyzer/ide/
- Changelog: https://rust-analyzer.github.io/thisweek
License
rust-analyzer is primarily distributed under the terms of both the MIT license and the Apache License (Version 2.0).
See LICENSE-APACHE and LICENSE-MIT for details.