This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10364

dirstate-tree: Empty shell for a second Rust DirstateMap implementation
ClosedPublic

Authored by SimonSapin on Apr 12 2021, 8:23 AM.

Download Raw Diff

Details

Reviewers

Alphare

Group Reviewers

hg-reviewers

Commits

rHG473abf4728bf: dirstate-tree: Empty shell for a second Rust DirstateMap implementation
rHGaa8f02718f3b: dirstate-tree: Empty shell for a second Rust DirstateMap implementation

Summary

For background see description of the previous changeset
"Make Rust DirstateMap bindings go through a trait object".

Add an empty shell for a opt-in second Rust implementation of the
DirstateMap type and the status function. For now all methods panic.
This can be seen in "action" with:

./hg status --config experimental.dirstate-tree.in-memory=1

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.Apr 12 2021, 8:23 AM

Herald added a reviewer: hg-reviewers. · View Herald TranscriptApr 12 2021, 8:23 AM

Herald added a subscriber: mercurial-patches. · View Herald Transcript

SimonSapin added a child revision: D10365: dirstate-tree: Add `WithBasename` wrapper for `HgPath`.Apr 12 2021, 8:23 AM

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

Alphare accepted this revision.Apr 19 2021, 11:23 AM

Alphare added a subscriber: Alphare.

Alphare added inline comments.

rust/hg-cpython/src/dirstate/dirstate_map.rs
57	I didn't know you could write `as _`, but it's cool!

SimonSapin updated this revision to Diff 27315.May 3 2021, 6:23 AM

SimonSapin added a commit: rHGaa8f02718f3b: dirstate-tree: Empty shell for a second Rust DirstateMap implementation.May 6 2021, 12:48 PM

This revision was not accepted when it landed; it landed in state Needs Review.

Closed by commit rHGaa8f02718f3b: dirstate-tree: Empty shell for a second Rust DirstateMap implementation (authored by SimonSapin). · Explain Why

This revision was automatically updated to reflect the committed changes.

SimonSapin added a commit: rHG473abf4728bf: dirstate-tree: Empty shell for a second Rust DirstateMap implementation.May 6 2021, 3:42 PM

Revision Contents
Changeset List

		Path
M		mercurial/configitems.py (5 lines)
M		mercurial/dirstate.py (7 lines)
M		rust/hg-core/src/dirstate_tree.rs (1 line)
A	M	rust/hg-core/src/dirstate_tree/dirstate_map.rs (216 lines)
M		rust/hg-cpython/src/dirstate/dirstate_map.rs (8 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	26817		Apr 12 2021, 8:23 AM	★	★
Diff 2	27048		Apr 19 2021, 11:02 AM	★	★
Diff 3	27315		May 3 2021, 6:23 AM	★	★
Diff 4	27639	rHGaa8f02718f3ba78a25cc25437313f71b47362c87	Mar 30 2021, 3:56 AM	★	★

Status	Author	Revision
Closed	SimonSapin	D10560 dirstate-tree: Borrow paths from the "on disk" bytes
Closed	SimonSapin	D10559 dirstate-tree: Borrow copy source paths from the "on disk" bytes
Closed	SimonSapin	D10558 rust: Use `&HgPath` instead of `&HgPathBuf` in may APIs
Closed	SimonSapin	D10557 dirstate-tree: Make `DirstateMap` borrow from a bytes buffer
Closed	SimonSapin	D10556 rust: Read dirstate from disk in DirstateMap constructor
Closed	SimonSapin	D10555 rust: Remove handling of `parents` in `DirstateMap`
Closed	SimonSapin	D10554 dirstate-tree: Fold "tracked descendants" counter update in main walk
Closed	SimonSapin	D10553 dirstate-tree: Use HashMap instead of BTreeMap
Closed	SimonSapin	D10552 dirstate-tree: Add #[timed] attribute to `status` and `DirstateMap::read`
Closed	SimonSapin	D10551 dirstate-tree: Paralellize the status algorithm with Rayon
Closed	SimonSapin	D10550 dirstate-tree: Avoid BTreeMap double-lookup when inserting a dirstate entry
Closed	SimonSapin	D10549 dirstate-tree: Handle I/O errors in status
Closed	SimonSapin	D10548 dirstate-tree: Ignore FIFOs etc. in the status algorithm
Closed	SimonSapin	D10547 dirstate-tree: Add the new `status()` algorithm
Closed	SimonSapin	D10546 dirstate-tree: Give to `status()` mutable access to the `DirstateMap`
Closed	SimonSapin	D10495 rust: Add doc-comments to DirstateStatus fields
Closed	SimonSapin	D10494 rust: Move "lookup" a.k.a. "unsure" paths into `DirstateStatus` struct
Closed	SimonSapin	D10493 rust: Remove DirstateMap::file_fold_map
Closed	SimonSapin	D10492 dirstate-tree: Add "non normal" and "from other parent" sets
Closed	SimonSapin	D10491 dirstate-tree: Add add_file, remove_file, and drop_file
Closed	SimonSapin	D10490 dirstate-tree: Add has_dir and has_tracked_dir
Closed	SimonSapin	D10489 dirstate-tree: Add clear_ambiguous_times in the new DirstateMap
Closed	SimonSapin	D10488 dirstate-tree: Add copy_map_insert and copy_map_remove
Closed	SimonSapin	D10487 dirstate-tree: Maintain a counter of DirstateEntry’s and copy sources
Closed	SimonSapin	D10486 dirstate-tree: Serialize to disk
Closed	SimonSapin	D10485 rust: Add a Timestamp struct instead of abusing Duration
Closed	SimonSapin	D10370 dirstate-tree: Add tree traversal/iteration
Closed	SimonSapin	D10369 dirstate-tree: Add map `get` and `contains_key` methods
Closed	SimonSapin	D10368 dirstate-tree: Add parsing only dirstate parents from disk
Closed	SimonSapin	D10367 dirstate-tree: Implement DirstateMap::read
Abandoned	SimonSapin	D10366 rust: Refactor parse_dirstate() to take a callback
Closed	SimonSapin	D10365 dirstate-tree: Add `WithBasename` wrapper for `HgPath`
Closed	SimonSapin	D10364 dirstate-tree: Empty shell for a second Rust DirstateMap implementation
Closed	SimonSapin	D10363 dirstate-tree: Abstract "non-normal" and "other parent" sets
Closed	SimonSapin	D10362 dirstate-tree: Make Rust DirstateMap bindings go through a trait object

Diff 27639

mercurial/configitems.py

	)			)
	coreconfigitem(			coreconfigitem(
	b'experimental',			b'experimental',
	b'directaccess.revnums',			b'directaccess.revnums',
	default=False,			default=False,
	)			)
	coreconfigitem(			coreconfigitem(
	b'experimental',			b'experimental',
				b'dirstate-tree.in-memory',
				default=False,
				)
				coreconfigitem(
				b'experimental',
	b'editortmpinhg',			b'editortmpinhg',
	default=False,			default=False,
	)			)
	coreconfigitem(			coreconfigitem(
	b'experimental',			b'experimental',
	b'evolution',			b'evolution',
	default=list,			default=list,
	)			)

