jiff vs chrono benchmark comparing timestamp and civil arithmetic

[keltia]

Am I doing something wrong here, or is it expected?

fn main() {
    divan::main();
}

use divan::{black_box, Bencher};

#[divan::bench]
fn test_jiff(bencher: Bencher) {
    use jiff::civil::DateTime;
    use jiff::Span;

    #[inline]
    fn expand_interval_jiff(begin: DateTime, end: DateTime) -> eyre::Result<Vec<DateTime>> {
        let mut d = begin;
        let mut intv = vec![];

        let day = Span::new().days(1);
        while d < end {
            intv.push(d);
            d = d.checked_add(day).expect("overflow");
        }
        Ok(intv)
    }

    let begin = "2024-01-01".parse().unwrap();
    let end = "2024-12-31".parse().unwrap();
    bencher.bench_local(move || black_box(expand_interval_jiff(begin, end)));
}

#[divan::bench]
fn test_chrono(bencher: Bencher) {
    use chrono::{Duration, Utc};

    #[inline]
    fn expand_interval(
        begin: chrono::DateTime<Utc>,
        end: chrono::DateTime<Utc>,
    ) -> eyre::Result<Vec<chrono::DateTime<Utc>>> {
        let mut d = begin;
        let mut intv = vec![];

        while d < end {
            intv.push(d);
            d += Duration::days(1);
        }
        Ok(intv)
    }

    let begin = dateparser::parse("2024-01-01").unwrap();
    let end = dateparser::parse("2024-12-31").unwrap();
    bencher.bench_local(move || black_box(expand_interval(begin, end)));
}

gives the following results on an AMD 7700X 5.2 GHz.

     Running benches\div_expand.rs (C:\Users\roberto\Src\rs\src\fetiche-rs\target\release\deps\div_expand-b08e512e801e6b28.exe)
Timer precision: 100 ns
div_expand      fastest       │ slowest       │ median        │ mean          │ samples │ iters
├─ test_chrono  1.599 µs      │ 2.462 µs      │ 1.731 µs      │ 1.785 µs      │ 100     │ 800
╰─ test_jiff    32.79 µs      │ 42.99 µs      │ 33.19 µs      │ 33.56 µs      │ 100     │ 100

[BurntSushi]

Can you provide a complete reproduction? e.g., Cargo.toml.

Note though that you're using two very different duration types. Since you're using civil time here, the actual semantics here end up being the same, but a Span is in general a fair bit more sophisticated than a chrono::TimeDelta or a jiff::SignedDuration. So it's overall going to have a higher performance floor. With that said, lots of stuff using Span in Jiff have had about zero attention paid to perf, so there are likely some low hanging fruits.

[BurntSushi]

Yeah there's probably a fair bit of low hanging fruit here. I don't know if civil time arithmetic can be as fast as timestamp arithmetic, but I'm pretty confident the existing implementation can be sped up quite a bit. Especially for common cases like "add 1 day."

[keltia]

In case you are interested, the whole project is there: https://github.com/keltia/fetiche-rs. It deals with aeronautical timestamped data like drone positions and ADS-B records.

[BurntSushi]

Nice! And wow, it looks like a migration to Jiff is a fair bit of work. I see chrono used in lots of files in there. Good luck.

Once it's done, I would love to hear a more holistic experience report about how it went. I'm especially interested in things like, "I spent 20 minutes looking for something or trying to do something" and "I did something this way but it feels wrong."

[keltia]

I guess the main obstacle to such a migration is that so many crates support std DateTime & chrono and not yet jiff. Thinking of datafusion, polars and similar libraries. This is why I haven't really started yet..

[BurntSushi]

Yeah that is definitely the biggest stumbling block. It's a chicken-and-egg problem. With jiff 0.2, which I hope to release soon, I'm going to try and switch my focus to ecosystem integration. But it will be a bit clunky.

[BurntSushi]

OK, it took me a few minutes to go from your code to something I can actually run. It would definitely be appreciated to include a full reproduction in the future. But here's my Cargo.toml:

[package]
publish = false
name = "jiff-v-chrono-benchmark"
version = "0.1.0"
edition = "2021"

[dependencies]
chrono = "0.4.39"
dateparser = "0.2.1"
divan = "0.1.17"
eyre = "0.6.12"
jiff = { path = "/home/andrew/rust/jiff/fixit" }

[[bench]]
name = "jiff-v-chrono"
path = "main.rs"
harness = false

