Loading of manifests is serial

[epage]

download_accessible is approximately 1/3 of cargo's overhead (see https://blog.rust-lang.org/inside-rust/2024/03/26/this-development-cycle-in-cargo-1.78/#performance) with most of that time spent on loading of manifests (parsing, deserializing, normalizing, converting to native data types). While we can speed up individual steps, loading the manifests in parallel could offer a boost (for the non-IO parts).

This can make a difference for

• Tracking Issue for native-completion #14520
• Tracking Issue for cargo-script RFC 3424 #12207
• Redundant builds between users and IDEs that end up blocking each other due to locks
• cargo check for leaf crates

[epage]

This is all kicked off by PackageSet::get_many:

cargo/src/cargo/core/package.rs

Lines 458 to 476 in 2251525

	pub fn get_many(&self, ids: impl IntoIterator<Item = PackageId>) -> CargoResult<Vec<&Package>> {
	let mut pkgs = Vec::new();
	let _lock = self
	.gctx
	.acquire_package_cache_lock(CacheLockMode::DownloadExclusive)?;
	let mut downloads = self.enable_download()?;
	for id in ids {
	pkgs.extend(downloads.start(id)?);
	}
	while downloads.remaining() > 0 {
	pkgs.push(downloads.wait()?);
	}
	downloads.success = true;
	drop(downloads);
	let mut deferred = self.gctx.deferred_global_last_use()?;
	deferred.save_no_error(self.gctx);
	Ok(pkgs)
	}

For registry, we kick off the download if needed and then parse it on completion

cargo/src/cargo/sources/registry/mod.rs

Lines 892 to 922 in 2251525

	fn download(&mut self, package: PackageId) -> CargoResult<MaybePackage> {
	let hash = loop {
	match self.index.hash(package, &mut *self.ops)? {
	Poll::Pending => self.block_until_ready()?,
	Poll::Ready(hash) => break hash,
	}
	};
	match self.ops.download(package, hash)? {
	MaybeLock::Ready(file) => self.get_pkg(package, &file).map(MaybePackage::Ready),
	MaybeLock::Download {
	url,
	descriptor,
	authorization,
	} => Ok(MaybePackage::Download {
	url,
	descriptor,
	authorization,
	}),
	}
	}
	fn finish_download(&mut self, package: PackageId, data: Vec<u8>) -> CargoResult<Package> {
	let hash = loop {
	match self.index.hash(package, &mut *self.ops)? {
	Poll::Pending => self.block_until_ready()?,
	Poll::Ready(hash) => break hash,
	}
	};
	let file = self.ops.finish_download(package, hash, &data)?;
	self.get_pkg(package, &file)
	}

The simplest change would be to have download / finish_downloadreturn aPathBuf` to the manifest and have the caller parse them in parallel.

However, that doesn't work for git because it already parses en masse and would require re-parsing. For git, we forward to Path

cargo/src/cargo/sources/git/source.rs

Lines 372 to 383 in 2251525

	fn download(&mut self, id: PackageId) -> CargoResult<MaybePackage> {
	trace!(
	"getting packages for package ID `{}` from `{:?}`",
	id,
	self.remote
	);
	self.mark_used()?;
	self.path_source
	.as_mut()
	.expect("BUG: `update()` must be called before `get()`")
	.download(id)
	}

which loads the repo all at once and then returns individual items

cargo/src/cargo/sources/path.rs

Lines 359 to 366 in 2251525

	fn download(&mut self, id: PackageId) -> CargoResult<MaybePackage> {
	trace!("getting packages; id={}", id);
	self.load()?;
	let pkg = self.packages.get(&id);
	pkg.map(|pkgs| first_package(id, pkgs, &mut self.warned_duplicate, self.gctx).clone())
	.map(MaybePackage::Ready)
	.ok_or_else(|| internal(format!("failed to find {} in path source", id)))
	}

This is important because git is indexed by a package name.

We could maybe have an an enum that returns PathBuf | Package but RegistrySource needs to store and then set the checksum on the Package that eventually gets loaded

cargo/src/cargo/sources/registry/mod.rs

Lines 702 to 711 in 2251525

	// After we've loaded the package configure its summary's `checksum`
	// field with the checksum we know for this `PackageId`.
	let cksum = self
	.index
	.hash(package, &mut *self.ops)
	.expect("a downloaded dep now pending!?")
	.expect("summary not found");
	pkg.manifest_mut()
	.summary_mut()
	.set_checksum(cksum.to_string());