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
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

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 30753

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))
} }