( )⚙ D11634 dirstate-v2: Store unsigned integers inside DirstateEntry

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
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: 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 30722

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)