tai64: time is wrong in different ways

[wxifze]

TLDR: Second assertion in the following code fails.

fn main() {
    let now_tai = tai64::Tai64::now();
    let now_std = std::time::SystemTime::now();

    // making sure the second didn't change between measurements
    assert_eq!(now_tai, tai64::Tai64::now());

    let now_tai_unix: u64 = now_tai
        .to_unix()
        .try_into()
        .expect("21st century");
    let now_std_unix: u64 = now_std
        .duration_since(std::time::SystemTime::UNIX_EPOCH)
        .expect("21st century")
        .as_secs();

    assert_eq!(now_tai_unix, now_std_unix);
}

thread 'main' panicked at src/main.rs:17:5:
assertion `left == right` failed
  left: 1756146344
 right: 1756146317
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Time standards are anything but trivial. TAI, UTC, and Unix time are three different time standards. In particular, they differ in how they handle leap seconds. The crate tai64 attempts to solve the conversion between TAI64 and Unix timestamps, which are (semi)standardized binary representations of a moment in time in TAI and Unix time respectively. Since Unix time is defined from UTC, which in turn defined from TAI, we should discuss relationship between the latter two.

By definition, 1 January 1972 00:00:00 UTC is 1 January 1972 00:00:10 TAI exactly¹. Yet, at the moment of writing, The current difference between UTC and TAI is 37 seconds. (TAI is ahead of UTC by this amount)². Change in difference over time comes from leap seconds, which have been inserted in 27 times since 1972.

This means that the difference between representations of a moment in time in TAI and UTC is not only a function of the current moment in time but also of the moment in question.

The problem with the current implementation isn't limited to the offset being constant: it is inconsistent. In UNIX_EPOCH it is 37, but in the methods from_unix and to_unix, it is 10:

formats/tai64/src/lib.rs

Line 40 in 950e25e

pub const UNIX_EPOCH: Self = Self(37 + (1 << 62));

formats/tai64/src/lib.rs

Line 63 in 950e25e

Tai64((secs + 10 + (1 << 62)) as u64)

formats/tai64/src/lib.rs

Line 68 in 950e25e

(self.0 as i64) - (10 + (1 << 62))

Footnotes

1. Blair 1974, p. 32. ↩

2. Leap second and UT1-UTC information. NIST. ↩

[tarcieri]

Can you please open focused issues for specific problems, rather than trying to lump them all into one issue?

It seems you are trying to discuss two separate things:

1. tai64 doesn't support conversions using historical interpretations of TAI that differ from the current ones, i.e. we can't ask how someone at date X in the past would've converted TAI timestamps to other formats. That would require the library to maintain a historical database of all of the leap second offsets. That's effectively a wontfix.
2. tai64 doesn't have a single constant it uses for conversions, and some are using an outdated constant. That's a real issue.

Are there others I'm missing?

We do also have a test in CI that the conversion implemented by the latest version of the crate is accurate: https://github.com/RustCrypto/formats/blob/master/.github/workflows/tai64_update_leap_seconds.yml