mercurial-scm/hg: rust/hg-core/src/update.rs annotate

annotate rust/hg-core/src/update.rs @ 52280:f4aede0f01af

rust-manifest: use `memchr` crate for all byte-finding needs While writing a very dumb manifest diffing algorithm for a proof-of-concept I saw that `Manifest::find_by_path` was much slower than I was expecting. It turns out that the Rust stdlib uses slow (all is relative) code when searching for byte positions for reasons ranging from portability, SIMD API stability, nobody doing the work, etc. `memch` is much faster for these purposes, so let's use it. I was measuring ~670ms of profile time in `find_by_path`, after this patch it went down to ~230ms.

author	Rapha?l Gom?s <rgomes@octobus.net>
date	Tue, 12 Nov 2024 23:20:04 +0100
parents	65d516db7309
children	db065b33fa56

rev	line source
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	1 //! Tools for moving the repository to a given revision
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	2
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	3 use std::{
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	4 fs::Permissions,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	5 io::Write,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	6 os::unix::fs::{MetadataExt, PermissionsExt},
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	7 path::Path,
52213 96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	8 sync::atomic::Ordering,
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	9 time::Duration,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	10 };
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	11
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	12 use crate::{
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	13 dirstate::{ParentFileData, TruncatedTimestamp},
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	14 dirstate_tree::{
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	15 dirstate_map::DirstateEntryReset, on_disk::write_tracked_key,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	16 },
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	17 errors::{HgError, IoResultExt},
52178 bd8081e9fd62 rust: don't star export from the `revlog` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52156 diff changeset	18 exit_codes, narrow,
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	19 operations::{list_rev_tracked_files, ExpandedManifestEntry},
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	20 progress::Progress,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	21 repo::Repo,
52178 bd8081e9fd62 rust: don't star export from the `revlog` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52156 diff changeset	22 revlog::filelog::Filelog,
bd8081e9fd62 rust: don't star export from the `revlog` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52156 diff changeset	23 revlog::node::NULL_NODE,
bd8081e9fd62 rust: don't star export from the `revlog` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52156 diff changeset	24 revlog::options::{default_revlog_options, RevlogOpenOptions},
bd8081e9fd62 rust: don't star export from the `revlog` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52156 diff changeset	25 revlog::RevlogError,
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	26 sparse,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	27 utils::{
52186 e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	28 cap_default_rayon_threads,
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	29 files::{filesystem_now, get_path_from_bytes},
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	30 hg_path::{hg_path_to_path_buf, HgPath, HgPathError},
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	31 path_auditor::PathAuditor,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	32 },
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	33 vfs::{is_on_nfs_mount, VfsImpl},
52251 65d516db7309 branching: merge stable into default Rapha?l Gom?s <rgomes@octobus.net> parents: 52178 52213 diff changeset	34 DirstateParents, UncheckedRevision, INTERRUPT_RECEIVED,
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	35 };
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	36 use crossbeam_channel::{Receiver, Sender};
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	37 use rayon::prelude::*;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	38
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	39 fn write_dirstate(repo: &Repo) -> Result<(), HgError> {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	40 repo.write_dirstate()
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	41 .map_err(\|e\| HgError::abort(e.to_string(), exit_codes::ABORT, None))?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	42 write_tracked_key(repo)
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	43 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	44
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	45 /// Update the current working copy of `repo` to the given revision `to`, from
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	46 /// the null revision and set + write out the dirstate to reflect that.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	47 ///
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	48 /// Do not call this outside of a Python context. This does not handle any
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	49 /// of the checks, hooks, lock taking needed to setup and get out of this
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	50 /// update from the null revision.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	51 pub fn update_from_null(
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	52 repo: &Repo,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	53 to: UncheckedRevision,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	54 progress: &dyn Progress,
52186 e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	55 workers: Option<usize>,
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	56 ) -> Result<usize, HgError> {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	57 // Ignore the warnings, they've been displayed by Python already
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	58 // TODO non-Python clients: display narrow warnings
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	59 let (narrow_matcher, _) = narrow::matcher(repo)?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	60
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	61 let files_for_rev = list_rev_tracked_files(repo, to, narrow_matcher)
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	62 .map_err(handle_revlog_error)?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	63 repo.manually_set_parents(DirstateParents {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	64 p1: repo.node(to).expect("update target should exist"),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	65 p2: NULL_NODE,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	66 })?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	67
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	68 // Filter the working copy according to the sparse spec
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	69 let tracked_files: Result<Vec<_>, _> = if !repo.has_sparse() {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	70 files_for_rev.iter().collect()
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	71 } else {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	72 // Ignore the warnings, they've been displayed by Python already
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	73 // TODO non-Python clients: display sparse warnings
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	74 let (sparse_matcher, _) = sparse::matcher(repo)?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	75 files_for_rev
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	76 .iter()
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	77 .filter(\|f\| {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	78 match f {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	79 Ok(f) => sparse_matcher.matches(f.0),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	80 Err(_) => true, // Errors stop the update, include them
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	81 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	82 })
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	83 .collect()
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	84 };
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	85 let tracked_files = tracked_files?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	86
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	87 if tracked_files.is_empty() {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	88 // Still write the dirstate because we might not be in the null
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	89 // revision.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	90 // This can happen in narrow repos where all paths are excluded in
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	91 // this revision.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	92 write_dirstate(repo)?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	93 return Ok(0);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	94 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	95 let store_vfs = &repo.store_vfs();
52156 039b7caeb4d9 rust-revlog: introduce an `options` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	96 let options = default_revlog_options(
039b7caeb4d9 rust-revlog: introduce an `options` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	97 repo.config(),
039b7caeb4d9 rust-revlog: introduce an `options` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	98 repo.requirements(),
52178 bd8081e9fd62 rust: don't star export from the `revlog` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52156 diff changeset	99 crate::revlog::RevlogType::Filelog,
52156 039b7caeb4d9 rust-revlog: introduce an `options` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	100 )?;
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	101 let (errors_sender, errors_receiver) = crossbeam_channel::unbounded();
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	102 let (files_sender, files_receiver) = crossbeam_channel::unbounded();
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	103 let working_directory_path = &repo.working_directory_path();
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	104
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	105 let files_count = tracked_files.len();
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	106 let chunks = chunk_tracked_files(tracked_files);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	107 progress.update(0, Some(files_count as u64));
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	108
52213 96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	109 // TODO find a way (with `nix` or `signal-hook`?) of resetting the
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	110 // previous signal handler directly after. Currently, this is Python's
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	111 // job, but:
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	112 // - it introduces a (small) race between catching and resetting
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	113 // - it would break signal handlers in other contexts like `rhg``
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	114 let _ = ctrlc::set_handler(\|\| {
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	115 INTERRUPT_RECEIVED.store(true, Ordering::Relaxed)
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	116 });
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	117
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	118 create_working_copy(
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	119 chunks,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	120 working_directory_path,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	121 store_vfs,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	122 options,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	123 files_sender,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	124 errors_sender,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	125 progress,
52186 e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	126 workers,
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	127 );
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	128
52213 96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	129 // Reset the global interrupt now that we're done
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	130 if INTERRUPT_RECEIVED.swap(false, Ordering::Relaxed) {
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	131 // The threads have all exited early, let's re-raise
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	132 return Err(HgError::InterruptReceived);
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	133 }
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	134
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	135 let errors: Vec<HgError> = errors_receiver.iter().collect();
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	136 if !errors.is_empty() {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	137 log::debug!("{} errors during update (see trace logs)", errors.len());
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	138 for error in errors.iter() {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	139 log::trace!("{}", error);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	140 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	141 // Best we can do is raise the first error (in order of the channel)
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	142 return Err(errors.into_iter().next().expect("can never be empty"));
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	143 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	144
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	145 // TODO try to run this concurrently to update the dirstate while we're
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	146 // still writing out the working copy to see if that improves performance.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	147 let total = update_dirstate(repo, files_receiver)?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	148
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	149 write_dirstate(repo)?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	150
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	151 Ok(total)
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	152 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	153
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	154 fn handle_revlog_error(e: RevlogError) -> HgError {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	155 match e {
52178 bd8081e9fd62 rust: don't star export from the `revlog` module Rapha?l Gom?s <rgomes@octobus.net> parents: 52156 diff changeset	156 crate::revlog::RevlogError::Other(hg_error) => hg_error,
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	157 e => HgError::abort(
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	158 format!("revlog error: {}", e),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	159 exit_codes::ABORT,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	160 None,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	161 ),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	162 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	163 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	164
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	165 /// Preallocated size of Vec holding directory contents. This aims at
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	166 /// preventing the need for re-allocating the Vec in most cases.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	167 ///
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	168 /// The value is arbitrarily picked as a little over an average number of files
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	169 /// per directory done by looking at a few larger open-source repos.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	170 /// Most of the runtime is IO anyway, so this doesn't matter too much.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	171 const FILES_PER_DIRECTORY: usize = 16;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	172
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	173 /// Chunk files per directory prefix, so almost every directory is handled
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	174 /// in a separate thread, which works around the FS inode mutex.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	175 /// Chunking less (and doing approximately `files_count`/`threads`) actually
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	176 /// ends up being less performant: my hypothesis is `rayon`'s work stealing
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	177 /// being more efficient with tasks of varying lengths.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	178 #[logging_timer::time("trace")]
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	179 fn chunk_tracked_files(
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	180 tracked_files: Vec<ExpandedManifestEntry>,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	181 ) -> Vec<(&HgPath, Vec<ExpandedManifestEntry>)> {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	182 let files_count = tracked_files.len();
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	183
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	184 let mut chunks = Vec::with_capacity(files_count / FILES_PER_DIRECTORY);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	185
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	186 let mut current_chunk = Vec::with_capacity(FILES_PER_DIRECTORY);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	187 let mut last_directory = tracked_files[0].0.parent();
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	188
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	189 for file_info in tracked_files {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	190 let current_directory = file_info.0.parent();
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	191 let different_directory = current_directory != last_directory;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	192 if different_directory {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	193 chunks.push((last_directory, current_chunk));
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	194 current_chunk = Vec::with_capacity(FILES_PER_DIRECTORY);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	195 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	196 current_chunk.push(file_info);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	197 last_directory = current_directory;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	198 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	199 chunks.push((last_directory, current_chunk));
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	200 chunks
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	201 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	202
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	203 #[logging_timer::time("trace")]
52186 e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	204 #[allow(clippy::too_many_arguments)]
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	205 fn create_working_copy<'a: 'b, 'b>(
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	206 chunks: Vec<(&HgPath, Vec<ExpandedManifestEntry<'a>>)>,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	207 working_directory_path: &Path,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	208 store_vfs: &VfsImpl,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	209 options: RevlogOpenOptions,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	210 files_sender: Sender<(&'b HgPath, u32, usize, TruncatedTimestamp)>,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	211 error_sender: Sender<HgError>,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	212 progress: &dyn Progress,
52186 e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	213 workers: Option<usize>,
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	214 ) {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	215 let auditor = PathAuditor::new(working_directory_path);
52213 96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	216
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	217 let work_closure = \|(dir_path, chunk)\| -> Result<(), HgError> {
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	218 if let Err(e) = working_copy_worker(
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	219 dir_path,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	220 chunk,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	221 working_directory_path,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	222 store_vfs,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	223 options,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	224 &files_sender,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	225 progress,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	226 &auditor,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	227 ) {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	228 error_sender
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	229 .send(e)
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	230 .expect("channel should not be disconnected")
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	231 }
52213 96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	232 Ok(())
52186 e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	233 };
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	234 if let Some(workers) = workers {
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	235 if workers > 1 {
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	236 // Work in parallel, potentially restricting the number of threads
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	237 match rayon::ThreadPoolBuilder::new().num_threads(workers).build()
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	238 {
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	239 Err(error) => error_sender
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	240 .send(HgError::abort(
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	241 error.to_string(),
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	242 exit_codes::ABORT,
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	243 None,
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	244 ))
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	245 .expect("channel should not be disconnected"),
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	246 Ok(pool) => {
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	247 log::trace!("restricting update to {} threads", workers);
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	248 pool.install(\|\| {
52213 96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	249 let _ =
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	250 chunks.into_par_iter().try_for_each(work_closure);
52186 e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	251 });
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	252 }
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	253 }
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	254 } else {
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	255 // Work sequentially, don't even invoke rayon
52213 96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	256 let _ = chunks.into_iter().try_for_each(work_closure);
52186 e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	257 }
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	258 } else {
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	259 // Work in parallel by default in the global threadpool
e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	260 let _ = cap_default_rayon_threads();
52213 96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	261 let _ = chunks.into_par_iter().try_for_each(work_closure);
52186 e6a44bc91bc2 rust-update: make `update_from_null` respect `worker.numcpu` config option Rapha?l Gom?s <rgomes@octobus.net> parents: 52056 diff changeset	262 }
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	263 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	264
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	265 /// Represents a work unit for a single thread, responsible for this set of
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	266 /// files and restoring them to the working copy.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	267 #[allow(clippy::too_many_arguments)]
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	268 fn working_copy_worker<'a: 'b, 'b>(
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	269 dir_path: &HgPath,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	270 chunk: Vec<ExpandedManifestEntry<'a>>,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	271 working_directory_path: &Path,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	272 store_vfs: &VfsImpl,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	273 options: RevlogOpenOptions,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	274 files_sender: &Sender<(&'b HgPath, u32, usize, TruncatedTimestamp)>,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	275 progress: &dyn Progress,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	276 auditor: &PathAuditor,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	277 ) -> Result<(), HgError> {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	278 let dir_path =
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	279 hg_path_to_path_buf(dir_path).expect("invalid path in manifest");
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	280 let dir_path = working_directory_path.join(dir_path);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	281 std::fs::create_dir_all(&dir_path).when_writing_file(&dir_path)?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	282
52213 96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	283 if INTERRUPT_RECEIVED.load(Ordering::Relaxed) {
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	284 // Stop working, the user has requested that we stop
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	285 return Err(HgError::InterruptReceived);
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	286 }
96b113d22b34 rust-update: handle SIGINT from long-running update threads Rapha?l Gom?s <rgomes@octobus.net> parents: 52186 diff changeset	287
52056 8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	288 for (file, file_node, flags) in chunk {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	289 auditor.audit_path(file)?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	290 let flags = flags.map(\|f\| f.into());
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	291 let path =
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	292 working_directory_path.join(get_path_from_bytes(file.as_bytes()));
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	293
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	294 // Treemanifest is not supported
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	295 assert!(flags != Some(b't'));
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	296
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	297 let filelog = Filelog::open_vfs(store_vfs, file, options)?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	298 let filelog_revision_data = &filelog
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	299 .data_for_node(file_node)
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	300 .map_err(handle_revlog_error)?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	301 let file_data = filelog_revision_data.file_data()?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	302
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	303 if flags == Some(b'l') {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	304 let target = get_path_from_bytes(file_data);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	305 if let Err(e) = std::os::unix::fs::symlink(target, &path) {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	306 // If the path already exists either:
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	307 // - another process created this file while ignoring the
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	308 // lock => error
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	309 // - our check for the fast path is incorrect => error
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	310 // - this is a malicious repo/bundle and this is symlink that
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	311 // tries to write things where it shouldn't be able to.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	312 match e.kind() {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	313 std::io::ErrorKind::AlreadyExists => {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	314 let metadata = std::fs::symlink_metadata(&path)
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	315 .when_reading_file(&path)?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	316 if metadata.is_dir() {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	317 return Err(HgError::Path(
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	318 HgPathError::TraversesSymbolicLink {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	319 // Technically it should be one of the
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	320 // children, but good enough
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	321 path: file
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	322 .join(HgPath::new(b"*"))
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	323 .to_owned(),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	324 symlink: file.to_owned(),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	325 },
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	326 ));
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	327 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	328 return Err(e).when_writing_file(&path);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	329 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	330 _ => return Err(e).when_writing_file(&path),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	331 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	332 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	333 } else {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	334 let mut f =
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	335 std::fs::File::create(&path).when_writing_file(&path)?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	336 f.write_all(file_data).when_writing_file(&path)?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	337 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	338 if flags == Some(b'x') {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	339 std::fs::set_permissions(&path, Permissions::from_mode(0o755))
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	340 .when_writing_file(&path)?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	341 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	342 let metadata =
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	343 std::fs::symlink_metadata(&path).when_reading_file(&path)?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	344
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	345 let mode = metadata.mode();
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	346
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	347 files_sender
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	348 .send((
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	349 file,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	350 mode,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	351 file_data.len(),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	352 TruncatedTimestamp::for_mtime_of(&metadata)
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	353 .when_reading_file(&path)?,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	354 ))
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	355 .expect("channel should not be closed");
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	356 progress.increment(1, None);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	357 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	358 Ok(())
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	359 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	360
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	361 #[logging_timer::time("trace")]
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	362 fn update_dirstate(
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	363 repo: &Repo,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	364 files_receiver: Receiver<(&HgPath, u32, usize, TruncatedTimestamp)>,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	365 ) -> Result<usize, HgError> {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	366 let mut dirstate = repo
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	367 .dirstate_map_mut()
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	368 .map_err(\|e\| HgError::abort(e.to_string(), exit_codes::ABORT, None))?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	369
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	370 // (see the comments in `filter_ambiguous_files` in `merge.py` for more)
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	371 // It turns out that (on Linux at least) the filesystem resolution time
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	372 // for most filesystems is based on the HZ kernel config. Their internal
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	373 // clocks do return nanoseconds if the hardware clock is precise enough,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	374 // which should be the case on most recent computers but are only updated
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	375 // every few milliseconds at best (every "jiffy").
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	376 //
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	377 // We are still not concerned with fixing the race with other
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	378 // processes that might modify the working copy right after it was created
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	379 // within the same tick, because it is impossible to catch.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	380 // However, we might as well not race with operations that could run right
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	381 // after this one, especially other Mercurial operations that could be
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	382 // waiting for the wlock to change file contents and the dirstate.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	383 //
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	384 // Thus: wait until the filesystem clock has ticked to filter ambiguous
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	385 // entries and write the dirstate, but only for dirstate-v2, since v1 only
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	386 // has second-level granularity and waiting for a whole second is too much
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	387 // of a penalty in the general case.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	388 // Although we're assuming that people running dirstate-v2 on Linux
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	389 // don't have a second-granularity FS (with the exclusion of NFS), users
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	390 // can be surprising, and at some point in the future dirstate-v2 will
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	391 // become the default. To that end, we limit the wait time to 100ms and
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	392 // fall back to the filter method in case of a timeout.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	393 //
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	394 // +------------+------+--------------+
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	395 // \| version \| wait \| filter level \|
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	396 // +------------+------+--------------+
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	397 // \| V1 \| No \| Second \|
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	398 // \| V2 \| Yes \| Nanosecond \|
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	399 // \| V2-slow-fs \| No \| Second \|
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	400 // +------------+------+--------------+
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	401 let dirstate_v2 = repo.use_dirstate_v2();
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	402
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	403 // Let's ignore NFS right off the bat
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	404 let mut fast_enough_fs = !is_on_nfs_mount(repo.working_directory_path());
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	405 let fs_time_now = if dirstate_v2 && fast_enough_fs {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	406 match wait_until_fs_tick(repo.working_directory_path()) {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	407 None => None,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	408 Some(Ok(time)) => Some(time),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	409 Some(Err(time)) => {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	410 fast_enough_fs = false;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	411 Some(time)
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	412 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	413 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	414 } else {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	415 filesystem_now(repo.working_directory_path())
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	416 .ok()
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	417 .map(TruncatedTimestamp::from)
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	418 };
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	419
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	420 let mut total = 0;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	421 for (filename, mode, size, mtime) in files_receiver.into_iter() {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	422 total += 1;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	423 // When using dirstate-v2 on a filesystem with reasonable performance
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	424 // this is basically always true unless you get a mtime from the
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	425 // far future.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	426 let has_meaningful_mtime = if let Some(fs_time) = fs_time_now {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	427 mtime.for_reliable_mtime_of_self(&fs_time).is_some_and(\|t\| {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	428 // Dirstate-v1 only has second-level information
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	429 !t.second_ambiguous \|\| dirstate_v2 && fast_enough_fs
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	430 })
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	431 } else {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	432 // We somehow failed to write to the filesystem, so don't store
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	433 // the cache information.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	434 false
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	435 };
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	436 let reset = DirstateEntryReset {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	437 filename,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	438 wc_tracked: true,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	439 p1_tracked: true,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	440 p2_info: false,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	441 has_meaningful_mtime,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	442 parent_file_data_opt: Some(ParentFileData {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	443 mode_size: Some((
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	444 mode,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	445 size.try_into().expect("invalid file size in manifest"),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	446 )),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	447 mtime: Some(mtime),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	448 }),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	449 from_empty: true,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	450 };
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	451 dirstate.reset_state(reset).map_err(\|e\| {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	452 HgError::abort(e.to_string(), exit_codes::ABORT, None)
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	453 })?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	454 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	455
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	456 Ok(total)
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	457 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	458
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	459 /// Wait until the next update from the filesystem time by writing in a loop
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	460 /// a new temporary file inside the working directory and checking if its time
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	461 /// differs from the first one observed.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	462 ///
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	463 /// Returns `None` if we are unable to get the filesystem time,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	464 /// `Some(Err(timestamp))` if we've timed out waiting for the filesystem clock
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	465 /// to tick, and `Some(Ok(timestamp))` if we've waited successfully.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	466 ///
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	467 /// On Linux, your average tick is going to be a "jiffy", or 1/HZ.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	468 /// HZ is your kernel's tick rate (if it has one configured) and the value
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	469 /// is the one returned by `grep 'CONFIG_HZ=' /boot/config-$(uname -r)`,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	470 /// again assuming a normal setup.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	471 ///
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	472 /// In my case (Alphare) at the time of writing, I get `CONFIG_HZ=250`,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	473 /// which equates to 4ms.
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	474 ///
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	475 /// This might change with a series that could make it to Linux 6.12:
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	476 /// https://lore.kernel.org/all/20241002-mgtime-v10-8-d1c4717f5284@kernel.org
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	477 fn wait_until_fs_tick(
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	478 working_directory_path: &Path,
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	479 ) -> Option<Result<TruncatedTimestamp, TruncatedTimestamp>> {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	480 let start = std::time::Instant::now();
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	481 let old_fs_time = filesystem_now(working_directory_path).ok()?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	482 let mut fs_time = filesystem_now(working_directory_path).ok()?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	483
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	484 const FS_TICK_WAIT_TIMEOUT: Duration = Duration::from_millis(100);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	485
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	486 while fs_time == old_fs_time {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	487 if std::time::Instant::now() - start > FS_TICK_WAIT_TIMEOUT {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	488 log::trace!(
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	489 "timed out waiting for the fs clock to tick after {:?}",
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	490 FS_TICK_WAIT_TIMEOUT
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	491 );
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	492 return Some(Err(TruncatedTimestamp::from(old_fs_time)));
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	493 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	494 fs_time = filesystem_now(working_directory_path).ok()?;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	495 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	496 log::trace!(
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	497 "waited for {:?} before writing the dirstate",
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	498 fs_time.duration_since(old_fs_time)
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	499 );
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	500 Some(Ok(TruncatedTimestamp::from(fs_time)))
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	501 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	502
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	503 #[cfg(test)]
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	504 mod test {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	505 use super::*;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	506 use pretty_assertions::assert_eq;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	507
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	508 #[test]
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	509 fn test_chunk_tracked_files() {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	510 fn chunk(v: Vec<&'static str>) -> Vec<ExpandedManifestEntry> {
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	511 v.into_iter()
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	512 .map(\|f\| (HgPath::new(f.as_bytes()), NULL_NODE, None))
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	513 .collect()
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	514 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	515 let p = HgPath::new;
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	516
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	517 let files = chunk(vec!["a"]);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	518 let expected = vec![(p(""), chunk(vec!["a"]))];
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	519 assert_eq!(chunk_tracked_files(files), expected);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	520
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	521 let files = chunk(vec!["a", "b", "c"]);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	522 let expected = vec![(p(""), chunk(vec!["a", "b", "c"]))];
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	523 assert_eq!(chunk_tracked_files(files), expected);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	524
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	525 let files = chunk(vec![
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	526 "dir/a-new",
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	527 "dir/a/mut",
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	528 "dir/a/mut-mut",
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	529 "dir/albert",
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	530 "dir/b",
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	531 "dir/subdir/c",
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	532 "dir/subdir/d",
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	533 "file",
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	534 ]);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	535 let expected = vec![
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	536 (p("dir"), chunk(vec!["dir/a-new"])),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	537 (p("dir/a"), chunk(vec!["dir/a/mut", "dir/a/mut-mut"])),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	538 (p("dir"), chunk(vec!["dir/albert", "dir/b"])),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	539 (p("dir/subdir"), chunk(vec!["dir/subdir/c", "dir/subdir/d"])),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	540 (p(""), chunk(vec!["file"])),
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	541 ];
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	542 assert_eq!(chunk_tracked_files(files), expected);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	543
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	544 // Doesn't get split
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	545 let large_dir = vec![
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	546 "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12",
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	547 "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23",
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	548 ];
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	549 let files = chunk(large_dir.clone());
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	550 let expected = vec![(p(""), chunk(large_dir))];
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	551 assert_eq!(chunk_tracked_files(files), expected);
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	552 }
8b7123c8947b update: add a Rust fast-path when updating from null (and clean) Rapha?l Gom?s <rgomes@octobus.net> parents: diff changeset	553 }

Mercurial > public > mercurial-scm > hg

annotate rust/hg-core/src/update.rs @ 52280:f4aede0f01af