( )⚙ D11632 dirstate-v2: Separate Rust structs for Timestamp and PackedTimestamp

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11632

dirstate-v2: Separate Rust structs for Timestamp and PackedTimestamp
ClosedPublic

Authored by SimonSapin on Oct 12 2021, 1:00 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGd2f760c2c91c: dirstate-v2: Separate Rust structs for Timestamp and PackedTimestamp
Summary

PackedTimestamp is now exclusively for dirstate-v2 serialization purpose.
It contains unaligned big-endian integers. Timestamp is used everywhere else
and contains native Rust integers.

Diff Detail

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

Event Timeline

SimonSapin created this revision.Oct 12 2021, 1:00 PM
SimonSapin added a commit: rHGd2f760c2c91c: dirstate-v2: Separate Rust structs for Timestamp and PackedTimestamp.Oct 12 2021, 2:03 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGd2f760c2c91c: dirstate-v2: Separate Rust structs for Timestamp and PackedTimestamp (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 30720

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

use crate::errors::HgError; use crate::errors::HgError;
use bitflags::bitflags; use bitflags::bitflags;
use std::convert::TryFrom; use std::convert::TryFrom;
use std::time::{SystemTime, UNIX_EPOCH};
#[derive(Copy, Clone, Debug, Eq, PartialEq)] #[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum EntryState { pub enum EntryState {
Normal, Normal,
Added, Added,
Removed, Removed,
Merged, Merged,
} }
bitflags! { bitflags! {
pub(crate) struct Flags: u8 { pub(crate) struct Flags: u8 {
const WDIR_TRACKED = 1 << 0; const WDIR_TRACKED = 1 << 0;
const P1_TRACKED = 1 << 1; const P1_TRACKED = 1 << 1;
const P2_INFO = 1 << 2; const P2_INFO = 1 << 2;
} }
} }
#[derive(Copy, Clone, PartialEq)]
pub struct Timestamp {
seconds: i64,
/// In `0 .. 1_000_000_000`.
///
/// This timestamp is after `(seconds, 0)` by this many nanoseconds.
nanoseconds: u32,
}
impl Timestamp {
pub fn new(seconds: i64, nanoseconds: u32) -> Self {
Self {
seconds,
nanoseconds,
}
}
pub fn seconds(&self) -> i64 {
self.seconds
}
pub fn nanoseconds(&self) -> u32 {
self.nanoseconds
}
}
impl From<SystemTime> for Timestamp {
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 seconds;
let nanoseconds;
match system_time.duration_since(UNIX_EPOCH) {
Ok(duration) => {
seconds = duration.as_secs() as i64;
nanoseconds = duration.subsec_nanos();
}
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_secs = negative.as_secs() as i64;
let negative_nanos = negative.subsec_nanos();
if negative_nanos == 0 {
seconds = -negative_secs;
nanoseconds = 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)`:
const NSEC_PER_SEC: u32 = 1_000_000_000;
seconds = -1 - negative_secs;
nanoseconds = NSEC_PER_SEC - negative_nanos;
}
}
};
Self {
seconds,
nanoseconds,
}
}
}
pub const V1_RANGEMASK: i32 = 0x7FFFFFFF; pub const V1_RANGEMASK: i32 = 0x7FFFFFFF;
pub const MTIME_UNSET: i32 = -1; pub const MTIME_UNSET: i32 = -1;
/// A `DirstateEntry` with a size of `-2` means that it was merged from the /// A `DirstateEntry` with a size of `-2` means that it was merged from the
/// other parent. This allows revert to pick the right status back during a /// other parent. This allows revert to pick the right status back during a
/// merge. /// merge.
pub const SIZE_FROM_OTHER_PARENT: i32 = -2; pub const SIZE_FROM_OTHER_PARENT: i32 = -2;

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

pub(super) fn state( pub(super) fn state(
&self, &self,
) -> Result<Option<EntryState>, DirstateV2ParseError> { ) -> Result<Option<EntryState>, DirstateV2ParseError> {
Ok(self.entry()?.map(|e| e.state())) Ok(self.entry()?.map(|e| e.state()))
} }
pub(super) fn cached_directory_mtime( pub(super) fn cached_directory_mtime(
&self, &self,
) -> Option<&'tree on_disk::Timestamp> { ) -> Option<crate::dirstate::Timestamp> {
match self { match self {
NodeRef::InMemory(_path, node) => match &node.data { NodeRef::InMemory(_path, node) => match node.data {
NodeData::CachedDirectory { mtime } => Some(mtime), NodeData::CachedDirectory { mtime } => Some(mtime),
_ => None, _ => None,
}, },
NodeRef::OnDisk(node) => node.cached_directory_mtime(), NodeRef::OnDisk(node) => node.cached_directory_mtime(),
} }
} }
pub(super) fn descendants_with_entry_count(&self) -> u32 { pub(super) fn descendants_with_entry_count(&self) -> u32 {
/// How many (non-inclusive) descendants of this node have an entry whose /// How many (non-inclusive) descendants of this node have an entry whose
/// state is "tracked". /// state is "tracked".
pub(super) tracked_descendants_count: u32, pub(super) tracked_descendants_count: u32,
} }
pub(super) enum NodeData { pub(super) enum NodeData {
Entry(DirstateEntry), Entry(DirstateEntry),
CachedDirectory { mtime: on_disk::Timestamp }, CachedDirectory { mtime: crate::dirstate::Timestamp },
None, None,
} }
impl Default for NodeData { impl Default for NodeData {
fn default() -> Self { fn default() -> Self {
NodeData::None NodeData::None
} }
} }

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

//! The "version 2" disk representation of the dirstate //! The "version 2" disk representation of the dirstate
//! //!
//! See `mercurial/helptext/internals/dirstate-v2.txt` //! See `mercurial/helptext/internals/dirstate-v2.txt`
use crate::dirstate::Timestamp;
use crate::dirstate_tree::dirstate_map::{self, DirstateMap, NodeRef}; use crate::dirstate_tree::dirstate_map::{self, DirstateMap, NodeRef};
use crate::dirstate_tree::path_with_basename::WithBasename; use crate::dirstate_tree::path_with_basename::WithBasename;
use crate::errors::HgError; use crate::errors::HgError;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::DirstateEntry; use crate::DirstateEntry;
use crate::DirstateError; use crate::DirstateError;
use crate::DirstateParents; use crate::DirstateParents;
use bitflags::bitflags; use bitflags::bitflags;
use bytes_cast::unaligned::{I32Be, I64Be, U16Be, U32Be}; use bytes_cast::unaligned::{I32Be, I64Be, U16Be, U32Be};
use bytes_cast::BytesCast; use bytes_cast::BytesCast;
use format_bytes::format_bytes; use format_bytes::format_bytes;
use std::borrow::Cow; use std::borrow::Cow;
use std::convert::{TryFrom, TryInto}; use std::convert::{TryFrom, TryInto};
use std::time::{SystemTime, UNIX_EPOCH};
/// Added at the start of `.hg/dirstate` when the "v2" format is used. /// Added at the start of `.hg/dirstate` when the "v2" format is used.
/// This a redundant sanity check more than an actual "magic number" since /// This a redundant sanity check more than an actual "magic number" since
/// `.hg/requires` already governs which format should be used. /// `.hg/requires` already governs which format should be used.
pub const V2_FORMAT_MARKER: &[u8; 12] = b"dirstate-v2\n"; pub const V2_FORMAT_MARKER: &[u8; 12] = b"dirstate-v2\n";
/// Keep space for 256-bit hashes /// Keep space for 256-bit hashes
const STORED_NODE_ID_BYTES: usize = 32; const STORED_NODE_ID_BYTES: usize = 32;
#[repr(C)] #[repr(C)]
struct Entry { struct Entry {
mode: I32Be, mode: I32Be,
size: I32Be, size: I32Be,
mtime: I32Be, mtime: I32Be,
} }
/// Duration since the Unix epoch /// Duration since the Unix epoch
#[derive(BytesCast, Copy, Clone, PartialEq)] #[derive(BytesCast, Copy, Clone)]
#[repr(C)] #[repr(C)]
pub(super) struct Timestamp { struct PackedTimestamp {
seconds: I64Be, seconds: I64Be,
/// In `0 .. 1_000_000_000`. /// In `0 .. 1_000_000_000`.
/// ///
/// This timestamp is after `(seconds, 0)` by this many nanoseconds. /// This timestamp is after `(seconds, 0)` by this many nanoseconds.
nanoseconds: U32Be, nanoseconds: U32Be,
} }
) )
} }
pub(super) fn node_data( pub(super) fn node_data(
&self, &self,
) -> Result<dirstate_map::NodeData, DirstateV2ParseError> { ) -> Result<dirstate_map::NodeData, DirstateV2ParseError> {
if self.has_entry() { if self.has_entry() {
Ok(dirstate_map::NodeData::Entry(self.assume_entry())) Ok(dirstate_map::NodeData::Entry(self.assume_entry()))
} else if let Some(&mtime) = self.cached_directory_mtime() { } else if let Some(mtime) = self.cached_directory_mtime() {
Ok(dirstate_map::NodeData::CachedDirectory { mtime }) Ok(dirstate_map::NodeData::CachedDirectory { mtime })
} else { } else {
Ok(dirstate_map::NodeData::None) Ok(dirstate_map::NodeData::None)
} }
} }
pub(super) fn cached_directory_mtime(&self) -> Option<&Timestamp> { pub(super) fn cached_directory_mtime(&self) -> Option<Timestamp> {
if self.flags.contains(Flags::HAS_MTIME) && !self.has_entry() { if self.flags.contains(Flags::HAS_MTIME) && !self.has_entry() {
Some(self.data.as_timestamp()) Some(self.data.as_timestamp())
} else { } else {
None None
} }
} }
fn assume_entry(&self) -> DirstateEntry { fn assume_entry(&self) -> DirstateEntry {
mode: mode.into(), mode: mode.into(),
size: size.into(), size: size.into(),
mtime: mtime.into(), mtime: mtime.into(),
}; };
(flags, raw_entry) (flags, raw_entry)
} }
fn from_timestamp(timestamp: Timestamp) -> Self { fn from_timestamp(timestamp: Timestamp) -> Self {
let packed = PackedTimestamp {
seconds: timestamp.seconds().into(),
nanoseconds: timestamp.nanoseconds().into(),
};
// Safety: both types implement the `ByteCast` trait, so we could // Safety: both types implement the `ByteCast` trait, so we could
// safely use `as_bytes` and `from_bytes` to do this conversion. Using // safely use `as_bytes` and `from_bytes` to do this conversion. Using
// `transmute` instead makes the compiler check that the two types // `transmute` instead makes the compiler check that the two types
// have the same size, which eliminates the error case of // have the same size, which eliminates the error case of
// `from_bytes`. // `from_bytes`.
unsafe { std::mem::transmute::<Timestamp, Entry>(timestamp) } unsafe { std::mem::transmute::<PackedTimestamp, Entry>(packed) }
} }
fn as_timestamp(&self) -> &Timestamp { fn as_timestamp(self) -> Timestamp {
// Safety: same as above in `from_timestamp` // Safety: same as above in `from_timestamp`
unsafe { &*(self as *const Entry as *const Timestamp) } let packed =
} unsafe { std::mem::transmute::<Entry, PackedTimestamp>(self) };
} Timestamp::new(packed.seconds.get(), packed.nanoseconds.get())
impl Timestamp {
pub fn seconds(&self) -> i64 {
self.seconds.get()
}
}
impl From<SystemTime> for Timestamp {
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) {
Ok(duration) => {
(duration.as_secs() as i64, duration.subsec_nanos())
}
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_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)`:
const NSEC_PER_SEC: u32 = 1_000_000_000;
(-1 - negative_secs, NSEC_PER_SEC - negative_nanos)
}
}
};
Timestamp {
seconds: secs.into(),
nanoseconds: nanos.into(),
}
} }
} }
fn read_hg_path( fn read_hg_path(
on_disk: &[u8], on_disk: &[u8],
slice: PathSlice, slice: PathSlice,
) -> Result<&HgPath, DirstateV2ParseError> { ) -> Result<&HgPath, DirstateV2ParseError> {
read_slice(on_disk, slice.start, slice.len.get()).map(HgPath::new) read_slice(on_disk, slice.start, slice.len.get()).map(HgPath::new)

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

use crate::dirstate::entry::Timestamp;
use crate::dirstate::status::IgnoreFnType; use crate::dirstate::status::IgnoreFnType;
use crate::dirstate_tree::dirstate_map::BorrowedPath; use crate::dirstate_tree::dirstate_map::BorrowedPath;
use crate::dirstate_tree::dirstate_map::ChildNodesRef; use crate::dirstate_tree::dirstate_map::ChildNodesRef;
use crate::dirstate_tree::dirstate_map::DirstateMap; use crate::dirstate_tree::dirstate_map::DirstateMap;
use crate::dirstate_tree::dirstate_map::NodeData; use crate::dirstate_tree::dirstate_map::NodeData;
use crate::dirstate_tree::dirstate_map::NodeRef; use crate::dirstate_tree::dirstate_map::NodeRef;
use crate::dirstate_tree::on_disk::DirstateV2ParseError; use crate::dirstate_tree::on_disk::DirstateV2ParseError;
use crate::dirstate_tree::on_disk::Timestamp;
use crate::matchers::get_ignore_function; use crate::matchers::get_ignore_function;
use crate::matchers::Matcher; use crate::matchers::Matcher;
use crate::utils::files::get_bytes_from_os_string; use crate::utils::files::get_bytes_from_os_string;
use crate::utils::files::get_path_from_bytes; use crate::utils::files::get_path_from_bytes;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::BadMatch; use crate::BadMatch;
use crate::DirstateStatus; use crate::DirstateStatus;
use crate::EntryState; use crate::EntryState;
} }
/// If this returns true, we can get accurate results by only using /// If this returns true, we can get accurate results by only using
/// `symlink_metadata` for child nodes that exist in the dirstate and don’t /// `symlink_metadata` for child nodes that exist in the dirstate and don’t
/// need to call `read_dir`. /// need to call `read_dir`.
fn can_skip_fs_readdir( fn can_skip_fs_readdir(
&self, &self,
directory_metadata: Option<&std::fs::Metadata>, directory_metadata: Option<&std::fs::Metadata>,
cached_directory_mtime: Option<&Timestamp>, cached_directory_mtime: Option<Timestamp>,
) -> bool { ) -> bool {
if !self.options.list_unknown && !self.options.list_ignored { if !self.options.list_unknown && !self.options.list_ignored {
// All states that we care about listing have corresponding // All states that we care about listing have corresponding
// dirstate entries. // dirstate entries.
// This happens for example with `hg status -mard`. // This happens for example with `hg status -mard`.
return true; return true;
} }
if !self.options.list_ignored if !self.options.list_ignored
&& self.ignore_patterns_have_changed == Some(false) && self.ignore_patterns_have_changed == Some(false)
{ {
if let Some(cached_mtime) = cached_directory_mtime { if let Some(cached_mtime) = cached_directory_mtime {
// The dirstate contains a cached mtime for this directory, set // The dirstate contains a cached mtime for this directory, set
// by a previous run of the `status` algorithm which found this // by a previous run of the `status` algorithm which found this
// directory eligible for `read_dir` caching. // directory eligible for `read_dir` caching.
if let Some(meta) = directory_metadata { if let Some(meta) = directory_metadata {
if let Ok(current_mtime) = meta.modified() { if let Ok(current_mtime) = meta.modified() {
let current_mtime = Timestamp::from(current_mtime); let current_mtime = Timestamp::from(current_mtime);
if current_mtime == *cached_mtime { if current_mtime == cached_mtime {
// The mtime of that directory has not changed // The mtime of that directory has not changed
// since then, which means that the results of // since then, which means that the results of
// `read_dir` should also be unchanged. // `read_dir` should also be unchanged.
return true; return true;
} }
} }
} }
} }
} }
false false
} }
/// Returns whether all child entries of the filesystem directory have a /// Returns whether all child entries of the filesystem directory have a
/// corresponding dirstate node or are ignored. /// corresponding dirstate node or are ignored.
fn traverse_fs_directory_and_dirstate( fn traverse_fs_directory_and_dirstate(
&self, &self,
has_ignored_ancestor: bool, has_ignored_ancestor: bool,
dirstate_nodes: ChildNodesRef<'tree, 'on_disk>, dirstate_nodes: ChildNodesRef<'tree, 'on_disk>,
directory_hg_path: &BorrowedPath<'tree, 'on_disk>, directory_hg_path: &BorrowedPath<'tree, 'on_disk>,
directory_fs_path: &Path, directory_fs_path: &Path,
directory_metadata: Option<&std::fs::Metadata>, directory_metadata: Option<&std::fs::Metadata>,
cached_directory_mtime: Option<&Timestamp>, cached_directory_mtime: Option<Timestamp>,
is_at_repo_root: bool, is_at_repo_root: bool,
) -> Result<bool, DirstateV2ParseError> { ) -> Result<bool, DirstateV2ParseError> {
if self.can_skip_fs_readdir(directory_metadata, cached_directory_mtime) if self.can_skip_fs_readdir(directory_metadata, cached_directory_mtime)
{ {
dirstate_nodes dirstate_nodes
.par_iter() .par_iter()
.map(|dirstate_node| { .map(|dirstate_node| {
let fs_path = directory_fs_path.join(get_path_from_bytes( let fs_path = directory_fs_path.join(get_path_from_bytes(
// backward to some point before `directory_mtime`, then a // backward to some point before `directory_mtime`, then a
// directory change could potentially happen during exactly // directory change could potentially happen during exactly
// the wrong tick. // the wrong tick.
// //
// We deem this scenario (unlike the previous one) to be // We deem this scenario (unlike the previous one) to be
// unlikely enough in practice. // unlikely enough in practice.
let timestamp = directory_mtime.into(); let timestamp = directory_mtime.into();
let cached = dirstate_node.cached_directory_mtime(); let cached = dirstate_node.cached_directory_mtime();
if cached != Some(&timestamp) { if cached != Some(timestamp) {
let hg_path = dirstate_node let hg_path = dirstate_node
.full_path_borrowed(self.dmap.on_disk)? .full_path_borrowed(self.dmap.on_disk)?
.detach_from_tree(); .detach_from_tree();
self.new_cachable_directories self.new_cachable_directories
.lock() .lock()
.unwrap() .unwrap()
.push((hg_path, timestamp)) .push((hg_path, timestamp))
} }