File size: 6,761 Bytes
d5bfab8 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 |
use std::cmp;
#[derive(Debug, Eq, Hash, PartialEq)]
pub enum PerformanceClassifierResult {
ErrorTooShortInputVector,
ErrorDifferentInputVectorLengths,
Identical,
NewProgramIsAlwaysFaster,
NewProgramIsEqualOrFaster,
NewProgramIsAlwaysFasterWhenSkippingTheFirstSlice,
RejectNewProgram,
}
pub struct PerformanceClassifier {
number_of_items_in_first_slice: usize,
}
impl PerformanceClassifier {
pub fn new(number_of_items_in_first_slice: usize) -> Self {
assert!(number_of_items_in_first_slice > 0);
Self {
number_of_items_in_first_slice: number_of_items_in_first_slice
}
}
pub fn analyze(&self, steps0: &Vec<u64>, steps1: &Vec<u64>) -> PerformanceClassifierResult {
if steps0.len() != steps1.len() {
return PerformanceClassifierResult::ErrorDifferentInputVectorLengths;
}
let len = cmp::min(steps0.len(), steps1.len());
if len <= self.number_of_items_in_first_slice {
return PerformanceClassifierResult::ErrorTooShortInputVector;
}
let first_slice0: &[u64] = &steps0[..self.number_of_items_in_first_slice];
let first_slice1: &[u64] = &steps1[..self.number_of_items_in_first_slice];
assert!(first_slice0.len() == self.number_of_items_in_first_slice);
assert!(first_slice1.len() == self.number_of_items_in_first_slice);
let last_slice0: &[u64] = &steps0[self.number_of_items_in_first_slice..];
let last_slice1: &[u64] = &steps1[self.number_of_items_in_first_slice..];
assert!(first_slice0.len() + last_slice0.len() == steps0.len());
assert!(first_slice1.len() + last_slice1.len() == steps1.len());
let (first_count_program0, first_count_same, first_count_program1) = Self::histogram(first_slice0, first_slice1);
let (last_count_program0, last_count_same, last_count_program1) = Self::histogram(last_slice0, last_slice1);
let count_program0 = first_count_program0 + last_count_program0;
let count_same = first_count_same + last_count_same;
let count_program1 = first_count_program1 + last_count_program1;
if count_program0 == 0 && count_same > 0 && count_program1 == 0 {
return PerformanceClassifierResult::Identical;
}
if count_program0 > 0 && count_same == 0 && count_program1 == 0 {
return PerformanceClassifierResult::NewProgramIsAlwaysFaster;
}
if count_program0 > 0 && count_same > 0 && count_program1 == 0 {
return PerformanceClassifierResult::NewProgramIsEqualOrFaster;
}
if first_count_program1 > 0 &&
last_count_program0 > 0 && last_count_same == 0 && last_count_program1 == 0 {
return PerformanceClassifierResult::NewProgramIsAlwaysFasterWhenSkippingTheFirstSlice;
}
PerformanceClassifierResult::RejectNewProgram
}
fn histogram(steps0: &[u64], steps1: &[u64]) -> (usize, usize, usize) {
let mut count_same: usize = 0;
let mut count_less_than: usize = 0;
let mut count_greater_than: usize = 0;
let len = cmp::min(steps0.len(), steps1.len());
for i in 0..len {
let steps0: u64 = steps0[i];
let steps1: u64 = steps1[i];
if steps0 < steps1 {
count_less_than += 1;
continue;
}
if steps0 > steps1 {
count_greater_than += 1;
continue;
}
count_same += 1;
}
(count_less_than, count_same, count_greater_than)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn histogram(steps0: Vec<u64>, steps1: Vec<u64>) -> String {
let (a, b, c) = PerformanceClassifier::histogram(&steps0, &steps1);
format!("{} {} {}", a, b, c)
}
#[test]
fn test_10000_histogram() {
assert_eq!(histogram(vec![1, 1], vec![2, 2]), "2 0 0");
assert_eq!(histogram(vec![1, 1], vec![1, 1]), "0 2 0");
assert_eq!(histogram(vec![2, 2], vec![1, 1]), "0 0 2");
assert_eq!(histogram(vec![1, 1, 2, 1], vec![2, 2, 2, 2]), "3 1 0");
assert_eq!(histogram(vec![2, 2, 1, 2], vec![1, 1, 1, 1]), "0 1 3");
assert_eq!(histogram(vec![5, 1, 5, 1], vec![2, 4, 2, 4]), "2 0 2");
}
#[test]
fn test_20000_analyze_error_different_lengths() {
let steps0: Vec<u64> = vec![5, 5, 5, 5, 5];
let steps1: Vec<u64> = vec![5, 5, 5, 5, 5, 666];
let pc = PerformanceClassifier::new(2);
let result = pc.analyze(&steps0, &steps1);
assert_eq!(result, PerformanceClassifierResult::ErrorDifferentInputVectorLengths);
}
#[test]
fn test_20001_analyze_error_too_short() {
let steps: Vec<u64> = vec![5, 5, 5, 5, 5];
let pc = PerformanceClassifier::new(10);
let result = pc.analyze(&steps, &steps);
assert_eq!(result, PerformanceClassifierResult::ErrorTooShortInputVector);
}
#[test]
fn test_30000_analyze_identical() {
let steps: Vec<u64> = vec![5, 5, 5, 5, 5];
let pc = PerformanceClassifier::new(2);
let result = pc.analyze(&steps, &steps);
assert_eq!(result, PerformanceClassifierResult::Identical);
}
#[test]
fn test_30001_analyze_is_always_faster() {
let steps0: Vec<u64> = vec![4, 4, 3, 4, 2];
let steps1: Vec<u64> = vec![5, 5, 5, 5, 5];
let pc = PerformanceClassifier::new(3);
let result = pc.analyze(&steps0, &steps1);
assert_eq!(result, PerformanceClassifierResult::NewProgramIsAlwaysFaster);
}
#[test]
fn test_30002_analyze_new_program_is_equal_or_faster() {
let steps0: Vec<u64> = vec![4, 5, 3, 5, 2];
let steps1: Vec<u64> = vec![5, 5, 5, 5, 5];
let pc = PerformanceClassifier::new(3);
let result = pc.analyze(&steps0, &steps1);
assert_eq!(result, PerformanceClassifierResult::NewProgramIsEqualOrFaster);
}
#[test]
fn test_30003_analyze_new_program_is_equal_or_faster() {
let steps0: Vec<u64> = vec![40, 40, 40, 5, 5, 5];
let steps1: Vec<u64> = vec![5, 5, 5, 40, 40, 40];
let pc = PerformanceClassifier::new(3);
let result = pc.analyze(&steps0, &steps1);
assert_eq!(result, PerformanceClassifierResult::NewProgramIsAlwaysFasterWhenSkippingTheFirstSlice);
}
#[test]
fn test_40000_analyze_reject_new_program() {
let steps0: Vec<u64> = vec![40, 41, 43, 46, 50, 60];
let steps1: Vec<u64> = vec![5, 5, 5, 5, 5, 5];
let pc = PerformanceClassifier::new(3);
let result = pc.analyze(&steps0, &steps1);
assert_eq!(result, PerformanceClassifierResult::RejectNewProgram);
}
}
|