( )⚙ D11702 dirstate-v2: actually use sub-second mtime precision

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11702

dirstate-v2: actually use sub-second mtime precision
ClosedPublic

Authored by marmoute on Oct 19 2021, 6:03 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG83d0bd45b662: dirstate-v2: actually use sub-second mtime precision
Summary

Instead of zero, set the nanoseconds field to its correct value whenever
possible and preserve it across serialization+parsing.

Diff Detail

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

Event Timeline

marmoute created this revision.Oct 19 2021, 6:03 PM
Alphare accepted this revision.Oct 20 2021, 4:40 AM
This revision is now accepted and ready to land.Oct 20 2021, 4:40 AM
marmoute updated this revision to Diff 30933.Oct 20 2021, 5:12 AM
SimonSapin added a commit: rHG83d0bd45b662: dirstate-v2: actually use sub-second mtime precision.Oct 20 2021, 5:31 AM
Closed by commit rHG83d0bd45b662: dirstate-v2: actually use sub-second mtime precision (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 30933

mercurial/dirstateutils/timestamp.py

return tuple.__new__(timestamp, (0, 0)) return tuple.__new__(timestamp, (0, 0))
def mtime_of(stat_result): def mtime_of(stat_result):
""" """
Takes an `os.stat_result`-like object and returns a `timestamp` object Takes an `os.stat_result`-like object and returns a `timestamp` object
for its modification time. for its modification time.
""" """
try:
# TODO: add this attribute to `osutil.stat` objects,
# see `mercurial/cext/osutil.c`.
#
# This attribute is also not available on Python 2.
nanos = stat_result.st_mtime_ns
except AttributeError:
# https://docs.python.org/2/library/os.html#os.stat_float_times # https://docs.python.org/2/library/os.html#os.stat_float_times
# "For compatibility with older Python versions, # "For compatibility with older Python versions,
# accessing stat_result as a tuple always returns integers." # accessing stat_result as a tuple always returns integers."
secs = stat_result[stat.ST_MTIME] secs = stat_result[stat.ST_MTIME]
# For now
subsec_nanos = 0 subsec_nanos = 0
else:
billion = int(1e9)
secs = nanos // billion
subsec_nanos = nanos % billion
return timestamp((secs, subsec_nanos)) return timestamp((secs, subsec_nanos))

mercurial/dirstateutils/v2.py

copy_source_len, copy_source_len,
children_start, children_start,
children_count, children_count,
_descendants_with_entry_count, _descendants_with_entry_count,
_tracked_descendants_count, _tracked_descendants_count,
flags, flags,
size, size,
mtime_s, mtime_s,
_mtime_ns, mtime_ns,
) = NODE.unpack(node_bytes) ) = NODE.unpack(node_bytes)
# Parse child nodes of this node recursively # Parse child nodes of this node recursively
parse_nodes(map, copy_map, data, children_start, children_count) parse_nodes(map, copy_map, data, children_start, children_count)
# Don’t yet use sub-second precision if it exists in the file,
# since other parts of the code still set it to zero.
mtime_ns = 0
item = parsers.DirstateItem.from_v2_data(flags, size, mtime_s, mtime_ns) item = parsers.DirstateItem.from_v2_data(flags, size, mtime_s, mtime_ns)
if not item.any_tracked: if not item.any_tracked:
continue continue
path = slice_with_len(data, path_start, path_len) path = slice_with_len(data, path_start, path_len)
map[path] = item map[path] = item
if copy_source_start: if copy_source_start:
copy_map[path] = slice_with_len( copy_map[path] = slice_with_len(
data, copy_source_start, copy_source_len data, copy_source_start, copy_source_len

rust/hg-core/src/dirstate/entry.rs

Ok(Self::new_truncate(seconds, nanoseconds)) Ok(Self::new_truncate(seconds, nanoseconds))
} }
#[cfg(not(unix))] #[cfg(not(unix))]
{ {
metadata.modified().map(Self::from) metadata.modified().map(Self::from)
} }
} }
pub fn to_integer_second(mut self) -> Self {
self.nanoseconds = 0;
self
}
/// The lower 31 bits of the number of seconds since the epoch. /// The lower 31 bits of the number of seconds since the epoch.
pub fn truncated_seconds(&self) -> u32 { pub fn truncated_seconds(&self) -> u32 {
self.truncated_seconds self.truncated_seconds
} }
/// The sub-second component of this timestamp, in nanoseconds. /// The sub-second component of this timestamp, in nanoseconds.
/// Always in the `0 .. 1_000_000_000` range. /// Always in the `0 .. 1_000_000_000` range.
/// ///

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

None None
}; };
let mtime = if self.flags().contains(Flags::HAS_FILE_MTIME) let mtime = if self.flags().contains(Flags::HAS_FILE_MTIME)
&& !self.flags().contains(Flags::EXPECTED_STATE_IS_MODIFIED) && !self.flags().contains(Flags::EXPECTED_STATE_IS_MODIFIED)
// The current code is not able to do the more subtle comparison that the // The current code is not able to do the more subtle comparison that the
// MTIME_SECOND_AMBIGUOUS requires. So we ignore the mtime // MTIME_SECOND_AMBIGUOUS requires. So we ignore the mtime
&& !self.flags().contains(Flags::MTIME_SECOND_AMBIGUOUS) && !self.flags().contains(Flags::MTIME_SECOND_AMBIGUOUS)
{ {
// TODO: replace this by `self.mtime.try_into()?` to use Some(self.mtime.try_into()?)
// sub-second precision from the file.
// We don’t do this yet because other parts of the code
// always set it to zero.
let mtime = TruncatedTimestamp::from_already_truncated(
self.mtime.truncated_seconds.get(),
0,
)?;
Some(mtime)
} else { } else {
None None
}; };
Ok(DirstateEntry::from_v2_data( Ok(DirstateEntry::from_v2_data(
wdir_tracked, wdir_tracked,
p1_tracked, p1_tracked,
p2_info, p2_info,
mode_size, mode_size,

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

.lock() .lock()
.unwrap() .unwrap()
.modified .modified
.push(hg_path.detach_from_tree()) .push(hg_path.detach_from_tree())
} else { } else {
let mtime_looks_clean; let mtime_looks_clean;
if let Some(dirstate_mtime) = entry.truncated_mtime() { if let Some(dirstate_mtime) = entry.truncated_mtime() {
let fs_mtime = TruncatedTimestamp::for_mtime_of(fs_metadata) let fs_mtime = TruncatedTimestamp::for_mtime_of(fs_metadata)
.expect("OS/libc does not support mtime?") .expect("OS/libc does not support mtime?");
// For now don’t use sub-second precision for file mtimes
.to_integer_second();
mtime_looks_clean = fs_mtime.likely_equal(dirstate_mtime) mtime_looks_clean = fs_mtime.likely_equal(dirstate_mtime)
&& !fs_mtime.likely_equal(self.options.last_normal_time) && !fs_mtime.likely_equal(self.options.last_normal_time)
} else { } else {
// No mtime in the dirstate entry // No mtime in the dirstate entry
mtime_looks_clean = false mtime_looks_clean = false
}; };
if !mtime_looks_clean { if !mtime_looks_clean {
self.outcome self.outcome