Preserve artifact cache unless stale

polkadot/node/core/candidate-validation/src/lib.rs

@@ -25,7 +25,7 @@
 
 use polkadot_node_core_pvf::{
 	InternalValidationError, InvalidCandidate as WasmInvalidCandidate, PrepareError,
-	PrepareJobKind, PrepareStats, PvfPrepData, ValidationError, ValidationHost,
+	PrepareJobKind, PvfPrepData, ValidationError, ValidationHost,
 };
 use polkadot_node_primitives::{
 	BlockData, InvalidCandidate, PoV, ValidationResult, POV_BOMB_LIMIT, VALIDATION_CODE_BOMB_LIMIT,
@@ -788,7 +788,7 @@ trait ValidationBackend {
 		validation_result
 	}
 
-	async fn precheck_pvf(&mut self, pvf: PvfPrepData) -> Result<PrepareStats, PrepareError>;
+	async fn precheck_pvf(&mut self, pvf: PvfPrepData) -> Result<(), PrepareError>;
 }
 
 #[async_trait]
@@ -818,7 +818,7 @@ impl ValidationBackend for ValidationHost {
 		})?
 	}
 
-	async fn precheck_pvf(&mut self, pvf: PvfPrepData) -> Result<PrepareStats, PrepareError> {
+	async fn precheck_pvf(&mut self, pvf: PvfPrepData) -> Result<(), PrepareError> {
 		let (tx, rx) = oneshot::channel();
 		if let Err(err) = self.precheck_pvf(pvf, tx).await {
 			// Return an IO error if there was an error communicating with the host.

polkadot/node/core/candidate-validation/src/tests.rs

@@ -377,7 +377,7 @@ impl ValidationBackend for MockValidateCandidateBackend {
 		result
 	}
 
-	async fn precheck_pvf(&mut self, _pvf: PvfPrepData) -> Result<PrepareStats, PrepareError> {
+	async fn precheck_pvf(&mut self, _pvf: PvfPrepData) -> Result<(), PrepareError> {
 		unreachable!()
 	}
 }
@@ -1012,11 +1012,11 @@ fn pov_decompression_failure_is_invalid() {
 }
 
 struct MockPreCheckBackend {
-	result: Result<PrepareStats, PrepareError>,
+	result: Result<(), PrepareError>,
 }
 
 impl MockPreCheckBackend {
-	fn with_hardcoded_result(result: Result<PrepareStats, PrepareError>) -> Self {
+	fn with_hardcoded_result(result: Result<(), PrepareError>) -> Self {
 		Self { result }
 	}
 }
@@ -1032,7 +1032,7 @@ impl ValidationBackend for MockPreCheckBackend {
 		unreachable!()
 	}
 
-	async fn precheck_pvf(&mut self, _pvf: PvfPrepData) -> Result<PrepareStats, PrepareError> {
+	async fn precheck_pvf(&mut self, _pvf: PvfPrepData) -> Result<(), PrepareError> {
 		self.result.clone()
 	}
 }
@@ -1049,7 +1049,7 @@ fn precheck_works() {
 
 	let (check_fut, check_result) = precheck_pvf(
 		ctx.sender(),
-		MockPreCheckBackend::with_hardcoded_result(Ok(PrepareStats::default())),
+		MockPreCheckBackend::with_hardcoded_result(Ok(())),
 		relay_parent,
 		validation_code_hash,
 	)
@@ -1111,7 +1111,7 @@ fn precheck_invalid_pvf_blob_compression() {
 
 	let (check_fut, check_result) = precheck_pvf(
 		ctx.sender(),
-		MockPreCheckBackend::with_hardcoded_result(Ok(PrepareStats::default())),
+		MockPreCheckBackend::with_hardcoded_result(Ok(())),
 		relay_parent,
 		validation_code_hash,
 	)

polkadot/node/core/pvf/Cargo.toml

@@ -8,6 +8,7 @@ license.workspace = true
 
 [dependencies]
 always-assert = "0.1"
+blake3 = "1.5"
 cfg-if = "1.0"
 futures = "0.3.21"
 futures-timer = "3.0.2"

polkadot/node/core/pvf/benches/host_prepare_rococo_runtime.rs

@@ -56,7 +56,7 @@ impl TestHost {
 		&self,
 		code: &[u8],
 		executor_params: ExecutorParams,
-	) -> Result<PrepareStats, PrepareError> {
+	) -> Result<(), PrepareError> {
 		let (result_tx, result_rx) = futures::channel::oneshot::channel();
 
 		let code = sp_maybe_compressed_blob::decompress(code, 16 * 1024 * 1024)

polkadot/node/core/pvf/common/Cargo.toml

@@ -2,6 +2,7 @@
 name = "polkadot-node-core-pvf-common"
 description = "Polkadot crate that contains functionality related to PVFs that is shared by the PVF host and the PVF workers."
 version = "1.0.0"
+build = "build.rs"
 authors.workspace = true
 edition.workspace = true
 license.workspace = true

polkadot/node/core/pvf/common/build.rs

@@ -0,0 +1,28 @@
+fn main() {
+	get_wasmtime_version();
+}
+
+pub fn get_wasmtime_version() {
+	// we only care about the root of the tree
+	match std::process::Command::new("cargo")
+		.args(&["tree", "--package=wasmtime", "--depth=0"])
+		.output()
+	{
+		Ok(out) if out.status.success() => {
+			// wasmtime vX.X.X
+			let version = String::from_utf8_lossy(&out.stdout);
+			if let Some(version) = version.strip_prefix("wasmtime v") {
+				println!("cargo:rustc-env=SUBSTRATE_WASMTIME_VERSION={}", version);
+			} else {
+				println!("cargo:warning=build.rs: unexpected result {}", version);
+			}
+		},
+		Ok(out) => println!(
+			"cargo:warning=build.rs: `cargo tree` {}",
+			String::from_utf8_lossy(&out.stderr),
+		),
+		Err(err) => {
+			println!("cargo:warning=build.rs: Could not run `cargo tree`: {}", err);
+		},
+	}
+}

polkadot/node/core/pvf/common/src/error.rs

@@ -14,13 +14,21 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use crate::prepare::PrepareStats;
+use crate::prepare::{PrepareSuccess, PrepareWorkerSuccess};
 use parity_scale_codec::{Decode, Encode};
 use std::fmt;
 
-/// Result of PVF preparation performed by the validation host. Contains stats about the preparation
-/// if successful
-pub type PrepareResult = Result<PrepareStats, PrepareError>;
+/// Result of PVF preparation from a worker, with checksum of the compiled PVF and stats of the
+/// preparation if successful.
+pub type PrepareWorkerResult = Result<PrepareWorkerSuccess, PrepareError>;
+
+/// Result of PVF preparation propagated all the way back to the host, with path to the concluded
+/// artifact and stats of the preparation if successful.
+pub type PrepareResult = Result<PrepareSuccess, PrepareError>;
+
+/// Result of prechecking PVF performed by the validation host. Contains stats about the preparation
+/// if successful.
+pub type PrecheckResult = Result<(), PrepareError>;
 
 /// An error that occurred during the prepare part of the PVF pipeline.
 // Codec indexes are intended to stabilize pre-encoded payloads (see `OOM_PAYLOAD` below)
@@ -70,7 +78,7 @@ pub enum PrepareError {
 	ClearWorkerDir(String),
 }
 
-/// Pre-encoded length-prefixed `PrepareResult::Err(PrepareError::OutOfMemory)`
+/// Pre-encoded length-prefixed `PrepareWorkerResult::Err(PrepareError::OutOfMemory)`
 pub const OOM_PAYLOAD: &[u8] = b"\x02\x00\x00\x00\x00\x00\x00\x00\x01\x08";
 
 impl PrepareError {
@@ -167,7 +175,7 @@ impl fmt::Display for InternalValidationError {
 
 #[test]
 fn pre_encoded_payloads() {
-	let oom_enc = PrepareResult::Err(PrepareError::OutOfMemory).encode();
+	let oom_enc = PrepareWorkerResult::Err(PrepareError::OutOfMemory).encode();
 	let mut oom_payload = oom_enc.len().to_le_bytes().to_vec();
 	oom_payload.extend(oom_enc);
 	assert_eq!(oom_payload, OOM_PAYLOAD);

polkadot/node/core/pvf/common/src/lib.rs

@@ -31,6 +31,8 @@ pub use sp_tracing;
 
 const LOG_TARGET: &str = "parachain::pvf-common";
 
+pub const RUNTIME_VERSION: &str = env!("SUBSTRATE_WASMTIME_VERSION");
+
 use std::{
 	io::{self, Read, Write},
 	mem,

polkadot/node/core/pvf/common/src/prepare.rs

@@ -15,6 +15,25 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use parity_scale_codec::{Decode, Encode};
+use std::path::PathBuf;
+
+/// Result from prepare worker if successful.
+#[derive(Debug, Clone, Default, Encode, Decode)]
+pub struct PrepareWorkerSuccess {
+	/// Checksum of the compiled PVF.
+	pub checksum: String,
+	/// Stats of the current preparation run.
+	pub stats: PrepareStats,
+}
+
+/// Result of PVF preparation if successful.
+#[derive(Debug, Clone, Default)]
+pub struct PrepareSuccess {
+	/// Canonical path to the compiled artifact.
+	pub path: PathBuf,
+	/// Stats of the current preparation run.
+	pub stats: PrepareStats,
+}
 
 /// Preparation statistics, including the CPU time and memory taken.
 #[derive(Debug, Clone, Default, Encode, Decode)]

polkadot/node/core/pvf/common/src/pvf.rs

@@ -115,7 +115,7 @@ impl fmt::Debug for PvfPrepData {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		write!(
 			f,
-			"Pvf {{ code, code_hash: {:?}, executor_params: {:?}, prep_timeout: {:?} }}",
+			"Pvf {{ code_hash: {:?}, executor_params: {:?}, prep_timeout: {:?} }}",
 			self.code_hash, self.executor_params, self.prep_timeout
 		)
 	}

polkadot/node/core/pvf/prepare-worker/Cargo.toml

@@ -7,6 +7,7 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
+blake3 = "1.5"
 cfg-if = "1.0"
 gum = { package = "tracing-gum", path = "../../../gum" }
 libc = "0.2.139"

polkadot/node/core/pvf/prepare-worker/src/lib.rs

@@ -30,10 +30,10 @@ use crate::memory_stats::max_rss_stat::{extract_max_rss_stat, get_max_rss_thread
 use crate::memory_stats::memory_tracker::{get_memory_tracker_loop_stats, memory_tracker_loop};
 use parity_scale_codec::{Decode, Encode};
 use polkadot_node_core_pvf_common::{
-	error::{PrepareError, PrepareResult, OOM_PAYLOAD},
+	error::{PrepareError, PrepareWorkerResult, OOM_PAYLOAD},
 	executor_intf::create_runtime_from_artifact_bytes,
 	framed_recv_blocking, framed_send_blocking,
-	prepare::{MemoryStats, PrepareJobKind, PrepareStats},
+	prepare::{MemoryStats, PrepareJobKind, PrepareStats, PrepareWorkerSuccess},
 	pvf::PvfPrepData,
 	worker::{
 		cpu_time_monitor_loop, stringify_panic_payload,
@@ -91,7 +91,7 @@ fn recv_request(stream: &mut UnixStream) -> io::Result<PvfPrepData> {
 	Ok(pvf)
 }
 
-fn send_response(stream: &mut UnixStream, result: PrepareResult) -> io::Result<()> {
+fn send_response(stream: &mut UnixStream, result: PrepareWorkerResult) -> io::Result<()> {
 	framed_send_blocking(stream, &result.encode())
 }
 
@@ -165,8 +165,8 @@ fn end_memory_tracking() -> isize {
 ///
 /// 6. If compilation succeeded, write the compiled artifact into a temporary file.
 ///
-/// 7. Send the result of preparation back to the host. If any error occurred in the above steps, we
-///    send that in the `PrepareResult`.
+/// 7. Send the result of preparation back to the host, including the checksum of the artifact. If
+///    any error occurred in the above steps, we send that in the `PrepareWorkerResult`.
 pub fn worker_entrypoint(
 	socket_path: PathBuf,
 	worker_dir_path: PathBuf,
@@ -341,7 +341,12 @@ pub fn worker_entrypoint(
 								);
 								fs::write(&temp_artifact_dest, &artifact)?;
 
-								Ok(PrepareStats { cpu_time_elapsed, memory_stats })
+								let checksum =
+									blake3::hash(&artifact.as_ref()).to_hex().to_string();
+								Ok(PrepareWorkerSuccess {
+									checksum,
+									stats: PrepareStats { cpu_time_elapsed, memory_stats },
+								})
 							},
 						}
 					},