Skip to content

Commit 3e8d80a

Browse files
douchuandouchuan
committed
refact: extract benches & tests
1 parent e7b1e8e commit 3e8d80a

File tree

13 files changed

+377
-388
lines changed

13 files changed

+377
-388
lines changed

‎benches/dp.rs‎

Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,54 @@
1+
use algo::dp;
2+
use test::Bencher;
3+
4+
static MAKE_CHANGES_AMOUNT: i32 = 20;
5+
6+
#[bench]
7+
fn make_changes_classic(b: &mut Bencher) {
8+
let coins = vec![1, 2, 5];
9+
b.iter(|| dp::coin::make_change_classic(&coins, MAKE_CHANGES_AMOUNT));
10+
}
11+
12+
#[bench]
13+
fn make_changes_cache(b: &mut Bencher) {
14+
let coins = vec![1, 2, 5];
15+
b.iter(|| dp::coin::make_change_cache(&coins, MAKE_CHANGES_AMOUNT));
16+
}
17+
18+
#[bench]
19+
fn make_changes_iter(b: &mut Bencher) {
20+
let coins = vec![1, 2, 5];
21+
b.iter(|| dp::coin::make_change_iter(&coins, MAKE_CHANGES_AMOUNT));
22+
}
23+
24+
static BENCH_N: usize = 40;
25+
26+
#[bench]
27+
fn fib_classic_recursive(b: &mut Bencher) {
28+
b.iter(|| dp::fib::fib_classic_recursive(BENCH_N));
29+
}
30+
31+
#[bench]
32+
fn fib_cache_result(b: &mut Bencher) {
33+
b.iter(|| dp::fib::fib_cache_result(BENCH_N));
34+
}
35+
36+
#[bench]
37+
fn fib_classic_iteration_loop(b: &mut Bencher) {
38+
b.iter(|| dp::fib::fib_classic_iteration_loop(BENCH_N));
39+
}
40+
41+
#[bench]
42+
fn fib_classic_iteration_for(b: &mut Bencher) {
43+
b.iter(|| dp::fib::fib_classic_iteration_for(BENCH_N));
44+
}
45+
46+
#[bench]
47+
fn fib_cache_result_c(b: &mut Bencher) {
48+
b.iter(|| unsafe { dp::fib::fib_cache_result_c(BENCH_N) });
49+
}
50+
51+
#[bench]
52+
fn fib_classic_iteration_for_c(b: &mut Bencher) {
53+
b.iter(|| unsafe { dp::fib::fib_classic_iteration_for_c(BENCH_N) });
54+
}

‎benches/sort.rs‎

