generic_vs_trait_object_vs_enum.rs

#![feature(test)]
extern crate test;
fn main() {
    println!("Hello, world!");
}


#[cfg(test)]
mod tests {
    use test::Bencher;
    const N: usize = 100;

    macro_rules! impl_mytrait {
        ($t: ty) => {
            impl MyTrait for $t {
                #[inline(never)]
                fn sum(&self) -> usize {
                    let mut sum = 0;
                    for i in 0..N {
                        sum += i
                    }
                    sum
                }
            } 
        };
    }
    trait MyTrait {
        fn sum(&self) -> usize;
    }

    struct A;
    struct B;
    struct C; 
    struct D;

    impl_mytrait!(A);
    impl_mytrait!(B);
    impl_mytrait!(C);
    impl_mytrait!(D);

    enum E {
        A(A),
        B(B),
        C(C),
        D(D),
    }

    impl MyTrait for E {
        fn sum(&self) -> usize {
            match &self {
                &E::A(a) => a.sum(), 
                &E::B(a) => a.sum(), 
                &E::C(a) => a.sum(), 
                &E::D(a) => a.sum(), 
            }
        }
    }

    const COUNT: usize = 100;
    #[bench]
    fn bench_enum(b: &mut Bencher) {
        let mut v = Vec::with_capacity(4 * COUNT);
        for _ in 0..COUNT {
            v.push(E::A(A));
            v.push(E::B(B));
            v.push(E::C(C));
            v.push(E::D(D));
        }

        b.iter(|| {
            let mut sum = 0;
            for e in &v {
                sum += test::black_box(e.sum());
            }
            sum
        })
    }

    #[bench]
    fn bench_trait_object(b: &mut Bencher) {
        let mut v: Vec<Box<dyn MyTrait>> = Vec::with_capacity(4 * COUNT);
        for _ in 0..COUNT {
            v.push(Box::new(A));
            v.push(Box::new(B));
            v.push(Box::new(C));
            v.push(Box::new(D));
        }

        b.iter(|| {
            let mut sum = 0;
            for e in &v {
                sum += test::black_box(e.sum());
            }
            sum
        })
    }

    struct TestGeneric<T: MyTrait> {
        s: T
    }

    impl<T: MyTrait> TestGeneric<T> {
        #[inline(never)]
        fn sum(&self) -> usize {
            self.s.sum()
        }
    }

    struct TestTraitObject {
        s: Box<dyn MyTrait>
    }

    impl TestTraitObject {
        #[inline(never)]
        fn sum(&self) -> usize {
            self.s.sum()
        }
    }

    #[bench]
    fn bench_generic(b: &mut Bencher) {
        let mut v = Vec::with_capacity(COUNT);
        for _ in 0..COUNT {
            v.push(TestGeneric{s: D});
        }
        b.iter(|| {
            let mut sum = 0;
            for t in &v {
                sum += test::black_box(t.sum());
            }
            sum
        })
    }

    #[bench]
    fn bench_trait_object2(b: &mut Bencher) {
        let mut v = Vec::with_capacity(COUNT);
        for _ in 0..COUNT {
            v.push(TestTraitObject{s: Box::new(D)});
        }
        b.iter(|| {
            let mut sum = 0;
            for t in &v {
                sum += test::black_box(t.sum());
            }
            sum
        })
    }
}

running 4 tests
test tests::bench_enum          ... bench:         971 ns/iter (+/- 25)
test tests::bench_generic       ... bench:         154 ns/iter (+/- 9)
test tests::bench_trait_object  ... bench:         495 ns/iter (+/- 27)
test tests::bench_trait_object2 ... bench:         178 ns/iter (+/- 23)