Set limb width to 64 for loongarch64

[heiher]

No description provided.

[heiher]

Benchmarks

On LoongArch LA664

• limb_width_32:

test tests::bench_bit_length ... bench:         461 ns/iter (+/- 0)
test tests::bench_compare    ... bench:         406 ns/iter (+/- 5)
test tests::bench_hi64       ... bench:         934 ns/iter (+/- 3)
test tests::bench_iadd_small ... bench:         368 ns/iter (+/- 1)
test tests::bench_imul_small ... bench:         528 ns/iter (+/- 2)
test tests::bench_ishl       ... bench:         777 ns/iter (+/- 1)

• limb_width_64:

test tests::bench_bit_length ... bench:         431 ns/iter (+/- 0)
test tests::bench_compare    ... bench:         209 ns/iter (+/- 0)
test tests::bench_hi64       ... bench:         862 ns/iter (+/- 1)
test tests::bench_iadd_small ... bench:         364 ns/iter (+/- 0)
test tests::bench_imul_small ... bench:         357 ns/iter (+/- 0)
test tests::bench_ishl       ... bench:         456 ns/iter (+/- 1)

• bench-math.rs

#![feature(test)]

#[cfg(test)]
mod lexical;
use lexical::math::{Limb, Math};

#[derive(Clone, Default)]
struct Bigint {
    data: Vec<Limb>,
}

impl Math for Bigint {
    fn data(&self) -> &Vec<Limb> {
        &self.data
    }

    fn data_mut(&mut self) -> &mut Vec<Limb> {
        &mut self.data
    }
}

#[cfg(test)]
mod tests {
    extern crate test;
    use super::*;
    use std::cmp;
    use test::Bencher;

    #[bench]
    fn bench_compare(b: &mut Bencher) {
        b.iter(|| {
            let mut x = Bigint::from_u64(0x3333333333333333);
            let mut y = Bigint::from_u64(0x3333333333333334);
            for i in 1..=100 {
                assert_eq!(x.compare(&x), cmp::Ordering::Equal);
                assert_eq!(x.compare(&y), cmp::Ordering::Less);
                assert_eq!(y.compare(&x), cmp::Ordering::Greater);
            }
        });
    }

    #[bench]
    fn bench_hi64(b: &mut Bencher) {
        b.iter(|| {
            for i in 1..=10 {
                assert_eq!(Bigint::from_u64(0xA).hi64(), (0xA000000000000000, false));
                assert_eq!(Bigint::from_u64(0xAB).hi64(), (0xAB00000000000000, false));
                assert_eq!(
                    Bigint::from_u64(0xAB00000000).hi64(),
                    (0xAB00000000000000, false)
                );
                assert_eq!(
                    Bigint::from_u64(0xA23456789A).hi64(),
                    (0xA23456789A000000, false)
                );
            }
        });
    }

    #[bench]
    fn bench_bit_length(b: &mut Bencher) {
        b.iter(|| {
            let x = Bigint::from_u64(0);
            for i in 1..=200 {
                assert_eq!(x.bit_length(), 0);
            }
        });
    }

    #[bench]
    fn bench_iadd_small(b: &mut Bencher) {
        b.iter(|| {
            let mut x = Bigint::from_u64(0x3333333333333333);
            let mut y = Bigint::from_u64(0x3333333333333334);
            for i in 1..=100 {
                x.iadd_small(5);
                y.iadd_small(7);
            }
        });
    }

    #[bench]
    fn bench_imul_small(b: &mut Bencher) {
        b.iter(|| {
            let mut x = Bigint::from_u64(0x3333333333333333);
            let mut y = Bigint::from_u64(0x3333333333333334);
            for i in 1..=50 {
                x.imul_small(5);
                y.imul_small(7);
            }
        });
    }

    #[bench]
    fn bench_ishl(b: &mut Bencher) {
        b.iter(|| {
            let mut x = Bigint::from_u64(0x3333333333333333);
            let mut y = Bigint::from_u64(0x3333333333333334);
            for i in 1..=50 {
                x.ishl(5);
                y.ishl(7);
            }
        });
    }
}

[dtolnay]

Thank you!

[dtolnay]

Published in serde_json 1.0.111.