Rust - Owned vs borrowed benchmark

lib.rs

/*
YMMV
 Compiling rust-bench-test v0.1.0 (/home/adam/apps/rust-bench-test)
    Finished release [optimized] target(s) in 0.78s
     Running /home/adam/apps/rust-bench-test/target/release/deps/rust_bench_test-5e0b4fbe4a887c9a

running 3 tests
test bench_gather_borrowed_foos ... bench:         291 ns/iter (+/- 18)
test bench_gather_owned_foos    ... bench:         333 ns/iter (+/- 9)
test bench_passed_borrowed_foos ... bench:         283 ns/iter (+/- 17)

test result: ok. 0 passed; 0 failed; 0 ignored; 3 measured; 0 filtered out
*/

#![feature(test)]

extern crate test;
use test::Bencher;

#[derive(Debug)]
pub struct Foo {
    bar: String,
}

pub fn gather_owned_foos<'a>(data: Vec<Vec<&'a Foo>>) -> Vec<Vec<&'a Foo>> {
    let mut ret: Vec<Vec<&Foo>> = Vec::new();

    for v in data {
        if meets_requirements(&v) {
            ret.push(v);
        }
    }

    return ret
}

pub fn gather_borrowed_foos<'a>(data: &'a Vec<&'a Vec<&'a Foo>>) -> Vec<&'a Vec<&'a Foo>> {
    let mut ret: Vec<&Vec<&Foo>> = Vec::new();

    for i in 0..data.len() {
        if meets_requirements(data[i]) {
            ret.push(data[i]);
        }
    }

    return ret
}

pub fn gather_passed_foos<'a>(data: &'a Vec<&'a Vec<&'a Foo>>, ret: &'a mut Vec<&'a Vec<&'a Foo>>) {
    for i in 0..data.len() {
        if meets_requirements(data[i]) {
            ret.push(data[i]);
        }
    }
}

fn meets_requirements<'a>(_data: &'a Vec<&'a Foo>) -> bool {
    true
}

#[bench]
fn bench_gather_owned_foos(b: &mut Bencher) {
    b.iter(|| {
        let foo = Foo{
            bar: String::from("bar"),
        };
        let v1 = vec![&foo, &foo, &foo];
        let v2 = vec![&foo, &foo];
        let data = vec![v1, v2];

        gather_owned_foos(data);
    });
}

#[bench]
fn bench_gather_borrowed_foos(b: &mut Bencher) {
    b.iter(|| {
        let foo = Foo{
            bar: String::from("bar"),
        };
        let v1 = vec![&foo, &foo, &foo];
        let v2 = vec![&foo, &foo];
        let data = vec![&v1, &v2];

        gather_borrowed_foos(&data);
    });
}

#[bench]
fn bench_passed_borrowed_foos(b: &mut Bencher) {
    b.iter(|| {
        let foo = Foo{
            bar: String::from("bar"),
        };
        let v1 = vec![&foo, &foo, &foo];
        let v2 = vec![&foo, &foo];
        let data = vec![&v1, &v2];
        let mut ret: Vec<&Vec<&Foo>> = Vec::new();

        gather_passed_foos(&data, &mut ret);
    });
}