console.log

running 3 tests
test bench::benth_fib_memo1   ... bench:       5,237 ns/iter (+/- 411)
test bench::benth_fib_memo1_2 ... bench:           2 ns/iter (+/- 0)
test bench::benth_fib_memo2   ... bench:           2 ns/iter (+/- 0)
test result: ok. 0 passed; 0 failed; 0 ignored; 3 measured; 0 filtered out

fib_memo.rs

#![feature(test)]
extern crate test;

const MAX_N: usize = 1000;
struct FibMemo {
    memo: [i32; MAX_N],
}

impl FibMemo {
    fn new() -> Self {
        FibMemo { memo: [0; MAX_N] }
    }

    fn calc(&mut self, n: i32) -> i32 {
        if n < 2 {
            return n;
        }
        if self.memo[n as usize] != 0 {
            return self.memo[n as usize];
        }
        self.memo[n as usize] = self.calc(n - 2) + self.calc(n - 1);
        self.memo[n as usize]
    }
}

static mut MEMO: [i32; MAX_N] = [0; MAX_N];

unsafe fn calc_unsafe(n: i32) -> i32 {
    if n < 2 {
        return n;
    }
    if *MEMO.get_unchecked(n as usize) != 0 {
        return *MEMO.get_unchecked(n as usize);
    }
    *MEMO.get_unchecked_mut(n as usize) = calc_unsafe(n - 2).wrapping_add(calc_unsafe(n - 1));
    *MEMO.get_unchecked_mut(n as usize)
}

pub fn fib_memo1(n: i32) -> i32 {
    let mut f = FibMemo::new();
    f.calc(n)
}

fn fib_memo2(n: i32) -> i32 {
    if (n as usize) < MAX_N {
        unsafe { calc_unsafe(n) }
    } else {
        panic!("index overrun")
    }
}

#[cfg(test)]
mod bench {
    use super::*;
    use test::Bencher;

    #[bench]
    fn benth_fib_memo1(b: &mut Bencher) {
        b.iter(|| fib_memo1(999));
    }

    #[bench]
    fn benth_fib_memo1_2(b: &mut Bencher) {
        let mut f = FibMemo::new();
        b.iter(|| f.calc(999));
    }

    #[bench]
    fn benth_fib_memo2(b: &mut Bencher) {
        b.iter(|| fib_memo2(999));
    }

}