[profile.release]
debug = true

And my Rust source code, which I expanded quite a bit to include more benchmarks:

use divan::{black_box, Bencher};

fn main() {
    divan::main();
}

#[divan::bench]
fn test_jiff_civil_span(bencher: Bencher) {
    use jiff::civil::DateTime;
    use jiff::Span;

    #[inline]
    fn expand_interval_jiff(
        begin: DateTime,
        end: DateTime,
    ) -> eyre::Result<Vec<DateTime>> {
        let mut d = begin;
        let mut intv = vec![];

        let day = Span::new().days(1);
        while d < end {
            intv.push(d);
            d = d.checked_add(day).expect("overflow");
        }
        Ok(intv)
    }

    let begin = "2024-01-01".parse().unwrap();
    let end = "2024-12-31".parse().unwrap();
    bencher.bench_local(move || black_box(expand_interval_jiff(begin, end)));
}

#[divan::bench]
fn test_jiff_civil_duration(bencher: Bencher) {
    use jiff::civil::DateTime;
    use jiff::SignedDuration;

    #[inline]
    fn expand_interval_jiff(
        begin: DateTime,
        end: DateTime,
    ) -> eyre::Result<Vec<DateTime>> {
        let mut d = begin;
        let mut intv = vec![];

        let day = SignedDuration::from_hours(24);
        while d < end {
            intv.push(d);
            d = d.checked_add(day).expect("overflow");
        }
        Ok(intv)
    }

    let begin = "2024-01-01".parse().unwrap();
    let end = "2024-12-31".parse().unwrap();
    bencher.bench_local(move || black_box(expand_interval_jiff(begin, end)));
}

#[divan::bench]
fn test_jiff_timestamp_span(bencher: Bencher) {
    use jiff::Span;
    use jiff::Timestamp;

    #[inline]
    fn expand_interval_jiff(
        begin: Timestamp,
        end: Timestamp,
    ) -> eyre::Result<Vec<Timestamp>> {
        let mut d = begin;
        let mut intv = vec![];

        let day = Span::new().hours(24);
        while d < end {
            intv.push(d);
            d = d.checked_add(day).expect("overflow");
        }
        Ok(intv)
    }

    let begin = "2024-01-01T00:00Z".parse().unwrap();
    let end = "2024-12-31T00:00Z".parse().unwrap();
    bencher.bench_local(move || black_box(expand_interval_jiff(begin, end)));
}

#[divan::bench]
fn test_jiff_timestamp_duration(bencher: Bencher) {
    use jiff::SignedDuration;
    use jiff::Timestamp;

    #[inline]
    fn expand_interval_jiff(
        begin: Timestamp,
        end: Timestamp,
    ) -> eyre::Result<Vec<Timestamp>> {
        let mut d = begin;
        let mut intv = vec![];

        let day = SignedDuration::from_hours(24);
        while d < end {
            intv.push(d);
            d = d.checked_add(day).expect("overflow");
        }
        Ok(intv)
    }

    let begin = "2024-01-01T00:00Z".parse().unwrap();
    let end = "2024-12-31T00:00Z".parse().unwrap();
    bencher.bench_local(move || black_box(expand_interval_jiff(begin, end)));
}

#[divan::bench]
fn test_chrono_timestamp(bencher: Bencher) {
    use chrono::{Duration, Utc};

    #[inline]
    fn expand_interval(
        begin: chrono::DateTime<Utc>,
        end: chrono::DateTime<Utc>,
    ) -> eyre::Result<Vec<chrono::DateTime<Utc>>> {
        let mut d = begin;
        let mut intv = vec![];

        while d < end {
            intv.push(d);
            d += Duration::days(1);
        }
        Ok(intv)
    }

    let begin = dateparser::parse("2024-01-01").unwrap();
    let end = dateparser::parse("2024-12-31").unwrap();
    bencher.bench_local(move || black_box(expand_interval(begin, end)));
}

#[divan::bench]
fn test_chrono_civil(bencher: Bencher) {
    use chrono::Duration;

    #[inline]
    fn expand_interval(
        begin: chrono::NaiveDateTime,
        end: chrono::NaiveDateTime,
    ) -> eyre::Result<Vec<chrono::NaiveDateTime>> {
        let mut d = begin;
        let mut intv = vec![];

        while d < end {
            intv.push(d);
            d += Duration::days(1);
        }
        Ok(intv)
    }

    let begin = dateparser::parse("2024-01-01").unwrap().naive_utc();
    let end = dateparser::parse("2024-12-31").unwrap().naive_utc();
    bencher.bench_local(move || black_box(expand_interval(begin, end)));
}

