This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11624

dirstate-v2: Change the representation of negative directory mtime
AbandonedPublic

Authored by SimonSapin on Oct 11 2021, 4:31 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Summary

Change it from how I previously thought C’s timespec works
to how it actually works. See code comments.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

SimonSapin created this revision.Oct 11 2021, 4:31 PM
SimonSapin abandoned this revision.Oct 12 2021, 7:56 AM

Resubmitted as D11629 because phabsend errors with abort: Conduit Error (ERR-CONDUIT-CORE): Graph cycle detected when swapping the order of two existing patches.

martinvonz added a subscriber: martinvonz.Oct 12 2021, 11:54 AM
In D11624#178221, @SimonSapin wrote:

Resubmitted as D11629 because phabsend errors with abort: Conduit Error (ERR-CONDUIT-CORE): Graph cycle detected when swapping the order of two existing patches.

FYI, a workaround is to remove the relationships first and then add them back in the order you want.

Revision Contents
Changeset List

Diff 30705

rust/hg-core/src/dirstate_tree/on_disk.rs

/// Duration since the Unix epoch /// Duration since the Unix epoch
#[derive(BytesCast, Copy, Clone, PartialEq)] #[derive(BytesCast, Copy, Clone, PartialEq)]
#[repr(C)] #[repr(C)]
pub(super) struct Timestamp { pub(super) struct Timestamp {
seconds: I64Be, seconds: I64Be,
/// In `0 .. 1_000_000_000`. /// In `0 .. 1_000_000_000`.
/// ///
/// This timestamp is later or earlier than `(seconds, 0)` by this many /// This timestamp is after `(seconds, 0)` by this many nanoseconds.
/// nanoseconds, if `seconds` is non-negative or negative, respectively.
nanoseconds: U32Be, nanoseconds: U32Be,
} }
/// Counted in bytes from the start of the file /// Counted in bytes from the start of the file
/// ///
/// NOTE: not supporting `.hg/dirstate` files larger than 4 GiB. /// NOTE: not supporting `.hg/dirstate` files larger than 4 GiB.
type Offset = U32Be; type Offset = U32Be;
} }
impl Timestamp { impl Timestamp {
pub fn seconds(&self) -> i64 { pub fn seconds(&self) -> i64 {
self.seconds.get() self.seconds.get()
} }
} }
const NSEC_PER_SEC: u32 = 1_000_000_000;
impl From<SystemTime> for Timestamp { impl From<SystemTime> for Timestamp {
fn from(system_time: SystemTime) -> Self { fn from(system_time: SystemTime) -> Self {
// On Unix, `SystemTime` is a wrapper for the `timespec` C struct:
// https://www.gnu.org/software/libc/manual/html_node/Time-Types.html#index-struct-timespec
// We want to effectively access its fields, but the Rust standard
// library does not expose them. The best we can do is:
let (secs, nanos) = match system_time.duration_since(UNIX_EPOCH) { let (secs, nanos) = match system_time.duration_since(UNIX_EPOCH) {
Ok(duration) => { Ok(duration) => {
(duration.as_secs() as i64, duration.subsec_nanos()) (duration.as_secs() as i64, duration.subsec_nanos())
} }
Err(error) => { Err(error) => {
// `system_time` is before `UNIX_EPOCH`.
// We need to undo this algorithm:
// https://github.com/rust-lang/rust/blob/6bed1f0bc3cc50c10aab26d5f94b16a00776b8a5/library/std/src/sys/unix/time.rs#L40-L41
let negative = error.duration(); let negative = error.duration();
(-(negative.as_secs() as i64), negative.subsec_nanos()) let negative_secs = negative.as_secs() as i64;
let negative_nanos = negative.subsec_nanos();
if negative_nanos == 0 {
(-negative_secs, 0)
} else {
// For example if `system_time` was 4.3!seconds before
// the Unix epoch we get a Duration that represents
// `(-4, -0.3)` but we want `(-5, +0.7)`:
(-1 - negative_secs, NSEC_PER_SEC - negative_nanos)
}
} }
}; };
Timestamp { Timestamp {
seconds: secs.into(), seconds: secs.into(),
nanoseconds: nanos.into(), nanoseconds: nanos.into(),
} }
} }
} }
impl From<&'_ Timestamp> for SystemTime { impl From<&'_ Timestamp> for SystemTime {
fn from(timestamp: &'_ Timestamp) -> Self { fn from(timestamp: &'_ Timestamp) -> Self {
let secs = timestamp.seconds.get(); let secs = timestamp.seconds.get();
let nanos = timestamp.nanoseconds.get(); let nanos = timestamp.nanoseconds.get();
if secs >= 0 { if secs < 0 {
UNIX_EPOCH + Duration::new(secs as u64, nanos) let (s_to_subtract, ns_to_subtract) = if nanos == 0 {
(-secs, 0)
} else {
// Example: `(-5, +0.7)` → `(-4, -0.3)`
// See `impl From<SystemTime> for Timestamp` above
(1 - secs, NSEC_PER_SEC - nanos)
};
UNIX_EPOCH - Duration::new(s_to_subtract as u64, ns_to_subtract)
} else { } else {
UNIX_EPOCH - Duration::new((-secs) as u64, nanos) UNIX_EPOCH + Duration::new(secs as u64, nanos)
} }
} }
} }
fn read_hg_path( fn read_hg_path(
on_disk: &[u8], on_disk: &[u8],
slice: PathSlice, slice: PathSlice,
) -> Result<&HgPath, DirstateV2ParseError> { ) -> Result<&HgPath, DirstateV2ParseError> {