Rust question about array reference

[JasonLi-cn]

There's a line comment #[allow(clippy::ptr_arg)] // &[StateAddr] slower than &StateAddrs ~20% here
https://github.com/datafuselabs/databend/blob/5c370f5c8861bde6270d1e8f59ed2e8e9822cacf/query/src/pipelines/transforms/group_by/aggregator.rs#L87-L88
Please help to answer the reasons and details, thanks!

[Xuanwo]

Visit @zhang2014 for some help 🚀

[Xuanwo]

BTW, it's better to link to a permanent link instead:

https://github.com/datafuselabs/databend/blob/03de61dc4dda79f85f2d600654aebabd07a769f0/query/src/pipelines/transforms/group_by/aggregator.rs#L86-L87

[JasonLi-cn]

Ok, thanks~

[sundy-li]

There are some docs about this optimization, but I can't find the link. Maybe @PsiACE knows the link

[PsiACE]

for clippy::ptr_arg, may need to check rust-lang/rust-clippy#8334

[zhang2014]

In the test, improve the performance if change &[StateAddr] to StateAddrs. There is no particularly accurate answer, just guess that &[StateAddr] will cause rust to create StateAddrs slice and get slice ref.

[JasonLi-cn]

1 Definition

pub struct Number {
    pub n: usize,
}

pub type Numbers = Vec<Number>;

2 Conclusion
After many tests, using Numbers is faster, but there doesn't seem to be a big difference.
15329906268us Using Numbers
15701229063us Using Vec<Number>:

3 Test code

fn main() {
    let mut args = std::env::args();
    args.next();
    let mut total = 0;
    let timer = std::time::Instant::now();
    for _ in 0..1024 * 128 {
        if args.next().is_none() {
            let numbers = build_numbers1(65536);
            total += sum1(&numbers);
        } else {
            let numbers = build_numbers2(65536);
            total += sum2(&numbers);
        }
    }

    let elapsed = timer.elapsed().as_nanos();
    println!("total = {}, elapsed = {}", total, elapsed);
}

pub struct Number {
    pub n: usize,
}

pub type Numbers = Vec<Number>;

fn build_numbers1(max: usize) -> Numbers {
    let mut numbers = Vec::with_capacity(max);
    for n in 0..max {
        numbers.push(Number { n });
    }
    numbers
}

fn sum1(numbers: &Numbers) -> usize {
    let mut sum = 0;
    for number in numbers {
        sum += number.n;
    }
    sum
}

fn build_numbers2(max: usize) -> Vec<Number> {
    let mut numbers = Vec::with_capacity(max);
    for n in 0..max {
        numbers.push(Number { n });
    }
    numbers
}

fn sum2(numbers: &[Number]) -> usize {
    let mut sum = 0;
    for number in numbers {
        sum += number.n;
    }
    sum
}

[zhang2014]

you are right, I retested it in the main branch. It doesn't big difference.

[zhang2014]

#5038
By the way, when I decompile the code, & [number] will call deref for dereference, and its instructions will be more complex.

lea    rdi,[rsp+0x30]
 mov    esi,0x10000
 call   a5a0 <example::build_numbers2>
 lea    rdi,[rsp+0x30]


call   9d90 <<alloc::vec::Vec<T,A> as core::ops::deref::Deref>::deref>
 mov    QWORD PTR [rsp+0x18],rdx
 mov    QWORD PTR [rsp+0x20],rax
 jmp    a772 <example::main+0x32>
 mov    rsi,QWORD PTR [rsp+0x18]
 mov    rdi,QWORD PTR [rsp+0x20]
 call   a6a0 <example::sum2>
 mov    QWORD PTR [rsp+0x10],rax
 jmp    a7a4 <example::main+0x64>

lea    rdi,[rsp+0x20]
 mov    esi,0x10000
 call   a5e0 <example::build_numbers1>
 lea    rdi,[rsp+0x20]
 call   a6e0 <example::sum1>
 mov    QWORD PTR [rsp+0x10],rax
 jmp    a7ad <example::main+0x2d>
 mov    rax,QWORD PTR [rsp+0x10]
 add    rax,QWORD PTR [rsp+0x18]
 mov    QWORD PTR [rsp+0x8],rax
 setb   al
 test   al,0x1
 jne    a7f7 <example::main+0x77>
 jmp    a7e1 <example::main+0x61>