Lines changed: 202 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,202 @@
1+
#![feature(test)]
2+
extern crate test;
3+
4+
use algo::sort;
5+
use algo::sort::util;
6+
use test::Bencher;
7+
8+
#[bench]
9+
fn small_merge_v1(b: &mut Bencher) {
10+
b.iter(|| {
11+
let mut numbs = [1, 2, 4, 8, 9, 9, 13, 17, 22];
12+
let f = |x: i32, y: i32| x > y;
13+
sort::merge::v1::sort(&mut numbs, f);
14+
});
15+
}
16+
17+
#[bench]
18+
fn large_merge_v1(b: &mut Bencher) {
19+
let data = util::random_data(util::DATA_LEN);
20+
b.iter(|| {
21+
let mut numbs = data.clone();
22+
let f = |x: i32, y: i32| x > y;
23+
sort::merge::v1::sort(&mut numbs, f);
24+
});
25+
}
26+
27+
#[bench]
28+
fn large_sorted_asc_merge_v1(b: &mut Bencher) {
29+
let data = util::sorted_data_asc(util::DATA_LEN);
30+
b.iter(|| {
31+
let mut numbs = data.clone();
32+
let f = |x: i32, y: i32| x > y;
33+
sort::merge::v1::sort(&mut numbs, f);
34+
});
35+
}
36+
37+
#[bench]
38+
fn large_sorted_desc_merge_v1(b: &mut Bencher) {
39+
let data = util::sorted_data_desc(util::DATA_LEN);
40+
b.iter(|| {
41+
let mut numbs = data.clone();
42+
let f = |x: i32, y: i32| x > y;
43+
sort::merge::v1::sort(&mut numbs, f);
44+
});
45+
}
46+
47+
#[bench]
48+
fn eq_data_merge_v1(b: &mut Bencher) {
49+
let data = util::eq_data(util::DATA_LEN);
50+
b.iter(|| {
51+
let mut numbs = data.clone();
52+
let f = |x: i32, y: i32| x > y;
53+
sort::merge::v1::sort(&mut numbs, f);
54+
});
55+
}
56+
57+
#[bench]
58+
fn small_merge_v2(b: &mut Bencher) {
59+
b.iter(|| {
60+
let mut numbs = [1, 2, 4, 8, 9, 9, 13, 17, 22];
61+
let f = |x: i32, y: i32| x > y;
62+
sort::merge::v2::sort(&mut numbs, f);
63+
});
64+
}
65+
66+
#[bench]
67+
fn large_merge_v2(b: &mut Bencher) {
68+
let data = util::random_data(util::DATA_LEN);
69+
b.iter(|| {
70+
let mut numbs = data.clone();
71+
let f = |x: i32, y: i32| x > y;
72+
sort::merge::v2::sort(&mut numbs, f);
73+
});
74+
}
75+
76+
#[bench]
77+
fn large_sorted_asc_merge_v2(b: &mut Bencher) {
78+
let data = util::sorted_data_asc(util::DATA_LEN);
79+
b.iter(|| {
80+
let mut numbs = data.clone();
81+
let f = |x: i32, y: i32| x > y;
82+
sort::merge::v2::sort(&mut numbs, f);
83+
});
84+
}
85+
86+
#[bench]
87+
fn large_sorted_desc_merge_v2(b: &mut Bencher) {
88+
let data = util::sorted_data_desc(util::DATA_LEN);
89+
b.iter(|| {
90+
let mut numbs = data.clone();
91+
let f = |x: i32, y: i32| x > y;
92+
sort::merge::v2::sort(&mut numbs, f);
93+
});
94+
}
95+
96+
#[bench]
97+
fn eq_data_merge_v2(b: &mut Bencher) {
98+
let data = util::eq_data(util::DATA_LEN);
99+
b.iter(|| {
100+
let mut numbs = data.clone();
101+
let f = |x: i32, y: i32| x > y;
102+
sort::merge::v2::sort(&mut numbs, f);
103+
});
104+
}
105+
106+
#[bench]
107+
fn small_merge_v3(b: &mut Bencher) {
108+
b.iter(|| {
109+
let mut numbs = [1, 2, 4, 8, 9, 9, 13, 17, 22];
110+
let f = |x: i32, y: i32| x > y;
111+
sort::merge::v3::sort(&mut numbs, f);
112+
});
113+
}
114+
115+
#[bench]
116+
fn large_merge_v3(b: &mut Bencher) {
117+
let data = util::random_data(util::DATA_LEN);
118+
b.iter(|| {
119+
let mut numbs = data.clone();
120+
let f = |x: i32, y: i32| x > y;
121+
sort::merge::v3::sort(&mut numbs, f);
122+
});
123+
}
124+
125+
#[bench]
126+
fn large_sorted_asc_merge_v3(b: &mut Bencher) {
127+
let data = util::sorted_data_asc(util::DATA_LEN);
128+
b.iter(|| {
129+
let mut numbs = data.clone();
130+
let f = |x: i32, y: i32| x > y;
131+
sort::merge::v3::sort(&mut numbs, f);
132+
});
133+
}
134+
135+
#[bench]
136+
fn large_sorted_desc_merge_v3(b: &mut Bencher) {
137+
let data = util::sorted_data_desc(util::DATA_LEN);
138+
b.iter(|| {
139+
let mut numbs = data.clone();
140+
let f = |x: i32, y: i32| x > y;
141+
sort::merge::v3::sort(&mut numbs, f);
142+
});
143+
}
144+
145+
#[bench]
146+
fn eq_data_merge_v3(b: &mut Bencher) {
147+
let data = util::eq_data(util::DATA_LEN);
148+
b.iter(|| {
149+
let mut numbs = data.clone();
150+
let f = |x: i32, y: i32| x > y;
151+
sort::merge::v3::sort(&mut numbs, f);
152+
});
153+
}
154+
155+
#[bench]
156+
fn small_quick(b: &mut Bencher) {
157+
b.iter(|| {
158+
let mut numbs = [1, 2, 4, 8, 9, 9, 13, 17, 22];
159+
let f = |x: i32, y: i32| x > y;
160+
sort::quick::sort(&mut numbs, f);
161+
});
162+
}
163+
164+
#[bench]
165+
fn large_quick(b: &mut Bencher) {
166+
let data = util::random_data(util::DATA_LEN);
167+
b.iter(|| {
168+
let mut numbs = data.clone();
169+
let f = |x: i32, y: i32| x > y;
170+
sort::quick::sort(&mut numbs, f);
171+
});
172+
}
173+
174+
#[bench]
175+
fn large_sorted_asc_quick(b: &mut Bencher) {
176+
let data = util::sorted_data_asc(util::DATA_LEN);
177+
b.iter(|| {
178+
let mut numbs = data.clone();
179+
let f = |x: i32, y: i32| x > y;
180+
sort::quick::sort(&mut numbs, f);
181+
});
182+
}
183+
184+
#[bench]
185+
fn large_sorted_desc_quick(b: &mut Bencher) {
186+
let data = util::sorted_data_desc(util::DATA_LEN);
187+
b.iter(|| {
188+
let mut numbs = data.clone();
189+
let f = |x: i32, y: i32| x > y;
190+
sort::quick::sort(&mut numbs, f);
191+
});
192+
}
193+
194+
#[bench]
195+
fn eq_data_quick(b: &mut Bencher) {
196+
let data = util::eq_data(util::DATA_LEN);
197+
b.iter(|| {
198+
let mut numbs = data.clone();
199+
let f = |x: i32, y: i32| x > y;
200+
sort::quick::sort(&mut numbs, f);
201+
});
202+
}

