blyxyas
commented
5 months ago Here are the contents of main.rs:
/*
[package] name = "perf-regression-debug" version = "0.1.0" edition = "2021"
[dependencies] rand = { version = "0.8.5", features = ["alloc", "small_rng"] }
[[bin]] name = "main" path = "main.rs"
$ RUSTFLAGS="-Copt-level=3" cargo +1.76.0 build --release $ time ./target/release/main real 0m4.182s user 0m4.181s sys 0m0.000s
$ RUSTFLAGS="-Copt-level=3" cargo +1.77.2 build --release $ time ./target/release/main real 0m7.699s user 0m7.694s sys 0m0.004s
$ RUSTFLAGS="-Copt-level=3" cargo +1.78.0 build --release $ time ./target/release/main real 0m7.634s user 0m7.628s sys 0m0.005s
*/
use core::hint::black_box;
use core::ptr;
use rand::distributions::{Distribution, WeightedIndex};
use rand::{Rng, SeedableRng};
const RAND_VEC_LEN: usize = 10000;
const BENCHMARK_LOOP_ITERATIONS: usize = 250000;
#[inline]
#[no_mangle]
pub fn decode_u32(buf: &[u8; 5]) -> (u32, usize) {
if buf[0] < 0x80 {
return (buf[0] as u32, 1);
}
if buf[0] < 0xF0 {
let x = u32::from_le(unsafe {
ptr::from_ref(buf).cast::<u32>().read_unaligned()
});
if buf[0] < 0b11000000 {
let decoded = (x & 0x3F) | ((x & 0xFF00) >> 2);
return (decoded, 2);
}
if buf[0] < 0b11100000 {
let decoded = (x & 0x1F) | ((x & 0xFFFF00) >> 3);
return (decoded, 3);
}
let decoded = (x & 0x0F) | ((x & 0xFFFFFF00) >> 4);
return (decoded, 4);
}
let decoded = u32::from_le(unsafe {
ptr::from_ref(buf)
.cast::<u8>()
.add(1)
.cast::<u32>()
.read_unaligned()
});
(decoded, ((buf[0] & 0x0F) + 2) as usize)
}
#[inline(never)]
#[no_mangle]
pub fn benchmark_decode_u32(bufs: &[[u8; 5]]) {
for buf in bufs {
black_box(decode_u32(black_box(buf)));
}
}
const U32_MASKS: [u32; 5] = [
u32::MAX >> 25,
u32::MAX >> 24,
u32::MAX >> 16,
u32::MAX >> 8,
u32::MAX,
];
fn main() {
let mixed_u32 = WeightedIndex::new(&[15, 60, 15, 5, 5])
.unwrap()
.map(|ii| U32_MASKS[ii]);
let mut rng = rand::rngs::SmallRng::seed_from_u64(0);
let encoded_values: Vec<[u8; 5]> =
std::iter::from_fn(|| Some(rng.sample(&mixed_u32)))
.map(|value| {
let mut buf = [0u8; 5];
encode_u32(&mut buf, value);
buf
})
.take(RAND_VEC_LEN)
.collect();
for _ii in 0..BENCHMARK_LOOP_ITERATIONS {
benchmark_decode_u32(&encoded_values);
}
}
fn encode_u32(buf: &mut [u8; 5], mut x: u32) -> usize {
if x & 0b01111111 == x {
buf[0] = x as u8;
return 1;
}
if x < 0x10000000 {
if x < 0x00004000 {
x <<= 2;
buf[0] = 0b10000000 | ((x as u8) >> 2);
buf[1] = (x >> 8) as u8;
return 2;
}
if x < 0x00200000 {
x <<= 3;
buf[0] = 0b11000000 | ((x as u8) >> 3);
buf[1] = (x >> 8) as u8;
buf[2] = (x >> 16) as u8;
return 3;
}
x <<= 4;
buf[0] = 0b11100000 | ((x as u8) >> 4);
buf[1] = (x >> 8) as u8;
buf[2] = (x >> 16) as u8;
buf[3] = (x >> 24) as u8;
return 4;
}
let bytes = x.to_le_bytes();
buf[0] = 0b11110011;
buf[1] = bytes[0];
buf[2] = bytes[1];
buf[3] = bytes[2];
buf[4] = bytes[3];
5
}
workingjubilee
jmillikin
apiraino
saethlin
Code
I'm working on some low-level bit-manipulation code, and discovered that v1.77 generates code that runs at about half the speed compared to the output of v1.76. Since the v1.77 release notes don't mention anything about an LLVM upgrade I figure there must be something going wrong in the
rustcLLVM IR generation.Compilable reproduction:
The inner loop is
decode_u32(), which is sort of ugly but isn't doing anything especially complex.The exact timing varies depending on the distribution of input values. The attached reproduction uses a distribution for which the new code is about twice as slow.
Version it worked on
It most recently worked on: Rust v1.76.0
Version with regression
rustc --version --verbose: