( )⚙ D11099 dirstate-v2: Separate iterators for dirfoldmap and debugdirstate

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11099

dirstate-v2: Separate iterators for dirfoldmap and debugdirstate
ClosedPublic

Authored by SimonSapin on Jul 16 2021, 8:37 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG284a20269a97: dirstate-v2: Separate iterators for dirfoldmap and debugdirstate
Summary

dirstatemap.dirfoldmap was recently changed to re-use a Rust iterator
that was added for the hg debugdirstate command.

That iterator was based on all nodes in the tree dirstate without an entry
only existing to hold child nodes, and therefore being directories.
However to optimize status further we may want to store additional nodes
for unknown or ignored files and directories. At that point the two users
of this iterator will want different things, so let’s make two iterators
instead.

See doc-comments in dispatch.rs.

Diff Detail

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

Event Timeline

SimonSapin created this revision.Jul 16 2021, 8:37 AM
Alphare accepted this revision.Jul 16 2021, 9:40 AM
This revision is now accepted and ready to land.Jul 16 2021, 9:40 AM
baymax updated this revision to Diff 29356.Jul 16 2021, 5:45 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 29615.Jul 20 2021, 3:42 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Revision Contents
Changeset List

Diff 29339

mercurial/debugcommands.py

( (
b'', b'',
b'nodates', b'nodates',
None, None,
_(b'do not display the saved mtime (DEPRECATED)'), _(b'do not display the saved mtime (DEPRECATED)'),
), ),
(b'', b'dates', True, _(b'display the saved mtime')), (b'', b'dates', True, _(b'display the saved mtime')),
(b'', b'datesort', None, _(b'sort by saved mtime')), (b'', b'datesort', None, _(b'sort by saved mtime')),
(b'', b'dirs', False, _(b'display directories')), (b'', b'all', False, _(b'display dirstate-v2 tree nodes that would not exist in v1')),
], ],
_(b'[OPTION]...'), _(b'[OPTION]...'),
) )
def debugstate(ui, repo, **opts): def debugstate(ui, repo, **opts):
"""show the contents of the current dirstate""" """show the contents of the current dirstate"""
nodates = not opts['dates'] nodates = not opts['dates']
if opts.get('nodates') is not None: if opts.get('nodates') is not None:
nodates = True nodates = True
datesort = opts.get('datesort') datesort = opts.get('datesort')
if datesort: if datesort:
keyfunc = lambda x: ( keyfunc = lambda x: (
x[1].v1_mtime(), x[1].v1_mtime(),
x[0], x[0],
) # sort by mtime, then by filename ) # sort by mtime, then by filename
else: else:
keyfunc = None # sort by filename keyfunc = None # sort by filename
if opts['all']:
entries = list(repo.dirstate._map.debug_iter())
else:
entries = list(pycompat.iteritems(repo.dirstate)) entries = list(pycompat.iteritems(repo.dirstate))
if opts['dirs']:
entries.extend(repo.dirstate.directories())
entries.sort(key=keyfunc) entries.sort(key=keyfunc)
for file_, ent in entries: for file_, ent in entries:
if ent.v1_mtime() == -1: if ent.v1_mtime() == -1:
timestr = b'unset ' timestr = b'unset '
elif nodates: elif nodates:
timestr = b'set ' timestr = b'set '
else: else:
timestr = time.strftime( timestr = time.strftime(

mercurial/dirstatemap.py

return self._map return self._map
@propertycache @propertycache
def copymap(self): def copymap(self):
self.copymap = {} self.copymap = {}
self._map self._map
return self.copymap return self.copymap
def directories(self):
# Rust / dirstate-v2 only
return []
def clear(self): def clear(self):
self._map.clear() self._map.clear()
self.copymap.clear() self.copymap.clear()
self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid) self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid)
util.clearcachedproperty(self, b"_dirs") util.clearcachedproperty(self, b"_dirs")
util.clearcachedproperty(self, b"_alldirs") util.clearcachedproperty(self, b"_alldirs")
util.clearcachedproperty(self, b"filefoldmap") util.clearcachedproperty(self, b"filefoldmap")
util.clearcachedproperty(self, b"dirfoldmap") util.clearcachedproperty(self, b"dirfoldmap")
util.clearcachedproperty(self, b"nonnormalset") util.clearcachedproperty(self, b"nonnormalset")
util.clearcachedproperty(self, b"otherparentset") util.clearcachedproperty(self, b"otherparentset")
def items(self): def items(self):
return pycompat.iteritems(self._map) return pycompat.iteritems(self._map)
# forward for python2,3 compat # forward for python2,3 compat
iteritems = items iteritems = items
debug_iter = items
def __len__(self): def __len__(self):
return len(self._map) return len(self._map)
def __iter__(self): def __iter__(self):
return iter(self._map) return iter(self._map)
def get(self, key, default=None): def get(self, key, default=None):
return self._map.get(key, default) return self._map.get(key, default)
@property @property
def copymap(self): def copymap(self):
return self._rustmap.copymap() return self._rustmap.copymap()
def directories(self): def directories(self):
return self._rustmap.directories() return self._rustmap.directories()
def debug_iter(self):
return self._rustmap.debug_iter()
def preload(self): def preload(self):
self._rustmap self._rustmap
def clear(self): def clear(self):
self._rustmap.clear() self._rustmap.clear()
self.setparents( self.setparents(
self._nodeconstants.nullid, self._nodeconstants.nullid self._nodeconstants.nullid, self._nodeconstants.nullid
) )
def non_normal_or_other_parent_paths(self): def non_normal_or_other_parent_paths(self):
return self._rustmap.non_normal_or_other_parent_paths() return self._rustmap.non_normal_or_other_parent_paths()
@propertycache @propertycache
def dirfoldmap(self): def dirfoldmap(self):
f = {} f = {}
normcase = util.normcase normcase = util.normcase
for name, _pseudo_entry in self.directories(): for name in self._rustmap.tracked_dirs():
f[normcase(name)] = name f[normcase(name)] = name
return f return f

rust/hg-core/src/dirstate.rs

filesystem_metadata: &std::fs::Metadata, filesystem_metadata: &std::fs::Metadata,
) -> bool { ) -> bool {
use std::os::unix::fs::MetadataExt; use std::os::unix::fs::MetadataExt;
const EXEC_BIT_MASK: u32 = 0o100; const EXEC_BIT_MASK: u32 = 0o100;
let dirstate_exec_bit = (self.mode as u32) & EXEC_BIT_MASK; let dirstate_exec_bit = (self.mode as u32) & EXEC_BIT_MASK;
let fs_exec_bit = filesystem_metadata.mode() & EXEC_BIT_MASK; let fs_exec_bit = filesystem_metadata.mode() & EXEC_BIT_MASK;
dirstate_exec_bit != fs_exec_bit dirstate_exec_bit != fs_exec_bit
} }
/// Returns a `(state, mode, size, mtime)` tuple as for
/// `DirstateMapMethods::debug_iter`.
pub fn debug_tuple(&self) -> (u8, i32, i32, i32) {
(self.state.into(), self.mode, self.size, self.mtime)
}
} }
#[derive(BytesCast)] #[derive(BytesCast)]
#[repr(C)] #[repr(C)]
struct RawEntry { struct RawEntry {
state: u8, state: u8,
mode: unaligned::I32Be, mode: unaligned::I32Be,
size: unaligned::I32Be, size: unaligned::I32Be,

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

Ok(if let Some(entry) = node.entry()? { Ok(if let Some(entry) = node.entry()? {
Some((node.full_path(self.on_disk)?, entry)) Some((node.full_path(self.on_disk)?, entry))
} else { } else {
None None
}) })
})) }))
} }
fn iter_directories( fn iter_tracked_dirs(
&mut self,
) -> Result<
Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>>
+ Send
+ '_,
>,
DirstateError,
> {
let on_disk = self.on_disk;
Ok(Box::new(filter_map_results(
self.iter_nodes(),
move |node| {
Ok(if node.tracked_descendants_count() > 0 {
Some(node.full_path(on_disk)?)
} else {
None
})
},
)))
}
fn debug_iter(
&self, &self,
) -> Box< ) -> Box<
dyn Iterator< dyn Iterator<
Item = Result< Item = Result<
(&HgPath, Option<Timestamp>), (&HgPath, (u8, i32, i32, i32)),
DirstateV2ParseError, DirstateV2ParseError,
>, >,
> + Send > + Send
+ '_, + '_,
> { > {
Box::new(filter_map_results(self.iter_nodes(), move |node| { Box::new(self.iter_nodes().map(move |node| {
Ok(if node.state()?.is_none() { let node = node?;
Some(( let debug_tuple = if let Some(entry) = node.entry()? {
node.full_path(self.on_disk)?, entry.debug_tuple()
node.cached_directory_mtime() } else if let Some(mtime) = node.cached_directory_mtime() {
.map(|mtime| Timestamp(mtime.seconds())), (b' ', 0, -1, mtime.seconds() as i32)
))
} else { } else {
None (b' ', 0, -1, -1)
}) };
Ok((node.full_path(self.on_disk)?, debug_tuple))
})) }))
} }
} }

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

) -> Result<Option<DirstateEntry>, DirstateV2ParseError>; ) -> Result<Option<DirstateEntry>, DirstateV2ParseError>;
/// Returns a `(path, entry)` iterator of files that have an entry. /// Returns a `(path, entry)` iterator of files that have an entry.
/// ///
/// Because parse errors can happen during iteration, the iterated items /// Because parse errors can happen during iteration, the iterated items
/// are `Result`s. /// are `Result`s.
fn iter(&self) -> StateMapIter<'_>; fn iter(&self) -> StateMapIter<'_>;
/// In the tree dirstate, return an iterator of "directory" (entry-less) /// Returns an iterator of tracked directories.
/// nodes with the data stored for them. This is for `hg debugdirstate
/// --dirs`.
/// ///
/// In the flat dirstate, returns an empty iterator. /// This is the paths for which `has_tracked_dir` would return true.
/// Or, in other words, the union of ancestor paths of all paths that have
/// an associated entry in a "tracked" state in this dirstate map.
/// ///
/// Because parse errors can happen during iteration, the iterated items /// Because parse errors can happen during iteration, the iterated items
/// are `Result`s. /// are `Result`s.
fn iter_directories( fn iter_tracked_dirs(
&mut self,
) -> Result<
Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>>
+ Send
+ '_,
>,
DirstateError,
>;
/// Return an iterator of `(path, (state, mode, size, mtime))` for every
/// node stored in this dirstate map, for the purpose of the `hg
/// debugdirstate` command.
///
/// For nodes that don’t have an entry, `state` is the ASCII space.
/// An `mtime` may still be present. It is used to optimize `status`.
///
/// Because parse errors can happen during iteration, the iterated items
/// are `Result`s.
fn debug_iter(
&self, &self,
) -> Box< ) -> Box<
dyn Iterator< dyn Iterator<
Item = Result< Item = Result<
(&HgPath, Option<Timestamp>), (&HgPath, (u8, i32, i32, i32)),
DirstateV2ParseError, DirstateV2ParseError,
>, >,
> + Send > + Send
+ '_, + '_,
>; >;
} }
impl DirstateMapMethods for DirstateMap { impl DirstateMapMethods for DirstateMap {
) -> Result<Option<DirstateEntry>, DirstateV2ParseError> { ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
Ok((&**self).get(key).cloned()) Ok((&**self).get(key).cloned())
} }
fn iter(&self) -> StateMapIter<'_> { fn iter(&self) -> StateMapIter<'_> {
Box::new((&**self).iter().map(|(key, value)| Ok((&**key, *value)))) Box::new((&**self).iter().map(|(key, value)| Ok((&**key, *value))))
} }
fn iter_directories( fn iter_tracked_dirs(
&mut self,
) -> Result<
Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>>
+ Send
+ '_,
>,
DirstateError,
> {
self.set_all_dirs()?;
Ok(Box::new(
self.all_dirs
.as_ref()
.unwrap()
.iter()
.map(|path| Ok(&**path)),
))
}
fn debug_iter(
&self, &self,
) -> Box< ) -> Box<
dyn Iterator< dyn Iterator<
Item = Result< Item = Result<
(&HgPath, Option<Timestamp>), (&HgPath, (u8, i32, i32, i32)),
DirstateV2ParseError, DirstateV2ParseError,
>, >,
> + Send > + Send
+ '_, + '_,
> { > {
Box::new(std::iter::empty()) Box::new(
(&**self)
.iter()
.map(|(path, entry)| Ok((&**path, entry.debug_tuple()))),
)
} }
} }

rust/hg-cpython/src/dirstate.rs

mtime: c_int, mtime: c_int,
) -> *mut RawPyObject ) -> *mut RawPyObject
); );
pub fn make_dirstate_item( pub fn make_dirstate_item(
py: Python, py: Python,
entry: &DirstateEntry, entry: &DirstateEntry,
) -> PyResult<PyObject> { ) -> PyResult<PyObject> {
// might be silly to retrieve capsule function in hot loop
let make = make_dirstate_item_capi::retrieve(py)?;
let &DirstateEntry { let &DirstateEntry {
state, state,
mode, mode,
size, size,
mtime, mtime,
} = entry; } = entry;
// Explicitly go through u8 first, then cast to platform-specific `c_char` // Explicitly go through u8 first, then cast to platform-specific `c_char`
// because Into<u8> has a specific implementation while `as c_char` would // because Into<u8> has a specific implementation while `as c_char` would
// just do a naive enum cast. // just do a naive enum cast.
let state_code: u8 = state.into(); let state_code: u8 = state.into();
make_dirstate_item_raw(py, state_code, mode, size, mtime)
let maybe_obj = unsafe {
let ptr = make(state_code as c_char, mode, size, mtime);
PyObject::from_owned_ptr_opt(py, ptr)
};
maybe_obj.ok_or_else(|| PyErr::fetch(py))
} }
// XXX a bit strange to have a dedicated function, but directory are not pub fn make_dirstate_item_raw(
// treated as dirstate node by hg-core for now so… py: Python,
pub fn make_directory_item(py: Python, mtime: i32) -> PyResult<PyObject> { state: u8,
// might be silly to retrieve capsule function in hot loop mode: i32,
size: i32,
mtime: i32,
) -> PyResult<PyObject> {
let make = make_dirstate_item_capi::retrieve(py)?; let make = make_dirstate_item_capi::retrieve(py)?;
let maybe_obj = unsafe { let maybe_obj = unsafe {
let ptr = make(b'd' as c_char, 0 as i32, 0 as i32, mtime); let ptr = make(state as c_char, mode, size, mtime);
PyObject::from_owned_ptr_opt(py, ptr) PyObject::from_owned_ptr_opt(py, ptr)
}; };
maybe_obj.ok_or_else(|| PyErr::fetch(py)) maybe_obj.ok_or_else(|| PyErr::fetch(py))
} }
pub fn extract_dirstate(py: Python, dmap: &PyDict) -> Result<StateMap, PyErr> { pub fn extract_dirstate(py: Python, dmap: &PyDict) -> Result<StateMap, PyErr> {
dmap.items(py) dmap.items(py)
.iter() .iter()

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

use cpython::{ use cpython::{
exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList, exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyList,
PyObject, PyResult, PySet, PyString, Python, PythonObject, ToPyObject, PyObject, PyResult, PySet, PyString, Python, PythonObject, ToPyObject,
UnsafePyLeaked, UnsafePyLeaked,
}; };
use crate::{ use crate::{
dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator}, dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
dirstate::make_directory_item,
dirstate::make_dirstate_item, dirstate::make_dirstate_item,
dirstate::make_dirstate_item_raw,
dirstate::non_normal_entries::{ dirstate::non_normal_entries::{
NonNormalEntries, NonNormalEntriesIterator, NonNormalEntries, NonNormalEntriesIterator,
}, },
dirstate::owning::OwningDirstateMap, dirstate::owning::OwningDirstateMap,
parsers::dirstate_parents_to_pytuple, parsers::dirstate_parents_to_pytuple,
}; };
use hg::{ use hg::{
dirstate::parsers::Timestamp, dirstate::parsers::Timestamp,
@shared data inner: Box<dyn DirstateMapMethods + Send>; @shared data inner: Box<dyn DirstateMapMethods + Send>;
/// Returns a `(dirstate_map, parents)` tuple /// Returns a `(dirstate_map, parents)` tuple
@staticmethod @staticmethod
def new_v1( def new_v1(
use_dirstate_tree: bool, use_dirstate_tree: bool,
on_disk: PyBytes, on_disk: PyBytes,
) -> PyResult<PyObject> { ) -> PyResult<PyObject> {
let dirstate_error = |e: DirstateError| {
PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e))
};
let (inner, parents) = if use_dirstate_tree { let (inner, parents) = if use_dirstate_tree {
let (map, parents) = OwningDirstateMap::new_v1(py, on_disk) let (map, parents) = OwningDirstateMap::new_v1(py, on_disk)
.map_err(dirstate_error)?; .map_err(|e| dirstate_error(py, e))?;
(Box::new(map) as _, parents) (Box::new(map) as _, parents)
} else { } else {
let bytes = on_disk.data(py); let bytes = on_disk.data(py);
let mut map = RustDirstateMap::default(); let mut map = RustDirstateMap::default();
let parents = map.read(bytes).map_err(dirstate_error)?; let parents = map.read(bytes).map_err(|e| dirstate_error(py, e))?;
(Box::new(map) as _, parents) (Box::new(map) as _, parents)
}; };
let map = Self::create_instance(py, inner)?; let map = Self::create_instance(py, inner)?;
let parents = parents.map(|p| dirstate_parents_to_pytuple(py, &p)); let parents = parents.map(|p| dirstate_parents_to_pytuple(py, &p));
Ok((map, parents).to_py_object(py).into_object()) Ok((map, parents).to_py_object(py).into_object())
} }
/// Returns a DirstateMap /// Returns a DirstateMap
def copymapitemsiter(&self) -> PyResult<CopyMapItemsIterator> { def copymapitemsiter(&self) -> PyResult<CopyMapItemsIterator> {
let leaked_ref = self.inner(py).leak_immutable(); let leaked_ref = self.inner(py).leak_immutable();
CopyMapItemsIterator::from_inner( CopyMapItemsIterator::from_inner(
py, py,
unsafe { leaked_ref.map(py, |o| o.copy_map_iter()) }, unsafe { leaked_ref.map(py, |o| o.copy_map_iter()) },
) )
} }
def directories(&self) -> PyResult<PyList> { def tracked_dirs(&self) -> PyResult<PyList> {
let dirs = PyList::new(py, &[]); let dirs = PyList::new(py, &[]);
for item in self.inner(py).borrow().iter_directories() { for path in self.inner(py).borrow_mut().iter_tracked_dirs()
let (path, mtime) = item.map_err(|e| v2_error(py, e))?; .map_err(|e |dirstate_error(py, e))?
{
let path = path.map_err(|e| v2_error(py, e))?;
let path = PyBytes::new(py, path.as_bytes()); let path = PyBytes::new(py, path.as_bytes());
let mtime = mtime.map(|t| t.0).unwrap_or(-1); dirs.append(py, path.into_object())
let item = make_directory_item(py, mtime as i32)?;
let tuple = (path, item);
dirs.append(py, tuple.to_py_object(py).into_object())
} }
Ok(dirs) Ok(dirs)
} }
def debug_iter(&self) -> PyResult<PyList> {
let dirs = PyList::new(py, &[]);
for item in self.inner(py).borrow().debug_iter() {
let (path, (state, mode, size, mtime)) =
item.map_err(|e| v2_error(py, e))?;
let path = PyBytes::new(py, path.as_bytes());
let item = make_dirstate_item_raw(py, state, mode, size, mtime)?;
dirs.append(py, (path, item).to_py_object(py).into_object())
}
Ok(dirs)
}
}); });
impl DirstateMap { impl DirstateMap {
pub fn get_inner_mut<'a>( pub fn get_inner_mut<'a>(
&'a self, &'a self,
py: Python<'a>, py: Python<'a>,
) -> RefMut<'a, Box<dyn DirstateMapMethods + Send>> { ) -> RefMut<'a, Box<dyn DirstateMapMethods + Send>> {
self.inner(py).borrow_mut() self.inner(py).borrow_mut()
Ok(s) => Ok(s), Ok(s) => Ok(s),
Err(e) => Err(PyErr::new::<exc::ValueError, _>(py, e.to_string())), Err(e) => Err(PyErr::new::<exc::ValueError, _>(py, e.to_string())),
} }
} }
pub(super) fn v2_error(py: Python<'_>, _: DirstateV2ParseError) -> PyErr { pub(super) fn v2_error(py: Python<'_>, _: DirstateV2ParseError) -> PyErr {
PyErr::new::<exc::ValueError, _>(py, "corrupted dirstate-v2") PyErr::new::<exc::ValueError, _>(py, "corrupted dirstate-v2")
} }
fn dirstate_error(py: Python<'_>, e: DirstateError) -> PyErr {
PyErr::new::<exc::OSError, _>(py, format!("Dirstate error: {:?}", e))
}

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

) -> Result<Option<DirstateEntry>, DirstateV2ParseError> { ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
self.get().get(key) self.get().get(key)
} }
fn iter(&self) -> StateMapIter<'_> { fn iter(&self) -> StateMapIter<'_> {
self.get().iter() self.get().iter()
} }
fn iter_directories( fn iter_tracked_dirs(
&mut self,
) -> Result<
Box<
dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>>
+ Send
+ '_,
>,
DirstateError,
> {
self.get_mut().iter_tracked_dirs()
}
fn debug_iter(
&self, &self,
) -> Box< ) -> Box<
dyn Iterator< dyn Iterator<
Item = Result< Item = Result<
(&HgPath, Option<Timestamp>), (&HgPath, (u8, i32, i32, i32)),
DirstateV2ParseError, DirstateV2ParseError,
>, >,
> + Send > + Send
+ '_, + '_,
> { > {
self.get().iter_directories() self.get().debug_iter()
} }
} }

tests/test-completion.t

debugcommands: debugcommands:
debugcomplete: options debugcomplete: options
debugcreatestreamclonebundle: debugcreatestreamclonebundle:
debugdag: tags, branches, dots, spaces debugdag: tags, branches, dots, spaces
debugdata: changelog, manifest, dir debugdata: changelog, manifest, dir
debugdate: extended debugdate: extended
debugdeltachain: changelog, manifest, dir, template debugdeltachain: changelog, manifest, dir, template
debugdirstateignorepatternshash: debugdirstateignorepatternshash:
debugdirstate: nodates, dates, datesort, dirs debugdirstate: nodates, dates, datesort, all
debugdiscovery: old, nonheads, rev, seed, local-as-revs, remote-as-revs, ssh, remotecmd, insecure, template debugdiscovery: old, nonheads, rev, seed, local-as-revs, remote-as-revs, ssh, remotecmd, insecure, template
debugdownload: output debugdownload: output
debugextensions: template debugextensions: template
debugfileset: rev, all-files, show-matcher, show-stage debugfileset: rev, all-files, show-matcher, show-stage
debugformat: template debugformat: template
debugfsinfo: debugfsinfo:
debuggetbundle: head, common, type debuggetbundle: head, common, type
debugignore: debugignore:

tests/test-status.t

$ hg init repo8 $ hg init repo8
$ cd repo8 $ cd repo8
$ mkdir subdir $ mkdir subdir
$ touch subdir/a subdir/b $ touch subdir/a subdir/b
$ hg ci -Aqm '#0' $ hg ci -Aqm '#0'
The cached mtime is initially unset The cached mtime is initially unset
$ hg debugdirstate --dirs --no-dates | grep '^d' $ hg debugdirstate --all --no-dates | grep '^ '
d 0 0 unset subdir 0 -1 unset subdir
It is still not set when there are unknown files It is still not set when there are unknown files
$ touch subdir/unknown $ touch subdir/unknown
$ hg status $ hg status
? subdir/unknown ? subdir/unknown
$ hg debugdirstate --dirs --no-dates | grep '^d' $ hg debugdirstate --all --no-dates | grep '^ '
d 0 0 unset subdir 0 -1 unset subdir
Now the directory is eligible for caching, so its mtime is save in the dirstate Now the directory is eligible for caching, so its mtime is save in the dirstate
$ rm subdir/unknown $ rm subdir/unknown
$ hg status $ hg status
$ hg debugdirstate --dirs --no-dates | grep '^d' $ hg debugdirstate --all --no-dates | grep '^ '
d 0 0 set subdir 0 -1 set subdir
This time the command should be ever so slightly faster since it does not need `read_dir("subdir")` This time the command should be ever so slightly faster since it does not need `read_dir("subdir")`
$ hg status $ hg status
Creating a new file changes the directory’s mtime, invalidating the cache Creating a new file changes the directory’s mtime, invalidating the cache
$ touch subdir/unknown $ touch subdir/unknown
$ hg status $ hg status
? subdir/unknown ? subdir/unknown
$ rm subdir/unknown $ rm subdir/unknown
$ hg status $ hg status
Removing a node from the dirstate resets the cache for its parent directory Removing a node from the dirstate resets the cache for its parent directory
$ hg forget subdir/a $ hg forget subdir/a
$ hg debugdirstate --dirs --no-dates | grep '^d' $ hg debugdirstate --all --no-dates | grep '^ '
d 0 0 set subdir 0 -1 set subdir
$ hg ci -qm '#1' $ hg ci -qm '#1'
$ hg debugdirstate --dirs --no-dates | grep '^d' $ hg debugdirstate --all --no-dates | grep '^ '
d 0 0 unset subdir 0 -1 unset subdir
$ hg status $ hg status
? subdir/a ? subdir/a
#endif #endif