mercurial/dirstate.py

	return self._rustmap			return self._rustmap

	@propertycache			@propertycache
	def _inner_rustmap(self):			def _inner_rustmap(self):
	"""			"""
	Does not fill the Dirstatemap when called. This allows for			Does not fill the Dirstatemap when called. This allows for
	optimizations where only setting/getting the parents is needed.			optimizations where only setting/getting the parents is needed.
	"""			"""
	self._inner_rustmap = rustmod.DirstateMap(self._root)			use_dirstate_tree = self._ui.configbool(
				b"experimental",
				b"dirstate-tree.in-memory",
				False,
				)
				self._inner_rustmap = rustmod.DirstateMap(use_dirstate_tree)
	return self._inner_rustmap			return self._inner_rustmap

	@property			@property
	def copymap(self):			def copymap(self):
	return self._rustmap.copymap()			return self._rustmap.copymap()

	def preload(self):			def preload(self):
	self._rustmap			self._rustmap

rust/hg-core/src/dirstate_tree.rs

				pub mod dirstate_map;
	pub mod dispatch;			pub mod dispatch;

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

This file was added.

				use std::path::PathBuf;
				use std::time::Duration;

				use crate::matchers::Matcher;
				use crate::utils::hg_path::{HgPath, HgPathBuf};
				use crate::CopyMapIter;
				use crate::DirstateEntry;
				use crate::DirstateError;
				use crate::DirstateMapError;
				use crate::DirstateParents;
				use crate::DirstateStatus;
				use crate::EntryState;
				use crate::FastHashMap;
				use crate::HgPathCow;
				use crate::PatternFileWarning;
				use crate::StateMapIter;
				use crate::StatusError;
				use crate::StatusOptions;

				pub struct DirstateMap {
				// TODO
				}

				impl DirstateMap {
				pub fn new() -> Self {
				todo!()
				}
				}

				impl super::dispatch::DirstateMapMethods for DirstateMap {
				fn clear(&mut self) {
				todo!()
				}

				fn add_file(
				&mut self,
				_filename: &HgPath,
				_old_state: EntryState,
				_entry: DirstateEntry,
				) -> Result<(), DirstateMapError> {
				todo!()
				}

				fn remove_file(
				&mut self,
				_filename: &HgPath,
				_old_state: EntryState,
				_size: i32,
				) -> Result<(), DirstateMapError> {
				todo!()
				}

				fn drop_file(
				&mut self,
				_filename: &HgPath,
				_old_state: EntryState,
				) -> Result<bool, DirstateMapError> {
				todo!()
				}

				fn clear_ambiguous_times(
				&mut self,
				_filenames: Vec<HgPathBuf>,
				_now: i32,
				) {
				todo!()
				}

				fn non_normal_entries_contains(&mut self, _key: &HgPath) -> bool {
				todo!()
				}

				fn non_normal_entries_remove(&mut self, _key: &HgPath) -> bool {
				todo!()
				}

				fn non_normal_or_other_parent_paths(
				&mut self,
				) -> Box<dyn Iterator<Item = &HgPathBuf> + '_> {
				todo!()
				}

				fn set_non_normal_other_parent_entries(&mut self, _force: bool) {
				todo!()
				}

				fn iter_non_normal_paths(
				&mut self,
				) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> {
				todo!()
				}

				fn iter_non_normal_paths_panic(
				&self,
				) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> {
				todo!()
				}

				fn iter_other_parent_paths(
				&mut self,
				) -> Box<dyn Iterator<Item = &HgPathBuf> + Send + '_> {
				todo!()
				}

				fn has_tracked_dir(
				&mut self,
				_directory: &HgPath,
				) -> Result<bool, DirstateMapError> {
				todo!()
				}

				fn has_dir(
				&mut self,
				_directory: &HgPath,
				) -> Result<bool, DirstateMapError> {
				todo!()
				}

				fn parents(
				&mut self,
				_file_contents: &[u8],
				) -> Result<&DirstateParents, DirstateError> {
				todo!()
				}

				fn set_parents(&mut self, _parents: &DirstateParents) {
				todo!()
				}

				fn read<'a>(
				&mut self,
				_file_contents: &'a [u8],
				) -> Result<Option<&'a DirstateParents>, DirstateError> {
				todo!()
				}

				fn pack(
				&mut self,
				_parents: DirstateParents,
				_now: Duration,
				) -> Result<Vec<u8>, DirstateError> {
				todo!()
				}

				fn build_file_fold_map(&mut self) -> &FastHashMap<HgPathBuf, HgPathBuf> {
				todo!()
				}

				fn set_all_dirs(&mut self) -> Result<(), DirstateMapError> {
				todo!()
				}

				fn set_dirs(&mut self) -> Result<(), DirstateMapError> {
				todo!()
				}

				fn status<'a>(
				&'a self,
				_matcher: &'a (dyn Matcher + Sync),
				_root_dir: PathBuf,
				_ignore_files: Vec<PathBuf>,
				_options: StatusOptions,
				) -> Result<
				(
				(Vec<HgPathCow<'a>>, DirstateStatus<'a>),
				Vec<PatternFileWarning>,
				),
				StatusError,
				> {
				todo!()
				}

				fn copy_map_len(&self) -> usize {
				todo!()
				}

				fn copy_map_iter(&self) -> CopyMapIter<'_> {
				todo!()
				}

				fn copy_map_contains_key(&self, _key: &HgPath) -> bool {
				todo!()
				}

				fn copy_map_get(&self, _key: &HgPath) -> Option<&HgPathBuf> {
				todo!()
				}

				fn copy_map_remove(&mut self, _key: &HgPath) -> Option<HgPathBuf> {
				todo!()
				}

				fn copy_map_insert(
				&mut self,
				_key: HgPathBuf,
				_value: HgPathBuf,
				) -> Option<HgPathBuf> {
				todo!()
				}

				fn len(&self) -> usize {
				todo!()
				}

				fn contains_key(&self, _key: &HgPath) -> bool {
				todo!()
				}

				fn get(&self, _key: &HgPath) -> Option<&DirstateEntry> {
				todo!()
				}

				fn iter(&self) -> StateMapIter<'_> {
				todo!()
				}
				}

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

	// The same logic applies to `dirs` and `all_dirs`, however the `Dirs`			// The same logic applies to `dirs` and `all_dirs`, however the `Dirs`
	// `py_class!` is already implemented and does not mention			// `py_class!` is already implemented and does not mention
	// `RustDirstateMap`, rightfully so.			// `RustDirstateMap`, rightfully so.
	// All attributes also have to have a separate refcount data attribute for			// All attributes also have to have a separate refcount data attribute for
	// leaks, with all methods that go along for reference sharing.			// leaks, with all methods that go along for reference sharing.
	py_class!(pub class DirstateMap \|py\| {			py_class!(pub class DirstateMap \|py\| {
	@shared data inner: Box<dyn DirstateMapMethods + Send>;			@shared data inner: Box<dyn DirstateMapMethods + Send>;

	def __new__(_cls, _root: PyObject) -> PyResult<Self> {			def __new__(_cls, use_dirstate_tree: bool) -> PyResult<Self> {
	let inner = Box::new(RustDirstateMap::default());			let inner = if use_dirstate_tree {
				Box::new(hg::dirstate_tree::dirstate_map::DirstateMap::new()) as _
				} else {
				Box::new(RustDirstateMap::default()) as _
				AlphareUnsubmitted Not Done I didn't know you could write `as _`, but it's cool! Alphare: I didn't know you could write `as _`, but it's cool!
				};
	Self::create_instance(py, inner)			Self::create_instance(py, inner)
	}			}

	def clear(&self) -> PyResult<PyObject> {			def clear(&self) -> PyResult<PyObject> {
	self.inner(py).borrow_mut().clear();			self.inner(py).borrow_mut().clear();
	Ok(py.None())			Ok(py.None())
	}			}