Where test_jiff_civil_span and test_chrono_timestamp correspond to your original benchmarks. And running the benchmarks:

$ cargo bench -- --sample-size 1000
    Finished `bench` profile [optimized + debuginfo] target(s) in 0.01s
     Running main.rs (target/release/deps/jiff_v_chrono-42466e13fc533ea1)
Timer precision: 16 ns
jiff_v_chrono                    fastest       │ slowest       │ median        │ mean          │ samples │ iters
├─ test_chrono_civil             2.565 µs      │ 2.842 µs      │ 2.591 µs      │ 2.602 µs      │ 100     │ 100000
├─ test_chrono_timestamp         4.77 µs       │ 4.895 µs      │ 4.785 µs      │ 4.794 µs      │ 100     │ 100000
├─ test_jiff_civil_duration      17.03 µs      │ 17.28 µs      │ 17.12 µs      │ 17.11 µs      │ 100     │ 100000
├─ test_jiff_civil_span          37.85 µs      │ 38.7 µs       │ 37.93 µs      │ 37.94 µs      │ 100     │ 100000
├─ test_jiff_timestamp_duration  2.597 µs      │ 2.78 µs       │ 2.604 µs      │ 2.607 µs      │ 100     │ 100000
╰─ test_jiff_timestamp_span      5.365 µs      │ 5.43 µs       │ 5.372 µs      │ 5.373 µs      │ 100     │ 100000

I increased the sample iterations because I was getting some pretty massive noise otherwise.

[keltia]

So, it is clearly a good idea to parse into jiff::Timestamp. Thanks!

[keltia]

And of course, Timestamp::series() blows everything up, of course :)

Timer precision: 100 ns
div_expand                       fastest       │ slowest       │ median        │ mean          │ samples │ iters
├─ test_chrono                   2.161 µs      │ 3.641 µs      │ 2.405 µs      │ 2.492 µs      │ 100     │ 100000
├─ test_jiff_duration            16.65 µs      │ 20.05 µs      │ 17.34 µs      │ 17.42 µs      │ 100     │ 100000
├─ test_jiff_duration_date       10.85 µs      │ 12.09 µs      │ 11.29 µs      │ 11.3 µs       │ 100     │ 100000
├─ test_jiff_duration_timestamp  2.455 µs      │ 3.754 µs      │ 2.903 µs      │ 2.986 µs      │ 100     │ 100000
├─ test_jiff_naive               37.65 µs      │ 45.46 µs      │ 39.21 µs      │ 39.3 µs       │ 100     │ 100000
╰─ test_jiff_timestamp_series    132.7 ns      │ 315.5 ns      │ 139 ns        │ 149.7 ns      │ 100     │ 100000

[BurntSushi]

I also think the series stuff uses Span, which is just much more expressive than a plain nanosecond duration. Using a Span is just never going to be as fast as a single 96-bit integer.

[BurntSushi]

Perf is part of the reason why Jiff has a SignedDuration. So if perf is important to you, that's what you should be using. I generally think it's acceptable to lose convenience if you're chasing perf.

[BurntSushi]

Can you show me your Timestamp::series benchmark?

[BurntSushi]

I'm working on a huge batch of perf improvements, and here's a sneak peek:

timestamp/every_hour_in_week/series                             22.79     2.4±0.01µs        ? ?/sec    1.00    107.3±1.31ns        ? ?/sec

Even quite a bit faster than doing it by hand in chrono or time:

[andrew@duff bench]$ critcmp update -g '(.*)/(?:jiff|chrono|time)$' -f 'series|byhand'
group                                  update//chrono                         update//jiff                           update//time
-----                                  --------------                         ------------                           ------------
timestamp/every_hour_in_week/byhand    15.82  1650.4±5.04ns        ? ?/sec    1.00    104.3±0.73ns        ? ?/sec    32.60     3.4±0.05µs        ? ?/sec
timestamp/every_hour_in_week/series                                           1.00    107.3±1.31ns        ? ?/sec

[BurntSushi]

OK, jiff 0.2.1 should have the aforementioned improvements.

if you run into more perf problems, please do share the complete benchmark. :-) Thanks!