‎src/dp/coin.rs‎

Lines changed: 3 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@ macro_rules! check_inputs {
2424
}
2525

2626
/// 暴力穷举
27-
fn make_change_classic(coins: &[i32], amount: i32) -> i32 {
27+
pub fn make_change_classic(coins: &[i32], amount: i32) -> i32 {
2828
if amount == 0 {
2929
return 0;
3030
}
@@ -53,7 +53,7 @@ fn make_change_classic(coins: &[i32], amount: i32) -> i32 {
5353
use std::cell::RefCell;
5454
thread_local!(static MEMO: RefCell<Vec<i32>> = RefCell::new(vec![-1; 1000]));
5555
/// 缓存最小的目标金额，避免重复计算 (消除重叠子)
56-
fn make_change_cache(coins: &[i32], amount: i32) -> i32 {
56+
pub fn make_change_cache(coins: &[i32], amount: i32) -> i32 {
5757
if amount == 0 {
5858
return 0;
5959
}
@@ -84,7 +84,7 @@ fn make_change_cache(coins: &[i32], amount: i32) -> i32 {
8484
}
8585
}
8686

87-
fn make_change_iter(coins: &[i32], amount: i32) -> i32 {
87+
pub fn make_change_iter(coins: &[i32], amount: i32) -> i32 {
8888
check_inputs!(coins, amount);
8989
let max_amount = amount + 1;
9090
// 为啥 dp 数组初始化为 amount + 1 呢，因为凑成 amount 金额的硬币数最多只
@@ -110,60 +110,3 @@ fn make_change_iter(coins: &[i32], amount: i32) -> i32 {
110110
v
111111
}
112112
}
113-
114-
//////////testcase & benchmarks
115-
use test::Bencher;
116-
117-
#[test]
118-
fn t_basic() {
119-
let coins = vec![1, 2, 5];
120-
//(min coins, amount)
121-
let solutions = vec![
122-
(3, 11),
123-
(3, 12),
124-
(4, 13),
125-
(4, 14),
126-
(3, 15),
127-
(4, 16),
128-
(4, 17),
129-
(5, 18),
130-
(5, 19),
131-
(4, 20),
132-
];
133-
for (expect, amount) in solutions {
134-
assert_eq!(expect, make_change_classic(&coins, amount));
135-
assert_eq!(expect, make_change_cache(&coins, amount));
136-
assert_eq!(expect, make_change_iter(&coins, amount));
137-
}
138-
}
139-
140-
#[test]
141-
fn t_basic_fail() {
142-
let coins = vec![2, 5];
143-
let solutions = vec![(-1, 3)];
144-
for (expect, amount) in solutions {
145-
assert_eq!(expect, make_change_classic(&coins, amount));
146-
assert_eq!(expect, make_change_cache(&coins, amount));
147-
assert_eq!(expect, make_change_iter(&coins, amount));
148-
}
149-
}
150-
151-
static AMOUNT: i32 = 20;
152-
153-
#[bench]
154-
fn bench_classic(b: &mut Bencher) {
155-
let coins = vec![1, 2, 5];
156-
b.iter(|| make_change_classic(&coins, AMOUNT));
157-
}
158-
159-
#[bench]
160-
fn bench_cache(b: &mut Bencher) {
161-
let coins = vec![1, 2, 5];
162-
b.iter(|| make_change_cache(&coins, AMOUNT));
163-
}
164-
165-
#[bench]
166-
fn bench_iter(b: &mut Bencher) {
167-
let coins = vec![1, 2, 5];
168-
b.iter(|| make_change_iter(&coins, AMOUNT));
169-
}

0 commit comments

Comments
 (0)