This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11634

dirstate-v2: Store unsigned integers inside DirstateEntry
ClosedPublic

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

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG1000db4a71f1: dirstate-v2: Store unsigned integers inside DirstateEntry
Summary

The negative marker values are not used anymore.

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: rHG1000db4a71f1: dirstate-v2: Store unsigned integers inside DirstateEntry.Oct 12 2021, 2:03 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG1000db4a71f1: dirstate-v2: Store unsigned integers inside DirstateEntry (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 30755

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

} }
/// The C implementation uses all signed types. This will be an issue /// The C implementation uses all signed types. This will be an issue
/// either when 4GB+ source files are commonplace or in 2038, whichever /// either when 4GB+ source files are commonplace or in 2038, whichever
/// comes first. /// comes first.
#[derive(Debug, PartialEq, Copy, Clone)] #[derive(Debug, PartialEq, Copy, Clone)]
pub struct DirstateEntry { pub struct DirstateEntry {
pub(crate) flags: Flags, pub(crate) flags: Flags,
mode_size: Option<(i32, i32)>, mode_size: Option<(u32, u32)>,
mtime: Option<i32>, mtime: Option<u32>,
} }
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;
} }
/// dirstate v1 format. /// dirstate v1 format.
pub const SIZE_NON_NORMAL: i32 = -1; pub const SIZE_NON_NORMAL: i32 = -1;
impl DirstateEntry { impl DirstateEntry {
pub fn from_v2_data( pub fn from_v2_data(
wdir_tracked: bool, wdir_tracked: bool,
p1_tracked: bool, p1_tracked: bool,
p2_info: bool, p2_info: bool,
mode_size: Option<(i32, i32)>, mode_size: Option<(u32, u32)>,
mtime: Option<i32>, mtime: Option<u32>,
) -> Self { ) -> Self {
if let Some((mode, size)) = mode_size {
// TODO: return an error for out of range values?
assert!(mode & !RANGE_MASK_31BIT == 0);
assert!(size & !RANGE_MASK_31BIT == 0);
}
if let Some(mtime) = mtime {
assert!(mtime & !RANGE_MASK_31BIT == 0);
}
let mut flags = Flags::empty(); let mut flags = Flags::empty();
flags.set(Flags::WDIR_TRACKED, wdir_tracked); flags.set(Flags::WDIR_TRACKED, wdir_tracked);
flags.set(Flags::P1_TRACKED, p1_tracked); flags.set(Flags::P1_TRACKED, p1_tracked);
flags.set(Flags::P2_INFO, p2_info); flags.set(Flags::P2_INFO, p2_info);
Self { Self {
flags, flags,
mode_size, mode_size,
mtime, mtime,
} }
} else if size == SIZE_NON_NORMAL { } else if size == SIZE_NON_NORMAL {
Self { Self {
flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED, flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
mode_size: None, mode_size: None,
mtime: None, mtime: None,
} }
} else if mtime == MTIME_UNSET { } else if mtime == MTIME_UNSET {
// TODO:!return an error for negative values?
let mode = u32::try_from(mode).unwrap();
let size = u32::try_from(size).unwrap();
Self { Self {
flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED, flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
mode_size: Some((mode, size)), mode_size: Some((mode, size)),
mtime: None, mtime: None,
} }
} else { } else {
// TODO:!return an error for negative values?
let mode = u32::try_from(mode).unwrap();
let size = u32::try_from(size).unwrap();
let mtime = u32::try_from(mtime).unwrap();
Self { Self {
flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED, flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
mode_size: Some((mode, size)), mode_size: Some((mode, size)),
mtime: Some(mtime), mtime: Some(mtime),
} }
} }
} }
EntryState::Added => Self { EntryState::Added => Self {
self.flags.intersects( self.flags.intersects(
Flags::WDIR_TRACKED | Flags::P1_TRACKED | Flags::P2_INFO, Flags::WDIR_TRACKED | Flags::P1_TRACKED | Flags::P2_INFO,
) )
} }
/// Returns `(wdir_tracked, p1_tracked, p2_info, mode_size, mtime)` /// Returns `(wdir_tracked, p1_tracked, p2_info, mode_size, mtime)`
pub(crate) fn v2_data( pub(crate) fn v2_data(
&self, &self,
) -> (bool, bool, bool, Option<(i32, i32)>, Option<i32>) { ) -> (bool, bool, bool, Option<(u32, u32)>, Option<u32>) {
if !self.any_tracked() { if !self.any_tracked() {
// TODO: return an Option instead? // TODO: return an Option instead?
panic!("Accessing v1_state of an untracked DirstateEntry") panic!("Accessing v1_state of an untracked DirstateEntry")
} }
let wdir_tracked = self.flags.contains(Flags::WDIR_TRACKED); let wdir_tracked = self.flags.contains(Flags::WDIR_TRACKED);
let p1_tracked = self.flags.contains(Flags::P1_TRACKED); let p1_tracked = self.flags.contains(Flags::P1_TRACKED);
let p2_info = self.flags.contains(Flags::P2_INFO); let p2_info = self.flags.contains(Flags::P2_INFO);
let mode_size = self.mode_size; let mode_size = self.mode_size;
EntryState::Added EntryState::Added
} else { } else {
EntryState::Normal EntryState::Normal
} }
} }
fn v1_mode(&self) -> i32 { fn v1_mode(&self) -> i32 {
if let Some((mode, _size)) = self.mode_size { if let Some((mode, _size)) = self.mode_size {
mode i32::try_from(mode).unwrap()
} else { } else {
0 0
} }
} }
fn v1_size(&self) -> i32 { fn v1_size(&self) -> i32 {
if !self.any_tracked() { if !self.any_tracked() {
// TODO: return an Option instead? // TODO: return an Option instead?
panic!("Accessing v1_size of an untracked DirstateEntry") panic!("Accessing v1_size of an untracked DirstateEntry")
} }
if self.removed() if self.removed()
&& self.flags.contains(Flags::P1_TRACKED | Flags::P2_INFO) && self.flags.contains(Flags::P1_TRACKED | Flags::P2_INFO)
{ {
SIZE_NON_NORMAL SIZE_NON_NORMAL
} else if self.flags.contains(Flags::P2_INFO) { } else if self.flags.contains(Flags::P2_INFO) {
SIZE_FROM_OTHER_PARENT SIZE_FROM_OTHER_PARENT
} else if self.removed() { } else if self.removed() {
0 0
} else if self.added() { } else if self.added() {
SIZE_NON_NORMAL SIZE_NON_NORMAL
} else if let Some((_mode, size)) = self.mode_size { } else if let Some((_mode, size)) = self.mode_size {
size i32::try_from(size).unwrap()
} else { } else {
SIZE_NON_NORMAL SIZE_NON_NORMAL
} }
} }
fn v1_mtime(&self) -> i32 { fn v1_mtime(&self) -> i32 {
if !self.any_tracked() { if !self.any_tracked() {
// TODO: return an Option instead? // TODO: return an Option instead?
panic!("Accessing v1_mtime of an untracked DirstateEntry") panic!("Accessing v1_mtime of an untracked DirstateEntry")
} }
if self.removed() { if self.removed() {
0 0
} else if self.flags.contains(Flags::P2_INFO) { } else if self.flags.contains(Flags::P2_INFO) {
MTIME_UNSET MTIME_UNSET
} else if !self.flags.contains(Flags::P1_TRACKED) { } else if !self.flags.contains(Flags::P1_TRACKED) {
MTIME_UNSET MTIME_UNSET
} else if let Some(mtime) = self.mtime {
i32::try_from(mtime).unwrap()
} else { } else {
self.mtime.unwrap_or(MTIME_UNSET) MTIME_UNSET
} }
} }
// TODO: return `Option<EntryState>`? None when `!self.any_tracked` // TODO: return `Option<EntryState>`? None when `!self.any_tracked`
pub fn state(&self) -> EntryState { pub fn state(&self) -> EntryState {
self.v1_state() self.v1_state()
} }
self.mtime = None; self.mtime = None;
} }
} }
pub fn set_possibly_dirty(&mut self) { pub fn set_possibly_dirty(&mut self) {
self.mtime = None self.mtime = None
} }
pub fn set_clean(&mut self, mode: i32, size: i32, mtime: i32) { pub fn set_clean(&mut self, mode: u32, size: u32, mtime: u32) {
let size = size & RANGE_MASK_31BIT;
let mtime = mtime & RANGE_MASK_31BIT;
self.flags.insert(Flags::WDIR_TRACKED | Flags::P1_TRACKED); self.flags.insert(Flags::WDIR_TRACKED | Flags::P1_TRACKED);
self.mode_size = Some((mode, size)); self.mode_size = Some((mode, size));
self.mtime = Some(mtime); self.mtime = Some(mtime);
} }
pub fn set_tracked(&mut self) { pub fn set_tracked(&mut self) {
self.flags.insert(Flags::WDIR_TRACKED); self.flags.insert(Flags::WDIR_TRACKED);
// `set_tracked` is replacing various `normallookup` call. So we mark // `set_tracked` is replacing various `normallookup` call. So we mark

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::TruncatedTimestamp; use crate::dirstate::TruncatedTimestamp;
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, U16Be, U32Be}; use bytes_cast::unaligned::{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};
/// 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.
const HAS_MODE_AND_SIZE = 1 << 3; const HAS_MODE_AND_SIZE = 1 << 3;
const HAS_MTIME = 1 << 4; const HAS_MTIME = 1 << 4;
} }
} }
#[derive(BytesCast, Copy, Clone, Debug)] #[derive(BytesCast, Copy, Clone, Debug)]
#[repr(C)] #[repr(C)]
struct Entry { struct Entry {
mode: I32Be, mode: U32Be,
size: I32Be, size: U32Be,
mtime: I32Be, mtime: U32Be,
} }
/// Duration since the Unix epoch /// Duration since the Unix epoch
#[derive(BytesCast, Copy, Clone)] #[derive(BytesCast, Copy, Clone)]
#[repr(C)] #[repr(C)]
struct PackedTimestamp { struct PackedTimestamp {
_padding: U32Be, _padding: U32Be,
truncated_seconds: U32Be, truncated_seconds: U32Be,

rust/hg-cpython/src/dirstate/item.rs

def __new__( def __new__(
_cls, _cls,
wc_tracked: bool = false, wc_tracked: bool = false,
p1_tracked: bool = false, p1_tracked: bool = false,
p2_info: bool = false, p2_info: bool = false,
has_meaningful_data: bool = true, has_meaningful_data: bool = true,
has_meaningful_mtime: bool = true, has_meaningful_mtime: bool = true,
parentfiledata: Option<(i32, i32, i32)> = None, parentfiledata: Option<(u32, u32, u32)> = None,
) -> PyResult<DirstateItem> { ) -> PyResult<DirstateItem> {
let mut mode_size_opt = None; let mut mode_size_opt = None;
let mut mtime_opt = None; let mut mtime_opt = None;
if let Some((mode, size, mtime)) = parentfiledata { if let Some((mode, size, mtime)) = parentfiledata {
if has_meaningful_data { if has_meaningful_data {
mode_size_opt = Some((mode, size)) mode_size_opt = Some((mode, size))
} }
def drop_merge_data(&self) -> PyResult<PyNone> { def drop_merge_data(&self) -> PyResult<PyNone> {
self.update(py, |entry| entry.drop_merge_data()); self.update(py, |entry| entry.drop_merge_data());
Ok(PyNone) Ok(PyNone)
} }
def set_clean( def set_clean(
&self, &self,
mode: i32, mode: u32,
size: i32, size: u32,
mtime: i32, mtime: u32,
) -> PyResult<PyNone> { ) -> PyResult<PyNone> {
self.update(py, |entry| entry.set_clean(mode, size, mtime)); self.update(py, |entry| entry.set_clean(mode, size, mtime));
Ok(PyNone) Ok(PyNone)
} }
def set_possibly_dirty(&self) -> PyResult<PyNone> { def set_possibly_dirty(&self) -> PyResult<PyNone> {
self.update(py, |entry| entry.set_possibly_dirty()); self.update(py, |entry| entry.set_possibly_dirty());
Ok(PyNone) Ok(PyNone)