715 lines
20 KiB
Rust
715 lines
20 KiB
Rust
use std::time::Duration as StdDuration;
|
|
|
|
use criterion::Bencher;
|
|
use time::ext::{NumericalDuration, NumericalStdDuration};
|
|
use time::Duration;
|
|
|
|
setup_benchmark! {
|
|
"Duration",
|
|
|
|
fn is_zero(ben: &mut Bencher<'_>) {
|
|
let a = (-1).nanoseconds();
|
|
let b = 0.seconds();
|
|
let c = 1.nanoseconds();
|
|
ben.iter(|| a.is_zero());
|
|
ben.iter(|| b.is_zero());
|
|
ben.iter(|| c.is_zero());
|
|
}
|
|
|
|
fn is_negative(ben: &mut Bencher<'_>) {
|
|
let a = (-1).seconds();
|
|
let b = 0.seconds();
|
|
let c = 1.seconds();
|
|
ben.iter(|| a.is_negative());
|
|
ben.iter(|| b.is_negative());
|
|
ben.iter(|| c.is_negative());
|
|
}
|
|
|
|
fn is_positive(ben: &mut Bencher<'_>) {
|
|
let a = (-1).seconds();
|
|
let b = 0.seconds();
|
|
let c = 1.seconds();
|
|
ben.iter(|| a.is_positive());
|
|
ben.iter(|| b.is_positive());
|
|
ben.iter(|| c.is_positive());
|
|
}
|
|
|
|
fn abs(ben: &mut Bencher<'_>) {
|
|
let a = 1.seconds();
|
|
let b = 0.seconds();
|
|
let c = (-1).seconds();
|
|
ben.iter(|| a.abs());
|
|
ben.iter(|| b.abs());
|
|
ben.iter(|| c.abs());
|
|
}
|
|
|
|
fn unsigned_abs(ben: &mut Bencher<'_>) {
|
|
let a = 1.seconds();
|
|
let b = 0.seconds();
|
|
let c = (-1).seconds();
|
|
ben.iter(|| a.unsigned_abs());
|
|
ben.iter(|| b.unsigned_abs());
|
|
ben.iter(|| c.unsigned_abs());
|
|
}
|
|
|
|
fn new(ben: &mut Bencher<'_>) {
|
|
ben.iter(|| Duration::new(1, 0));
|
|
ben.iter(|| Duration::new(-1, 0));
|
|
ben.iter(|| Duration::new(1, 2_000_000_000));
|
|
|
|
ben.iter(|| Duration::new(0, 0));
|
|
ben.iter(|| Duration::new(0, 1_000_000_000));
|
|
ben.iter(|| Duration::new(-1, 1_000_000_000));
|
|
ben.iter(|| Duration::new(-2, 1_000_000_000));
|
|
|
|
ben.iter(|| Duration::new(1, -1));
|
|
ben.iter(|| Duration::new(-1, 1));
|
|
ben.iter(|| Duration::new(1, 1));
|
|
ben.iter(|| Duration::new(-1, -1));
|
|
ben.iter(|| Duration::new(0, 1));
|
|
ben.iter(|| Duration::new(0, -1));
|
|
|
|
ben.iter(|| Duration::new(-1, 1_400_000_000));
|
|
ben.iter(|| Duration::new(-2, 1_400_000_000));
|
|
ben.iter(|| Duration::new(-3, 1_400_000_000));
|
|
ben.iter(|| Duration::new(1, -1_400_000_000));
|
|
ben.iter(|| Duration::new(2, -1_400_000_000));
|
|
ben.iter(|| Duration::new(3, -1_400_000_000));
|
|
}
|
|
|
|
fn weeks(ben: &mut Bencher<'_>) {
|
|
ben.iter(|| Duration::weeks(1));
|
|
ben.iter(|| Duration::weeks(2));
|
|
ben.iter(|| Duration::weeks(-1));
|
|
ben.iter(|| Duration::weeks(-2));
|
|
}
|
|
|
|
fn days(ben: &mut Bencher<'_>) {
|
|
ben.iter(|| Duration::days(1));
|
|
ben.iter(|| Duration::days(2));
|
|
ben.iter(|| Duration::days(-1));
|
|
ben.iter(|| Duration::days(-2));
|
|
}
|
|
|
|
fn hours(ben: &mut Bencher<'_>) {
|
|
ben.iter(|| Duration::hours(1));
|
|
ben.iter(|| Duration::hours(2));
|
|
ben.iter(|| Duration::hours(-1));
|
|
ben.iter(|| Duration::hours(-2));
|
|
}
|
|
|
|
fn minutes(ben: &mut Bencher<'_>) {
|
|
ben.iter(|| Duration::minutes(1));
|
|
ben.iter(|| Duration::minutes(2));
|
|
ben.iter(|| Duration::minutes(-1));
|
|
ben.iter(|| Duration::minutes(-2));
|
|
}
|
|
|
|
fn seconds(ben: &mut Bencher<'_>) {
|
|
ben.iter(|| Duration::seconds(1));
|
|
ben.iter(|| Duration::seconds(2));
|
|
ben.iter(|| Duration::seconds(-1));
|
|
ben.iter(|| Duration::seconds(-2));
|
|
}
|
|
|
|
fn seconds_f64(ben: &mut Bencher<'_>) {
|
|
ben.iter(|| Duration::seconds_f64(0.5));
|
|
ben.iter(|| Duration::seconds_f64(-0.5));
|
|
}
|
|
|
|
fn seconds_f32(ben: &mut Bencher<'_>) {
|
|
ben.iter(|| Duration::seconds_f32(0.5));
|
|
ben.iter(|| Duration::seconds_f32(-0.5));
|
|
}
|
|
|
|
fn saturating_seconds_f64(ben: &mut Bencher<'_>) {
|
|
ben.iter(|| Duration::saturating_seconds_f64(0.5));
|
|
ben.iter(|| Duration::saturating_seconds_f64(-0.5));
|
|
}
|
|
|
|
fn saturating_seconds_f32(ben: &mut Bencher<'_>) {
|
|
ben.iter(|| Duration::saturating_seconds_f32(0.5));
|
|
ben.iter(|| Duration::saturating_seconds_f32(-0.5));
|
|
}
|
|
|
|
fn checked_seconds_f64(ben: &mut Bencher<'_>) {
|
|
ben.iter(|| Duration::checked_seconds_f64(0.5));
|
|
ben.iter(|| Duration::checked_seconds_f64(-0.5));
|
|
}
|
|
|
|
fn checked_seconds_f32(ben: &mut Bencher<'_>) {
|
|
ben.iter(|| Duration::checked_seconds_f32(0.5));
|
|
ben.iter(|| Duration::checked_seconds_f32(-0.5));
|
|
}
|
|
|
|
fn milliseconds(ben: &mut Bencher<'_>) {
|
|
ben.iter(|| Duration::milliseconds(1));
|
|
ben.iter(|| Duration::milliseconds(-1));
|
|
}
|
|
|
|
fn microseconds(ben: &mut Bencher<'_>) {
|
|
ben.iter(|| Duration::microseconds(1));
|
|
ben.iter(|| Duration::microseconds(-1));
|
|
}
|
|
|
|
fn nanoseconds(ben: &mut Bencher<'_>) {
|
|
ben.iter(|| Duration::nanoseconds(1));
|
|
ben.iter(|| Duration::nanoseconds(-1));
|
|
}
|
|
|
|
fn whole_weeks(ben: &mut Bencher<'_>) {
|
|
let a = Duration::weeks(1);
|
|
let b = Duration::weeks(-1);
|
|
let c = Duration::days(6);
|
|
let d = Duration::days(-6);
|
|
ben.iter(|| a.whole_weeks());
|
|
ben.iter(|| b.whole_weeks());
|
|
ben.iter(|| c.whole_weeks());
|
|
ben.iter(|| d.whole_weeks());
|
|
}
|
|
|
|
fn whole_days(ben: &mut Bencher<'_>) {
|
|
let a = Duration::days(1);
|
|
let b = Duration::days(-1);
|
|
let c = Duration::hours(23);
|
|
let d = Duration::hours(-23);
|
|
ben.iter(|| a.whole_days());
|
|
ben.iter(|| b.whole_days());
|
|
ben.iter(|| c.whole_days());
|
|
ben.iter(|| d.whole_days());
|
|
}
|
|
|
|
fn whole_hours(ben: &mut Bencher<'_>) {
|
|
let a = Duration::hours(1);
|
|
let b = Duration::hours(-1);
|
|
let c = Duration::minutes(59);
|
|
let d = Duration::minutes(-59);
|
|
ben.iter(|| a.whole_hours());
|
|
ben.iter(|| b.whole_hours());
|
|
ben.iter(|| c.whole_hours());
|
|
ben.iter(|| d.whole_hours());
|
|
}
|
|
|
|
fn whole_minutes(ben: &mut Bencher<'_>) {
|
|
let a = 1.minutes();
|
|
let b = (-1).minutes();
|
|
let c = 59.seconds();
|
|
let d = (-59).seconds();
|
|
ben.iter(|| a.whole_minutes());
|
|
ben.iter(|| b.whole_minutes());
|
|
ben.iter(|| c.whole_minutes());
|
|
ben.iter(|| d.whole_minutes());
|
|
}
|
|
|
|
fn whole_seconds(ben: &mut Bencher<'_>) {
|
|
let a = 1.seconds();
|
|
let b = (-1).seconds();
|
|
let c = 1.minutes();
|
|
let d = (-1).minutes();
|
|
ben.iter(|| a.whole_seconds());
|
|
ben.iter(|| b.whole_seconds());
|
|
ben.iter(|| c.whole_seconds());
|
|
ben.iter(|| d.whole_seconds());
|
|
}
|
|
|
|
fn as_seconds_f64(ben: &mut Bencher<'_>) {
|
|
let a = 1.seconds();
|
|
let b = (-1).seconds();
|
|
let c = 1.minutes();
|
|
let d = (-1).minutes();
|
|
let e = 1.5.seconds();
|
|
let f = (-1.5).seconds();
|
|
ben.iter(|| a.as_seconds_f64());
|
|
ben.iter(|| b.as_seconds_f64());
|
|
ben.iter(|| c.as_seconds_f64());
|
|
ben.iter(|| d.as_seconds_f64());
|
|
ben.iter(|| e.as_seconds_f64());
|
|
ben.iter(|| f.as_seconds_f64());
|
|
}
|
|
|
|
fn as_seconds_f32(ben: &mut Bencher<'_>) {
|
|
let a = 1.seconds();
|
|
let b = (-1).seconds();
|
|
let c = 1.minutes();
|
|
let d = (-1).minutes();
|
|
let e = 1.5.seconds();
|
|
let f = (-1.5).seconds();
|
|
ben.iter(|| a.as_seconds_f32());
|
|
ben.iter(|| b.as_seconds_f32());
|
|
ben.iter(|| c.as_seconds_f32());
|
|
ben.iter(|| d.as_seconds_f32());
|
|
ben.iter(|| e.as_seconds_f32());
|
|
ben.iter(|| f.as_seconds_f32());
|
|
}
|
|
|
|
fn whole_milliseconds(ben: &mut Bencher<'_>) {
|
|
let a = 1.seconds();
|
|
let b = (-1).seconds();
|
|
let c = 1.milliseconds();
|
|
let d = (-1).milliseconds();
|
|
ben.iter(|| a.whole_milliseconds());
|
|
ben.iter(|| b.whole_milliseconds());
|
|
ben.iter(|| c.whole_milliseconds());
|
|
ben.iter(|| d.whole_milliseconds());
|
|
}
|
|
|
|
fn subsec_milliseconds(ben: &mut Bencher<'_>) {
|
|
let a = 1.4.seconds();
|
|
let b = (-1.4).seconds();
|
|
ben.iter(|| a.subsec_milliseconds());
|
|
ben.iter(|| b.subsec_milliseconds());
|
|
}
|
|
|
|
fn whole_microseconds(ben: &mut Bencher<'_>) {
|
|
let a = 1.milliseconds();
|
|
let b = (-1).milliseconds();
|
|
let c = 1.microseconds();
|
|
let d = (-1).microseconds();
|
|
ben.iter(|| a.whole_microseconds());
|
|
ben.iter(|| b.whole_microseconds());
|
|
ben.iter(|| c.whole_microseconds());
|
|
ben.iter(|| d.whole_microseconds());
|
|
}
|
|
|
|
fn subsec_microseconds(ben: &mut Bencher<'_>) {
|
|
let a = 1.0004.seconds();
|
|
let b = (-1.0004).seconds();
|
|
ben.iter(|| a.subsec_microseconds());
|
|
ben.iter(|| b.subsec_microseconds());
|
|
}
|
|
|
|
fn whole_nanoseconds(ben: &mut Bencher<'_>) {
|
|
let a = 1.microseconds();
|
|
let b = (-1).microseconds();
|
|
let c = 1.nanoseconds();
|
|
let d = (-1).nanoseconds();
|
|
ben.iter(|| a.whole_nanoseconds());
|
|
ben.iter(|| b.whole_nanoseconds());
|
|
ben.iter(|| c.whole_nanoseconds());
|
|
ben.iter(|| d.whole_nanoseconds());
|
|
}
|
|
|
|
fn subsec_nanoseconds(ben: &mut Bencher<'_>) {
|
|
let a = 1.000_000_4.seconds();
|
|
let b = (-1.000_000_4).seconds();
|
|
ben.iter(|| a.subsec_nanoseconds());
|
|
ben.iter(|| b.subsec_nanoseconds());
|
|
}
|
|
|
|
fn checked_add(ben: &mut Bencher<'_>) {
|
|
let a = 5.seconds();
|
|
let b = Duration::MAX;
|
|
let c = (-5).seconds();
|
|
|
|
let a2 = 5.seconds();
|
|
let b2 = 1.nanoseconds();
|
|
let c2 = 5.seconds();
|
|
|
|
ben.iter(|| a.checked_add(a2));
|
|
ben.iter(|| b.checked_add(b2));
|
|
ben.iter(|| c.checked_add(c2));
|
|
}
|
|
|
|
fn checked_sub(ben: &mut Bencher<'_>) {
|
|
let a = 5.seconds();
|
|
let b = Duration::MIN;
|
|
let c = 5.seconds();
|
|
|
|
let a2 = 5.seconds();
|
|
let b2 = 1.nanoseconds();
|
|
let c2 = 10.seconds();
|
|
|
|
ben.iter(|| a.checked_sub(a2));
|
|
ben.iter(|| b.checked_sub(b2));
|
|
ben.iter(|| c.checked_sub(c2));
|
|
}
|
|
|
|
fn checked_mul(ben: &mut Bencher<'_>) {
|
|
let a = 5.seconds();
|
|
let b = Duration::MAX;
|
|
ben.iter(|| a.checked_mul(2));
|
|
ben.iter(|| b.checked_mul(2));
|
|
}
|
|
|
|
fn checked_div(ben: &mut Bencher<'_>) {
|
|
let a = 10.seconds();
|
|
ben.iter(|| a.checked_div(2));
|
|
ben.iter(|| a.checked_div(0));
|
|
}
|
|
|
|
fn saturating_add(ben: &mut Bencher<'_>) {
|
|
let a = 5.seconds();
|
|
let b = Duration::MAX;
|
|
let c = Duration::MIN;
|
|
let d = (-5).seconds();
|
|
|
|
let a2 = 5.seconds();
|
|
let b2 = 1.nanoseconds();
|
|
let c2 = (-1).nanoseconds();
|
|
let d2 = 5.seconds();
|
|
|
|
ben.iter(|| a.saturating_add(a2));
|
|
ben.iter(|| b.saturating_add(b2));
|
|
ben.iter(|| c.saturating_add(c2));
|
|
ben.iter(|| d.saturating_add(d2));
|
|
}
|
|
|
|
fn saturating_sub(ben: &mut Bencher<'_>) {
|
|
let a = 5.seconds();
|
|
let b = Duration::MIN;
|
|
let c = Duration::MAX;
|
|
let d = 5.seconds();
|
|
|
|
let a2 = 5.seconds();
|
|
let b2 = 1.nanoseconds();
|
|
let c2 = (-1).nanoseconds();
|
|
let d2 = 10.seconds();
|
|
|
|
ben.iter(|| a.saturating_sub(a2));
|
|
ben.iter(|| b.saturating_sub(b2));
|
|
ben.iter(|| c.saturating_sub(c2));
|
|
ben.iter(|| d.saturating_sub(d2));
|
|
}
|
|
|
|
fn saturating_mul(ben: &mut Bencher<'_>) {
|
|
let a = 5.seconds();
|
|
let b = 5.seconds();
|
|
let c = 5.seconds();
|
|
let d = Duration::MAX;
|
|
let e = Duration::MIN;
|
|
let f = Duration::MAX;
|
|
let g = Duration::MIN;
|
|
|
|
ben.iter(|| a.saturating_mul(2));
|
|
ben.iter(|| b.saturating_mul(-2));
|
|
ben.iter(|| c.saturating_mul(0));
|
|
ben.iter(|| d.saturating_mul(2));
|
|
ben.iter(|| e.saturating_mul(2));
|
|
ben.iter(|| f.saturating_mul(-2));
|
|
ben.iter(|| g.saturating_mul(-2));
|
|
}
|
|
|
|
fn try_from_std_duration(ben: &mut Bencher<'_>) {
|
|
let a = 0.std_seconds();
|
|
let b = 1.std_seconds();
|
|
ben.iter(|| Duration::try_from(a));
|
|
ben.iter(|| Duration::try_from(b));
|
|
}
|
|
|
|
fn try_to_std_duration(ben: &mut Bencher<'_>) {
|
|
let a = 0.seconds();
|
|
let b = 1.seconds();
|
|
let c = (-1).seconds();
|
|
ben.iter(|| StdDuration::try_from(a));
|
|
ben.iter(|| StdDuration::try_from(b));
|
|
ben.iter(|| StdDuration::try_from(c));
|
|
}
|
|
|
|
fn add(ben: &mut Bencher<'_>) {
|
|
let a = 1.seconds();
|
|
let b = 2.seconds();
|
|
let c = 500.milliseconds();
|
|
let d = (-1).seconds();
|
|
ben.iter(|| a + b + c + d);
|
|
}
|
|
|
|
fn add_std(ben: &mut Bencher<'_>) {
|
|
let a = 1.seconds();
|
|
let b = 2.std_seconds();
|
|
ben.iter(|| a + b);
|
|
}
|
|
|
|
fn std_add(ben: &mut Bencher<'_>) {
|
|
let a = 1.std_seconds();
|
|
let b = 2.seconds();
|
|
ben.iter(|| a + b);
|
|
}
|
|
|
|
fn add_assign(ben: &mut Bencher<'_>) {
|
|
let a = 1.seconds();
|
|
let b = 500.milliseconds();
|
|
let c = (-1).seconds();
|
|
iter_batched_ref!(
|
|
ben,
|
|
|| 1.seconds(),
|
|
[
|
|
|duration| *duration += a,
|
|
|duration| *duration += b,
|
|
|duration| *duration += c,
|
|
]
|
|
);
|
|
}
|
|
|
|
fn add_assign_std(ben: &mut Bencher<'_>) {
|
|
let a = 1.std_seconds();
|
|
let b = 500.std_milliseconds();
|
|
iter_batched_ref!(
|
|
ben,
|
|
|| 1.seconds(),
|
|
[
|
|
|duration| *duration += a,
|
|
|duration| *duration += b,
|
|
]
|
|
);
|
|
}
|
|
|
|
fn neg(ben: &mut Bencher<'_>) {
|
|
let a = 1.seconds();
|
|
let b = (-1).seconds();
|
|
let c = 0.seconds();
|
|
ben.iter(|| -a);
|
|
ben.iter(|| -b);
|
|
ben.iter(|| -c);
|
|
}
|
|
|
|
fn sub(ben: &mut Bencher<'_>) {
|
|
let a = 1.seconds();
|
|
let b = 1.seconds();
|
|
let c = 1_500.milliseconds();
|
|
let d = 500.milliseconds();
|
|
let e = 1.seconds();
|
|
let f = (-1).seconds();
|
|
ben.iter(|| a - b);
|
|
ben.iter(|| b - c);
|
|
ben.iter(|| c - d);
|
|
ben.iter(|| d - e);
|
|
ben.iter(|| e - f);
|
|
ben.iter(|| f - a);
|
|
}
|
|
|
|
fn sub_std(ben: &mut Bencher<'_>) {
|
|
let a = 1.seconds();
|
|
let b = 2.std_seconds();
|
|
ben.iter(|| a - b);
|
|
}
|
|
|
|
fn std_sub(ben: &mut Bencher<'_>) {
|
|
let a = 1.std_seconds();
|
|
let b = 2.seconds();
|
|
ben.iter(|| a - b);
|
|
}
|
|
|
|
fn sub_assign(ben: &mut Bencher<'_>) {
|
|
let a = 1.seconds();
|
|
let b = 500.milliseconds();
|
|
let c = (-1).seconds();
|
|
iter_batched_ref!(
|
|
ben,
|
|
|| 1.seconds(),
|
|
[
|
|
|duration| *duration -= a,
|
|
|duration| *duration -= b,
|
|
|duration| *duration -= c,
|
|
]
|
|
);
|
|
}
|
|
|
|
fn mul_int(ben: &mut Bencher<'_>) {
|
|
let d = 1.seconds();
|
|
ben.iter(|| d * 2);
|
|
ben.iter(|| d * -2);
|
|
}
|
|
|
|
fn mul_int_assign(ben: &mut Bencher<'_>) {
|
|
iter_batched_ref!(
|
|
ben,
|
|
|| 1.seconds(),
|
|
[
|
|
|duration| *duration *= 2,
|
|
|duration| *duration *= -2,
|
|
]
|
|
);
|
|
}
|
|
|
|
fn int_mul(ben: &mut Bencher<'_>) {
|
|
let d = 1.seconds();
|
|
ben.iter(|| 2 * d);
|
|
ben.iter(|| -2 * d);
|
|
}
|
|
|
|
fn div_int(ben: &mut Bencher<'_>) {
|
|
let d = 1.seconds();
|
|
ben.iter(|| d / 2);
|
|
ben.iter(|| d / -2);
|
|
}
|
|
|
|
fn div_int_assign(ben: &mut Bencher<'_>) {
|
|
iter_batched_ref!(
|
|
ben,
|
|
|| 1.seconds(),
|
|
[
|
|
|duration| *duration /= 2,
|
|
|duration| *duration /= -2,
|
|
]
|
|
);
|
|
}
|
|
|
|
fn div(ben: &mut Bencher<'_>) {
|
|
let a = 1.seconds();
|
|
let b = 0.5.seconds();
|
|
ben.iter(|| a / b);
|
|
}
|
|
|
|
fn mul_float(ben: &mut Bencher<'_>) {
|
|
let d = 1.seconds();
|
|
ben.iter(|| d * 1.5_f32);
|
|
ben.iter(|| d * 2.5_f32);
|
|
ben.iter(|| d * -1.5_f32);
|
|
ben.iter(|| d * 0_f32);
|
|
ben.iter(|| d * 1.5_f64);
|
|
ben.iter(|| d * 2.5_f64);
|
|
ben.iter(|| d * -1.5_f64);
|
|
ben.iter(|| d * 0_f64);
|
|
}
|
|
|
|
fn float_mul(ben: &mut Bencher<'_>) {
|
|
let d = 1.seconds();
|
|
ben.iter(|| 1.5_f32 * d);
|
|
ben.iter(|| 2.5_f32 * d);
|
|
ben.iter(|| -1.5_f32 * d);
|
|
ben.iter(|| 0_f32 * d);
|
|
ben.iter(|| 1.5_f64 * d);
|
|
ben.iter(|| 2.5_f64 * d);
|
|
ben.iter(|| -1.5_f64 * d);
|
|
ben.iter(|| 0_f64 * d);
|
|
}
|
|
|
|
fn mul_float_assign(ben: &mut Bencher<'_>) {
|
|
iter_batched_ref!(
|
|
ben,
|
|
|| 1.seconds(),
|
|
[
|
|
|duration| *duration *= 1.5_f32,
|
|
|duration| *duration *= 2.5_f32,
|
|
|duration| *duration *= -1.5_f32,
|
|
|duration| *duration *= 3.15_f32,
|
|
|duration| *duration *= 1.5_f64,
|
|
|duration| *duration *= 2.5_f64,
|
|
|duration| *duration *= -1.5_f64,
|
|
|duration| *duration *= 0_f64,
|
|
]
|
|
);
|
|
}
|
|
|
|
fn div_float(ben: &mut Bencher<'_>) {
|
|
let d = 1.seconds();
|
|
ben.iter(|| d / 1_f32);
|
|
ben.iter(|| d / 2_f32);
|
|
ben.iter(|| d / -1_f32);
|
|
ben.iter(|| d / 1_f64);
|
|
ben.iter(|| d / 2_f64);
|
|
ben.iter(|| d / -1_f64);
|
|
}
|
|
|
|
fn div_float_assign(ben: &mut Bencher<'_>) {
|
|
iter_batched_ref!(
|
|
ben,
|
|
|| 10.seconds(),
|
|
[
|
|
|duration| *duration /= 1_f32,
|
|
|duration| *duration /= 2_f32,
|
|
|duration| *duration /= -1_f32,
|
|
|duration| *duration /= 1_f64,
|
|
|duration| *duration /= 2_f64,
|
|
|duration| *duration /= -1_f64,
|
|
]
|
|
);
|
|
}
|
|
|
|
fn partial_eq(ben: &mut Bencher<'_>) {
|
|
let a = 1.minutes();
|
|
let b = (-1).minutes();
|
|
let c = 40.seconds();
|
|
ben.iter(|| a == b);
|
|
ben.iter(|| c == a);
|
|
}
|
|
|
|
fn partial_eq_std(ben: &mut Bencher<'_>) {
|
|
let a = (-1).seconds();
|
|
let b = 1.std_seconds();
|
|
let c = (-1).minutes();
|
|
let d = 1.std_minutes();
|
|
let e = 40.seconds();
|
|
ben.iter(|| a == b);
|
|
ben.iter(|| c == d);
|
|
ben.iter(|| e == d);
|
|
}
|
|
|
|
fn std_partial_eq(ben: &mut Bencher<'_>) {
|
|
let a = 1.std_seconds();
|
|
let b = (-1).seconds();
|
|
let c = 1.std_minutes();
|
|
let d = (-1).minutes();
|
|
let e = 40.std_seconds();
|
|
let f = 1.minutes();
|
|
ben.iter(|| a == b);
|
|
ben.iter(|| c == d);
|
|
ben.iter(|| e == f);
|
|
}
|
|
|
|
fn partial_ord(ben: &mut Bencher<'_>) {
|
|
let a = 0.seconds();
|
|
let b = 1.seconds();
|
|
let c = (-1).seconds();
|
|
let d = 1.minutes();
|
|
let e = (-1).minutes();
|
|
ben.iter(|| a.partial_cmp(&a));
|
|
ben.iter(|| b.partial_cmp(&a));
|
|
ben.iter(|| b.partial_cmp(&c));
|
|
ben.iter(|| c.partial_cmp(&b));
|
|
ben.iter(|| a.partial_cmp(&c));
|
|
ben.iter(|| a.partial_cmp(&b));
|
|
ben.iter(|| c.partial_cmp(&a));
|
|
ben.iter(|| d.partial_cmp(&b));
|
|
ben.iter(|| e.partial_cmp(&c));
|
|
}
|
|
|
|
fn partial_ord_std(ben: &mut Bencher<'_>) {
|
|
let a = 0.seconds();
|
|
let b = 0.std_seconds();
|
|
let c = 1.seconds();
|
|
let d = (-1).seconds();
|
|
let e = 1.std_seconds();
|
|
let f = 1.minutes();
|
|
let g = u64::MAX.std_seconds();
|
|
ben.iter(|| a.partial_cmp(&b));
|
|
ben.iter(|| c.partial_cmp(&b));
|
|
ben.iter(|| d.partial_cmp(&e));
|
|
ben.iter(|| a.partial_cmp(&e));
|
|
ben.iter(|| d.partial_cmp(&b));
|
|
ben.iter(|| f.partial_cmp(&e));
|
|
ben.iter(|| a.partial_cmp(&g));
|
|
}
|
|
|
|
fn std_partial_ord(ben: &mut Bencher<'_>) {
|
|
let a = 0.std_seconds();
|
|
let b = 0.seconds();
|
|
let c = 1.std_seconds();
|
|
let d = (-1).seconds();
|
|
let e = 1.seconds();
|
|
let f = 1.std_minutes();
|
|
ben.iter(|| a.partial_cmp(&b));
|
|
ben.iter(|| c.partial_cmp(&b));
|
|
ben.iter(|| c.partial_cmp(&d));
|
|
ben.iter(|| a.partial_cmp(&d));
|
|
ben.iter(|| a.partial_cmp(&e));
|
|
ben.iter(|| f.partial_cmp(&e));
|
|
}
|
|
|
|
fn ord(ben: &mut Bencher<'_>) {
|
|
let a = 1.seconds();
|
|
let b = 0.seconds();
|
|
let c = (-1).seconds();
|
|
let d = 1.minutes();
|
|
let e = (-1).minutes();
|
|
ben.iter(|| a > b);
|
|
ben.iter(|| a > c);
|
|
ben.iter(|| c < a);
|
|
ben.iter(|| b > c);
|
|
ben.iter(|| b < a);
|
|
ben.iter(|| c < b);
|
|
ben.iter(|| d > a);
|
|
ben.iter(|| e < c);
|
|
}
|
|
}
|