bench compact proof size

client/db/src/bench.rs

@@ -23,7 +23,7 @@ use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
 
 use hash_db::{Prefix, Hasher};
-use sp_trie::{MemoryDB, prefixed_key, StorageProof};
+use sp_trie::{MemoryDB, prefixed_key, StorageProof, encode_compact};
 use sp_core::{
 	storage::{ChildInfo, TrackedStorageKey},
 	hexdisplay::HexDisplay
@@ -517,14 +517,20 @@ impl<B: BlockT> StateBackend<HashFor<B>> for BenchmarkingState<B> {
 		self.state.borrow().as_ref().map_or(sp_state_machine::UsageInfo::empty(), |s| s.usage_info())
 	}
 
-	fn proof_size(&self) -> Option<u32> {
+	fn proof_size(&self) -> Option<(u32, u32)> {
 		self.proof_recorder.as_ref().map(|recorder| {
 			let proof = StorageProof::new(recorder
 				.read()
 				.iter()
 				.filter_map(|(_k, v)| v.as_ref().map(|v| v.to_vec()))
 				.collect());
-			proof.encoded_size() as u32
+			let proof_size = proof.encoded_size() as u32;
+			let compact_proof = encode_compact::<sp_trie::Layout<HashFor<B>>>(
+				proof,
+				self.root.get(),
+			).unwrap();
+
+			(proof_size, compact_proof.encoded_size() as u32)
 		})
 	}
 }

frame/benchmarking/src/analysis.rs

@@ -39,6 +39,7 @@ pub enum BenchmarkSelector {
 	Reads,
 	Writes,
 	ProofSize,
+	CompactProofSize,
 }
 
 #[derive(Debug)]
@@ -88,6 +89,7 @@ impl Analysis {
 				BenchmarkSelector::Reads => result.reads.into(),
 				BenchmarkSelector::Writes => result.writes.into(),
 				BenchmarkSelector::ProofSize => result.proof_size.into(),
+				BenchmarkSelector::CompactProofSize => result.compact_proof_size.into(),
 			}
 		).collect();
 
@@ -129,6 +131,7 @@ impl Analysis {
 						BenchmarkSelector::Reads => result.reads.into(),
 						BenchmarkSelector::Writes => result.writes.into(),
 						BenchmarkSelector::ProofSize => result.proof_size.into(),
+						BenchmarkSelector::CompactProofSize => result.compact_proof_size.into(),
 					};
 					(result.components[i].1, data)
 				})
@@ -194,6 +197,7 @@ impl Analysis {
 					BenchmarkSelector::Reads => result.reads.into(),
 					BenchmarkSelector::Writes => result.writes.into(),
 					BenchmarkSelector::ProofSize => result.proof_size.into(),
+					BenchmarkSelector::CompactProofSize => result.compact_proof_size.into(),
 				})
 		}
 
@@ -375,6 +379,7 @@ mod tests {
 			writes,
 			repeat_writes: 0,
 			proof_size: 0,
+			compact_proof_size: 0,
 		}
 	}
 

frame/benchmarking/src/lib.rs

@@ -774,8 +774,11 @@ macro_rules! impl_benchmark {
 
 							// Calculate the diff caused by the benchmark.
 							let elapsed_extrinsic = finish_extrinsic.saturating_sub(start_extrinsic);
-							let diff_pov = match (start_pov, end_pov) {
-								(Some(start), Some(end)) => end.saturating_sub(start),
+							let (diff_pov, compact_diff_pov) = match (start_pov, end_pov) {
+								(Some((start, compact_start)), Some((end, compact_end))) => (
+									end.saturating_sub(start),
+									compact_end.saturating_sub(compact_start),
+								),
 								_ => Default::default(),
 							};
 
@@ -806,6 +809,7 @@ macro_rules! impl_benchmark {
 								writes: read_write_count.2,
 								repeat_writes: read_write_count.3,
 								proof_size: diff_pov,
+								compact_proof_size: compact_diff_pov,
 							});
 						}
 

frame/benchmarking/src/utils.rs

@@ -63,6 +63,7 @@ pub struct BenchmarkResults {
 	pub writes: u32,
 	pub repeat_writes: u32,
 	pub proof_size: u32,
+	pub compact_proof_size: u32,
 }
 
 /// Configuration used to setup and run runtime benchmarks.
@@ -165,7 +166,7 @@ pub trait Benchmarking {
 	}
 
 	/// Get current estimated proof size.
-	fn proof_size(&self) -> Option<u32> {
+	fn proof_size(&self) -> Option<(u32, u32)> {
 		self.proof_size()
 	}
 }

primitives/externalities/src/lib.rs

@@ -288,7 +288,7 @@ pub trait Externalities: ExtensionStore {
 	///
 	/// Returns estimated proof size for the state queries so far.
 	/// Proof is reset on commit and wipe.
-	fn proof_size(&self) -> Option<u32> {
+	fn proof_size(&self) -> Option<(u32, u32)> {
 		None
 	}
 }

primitives/state-machine/src/backend.rs

@@ -247,7 +247,7 @@ pub trait Backend<H: Hasher>: sp_std::fmt::Debug {
 	fn set_whitelist(&self, _: Vec<TrackedStorageKey>) {}
 
 	/// Estimate proof size
-	fn proof_size(&self) -> Option<u32> {
+	fn proof_size(&self) -> Option<(u32, u32)> {
 		unimplemented!()
 	}
 }

primitives/state-machine/src/ext.rs

@@ -713,7 +713,7 @@ where
 		self.backend.set_whitelist(new)
 	}
 
-	fn proof_size(&self) -> Option<u32> {
+	fn proof_size(&self) -> Option<(u32, u32)> {
 		self.backend.proof_size()
 	}
 }

utils/frame/benchmarking-cli/src/command.rs

@@ -126,20 +126,21 @@ impl BenchmarkCmd {
 						// Print the table header
 						batch.results[0].components.iter().for_each(|param| print!("{:?},", param.0));
 
-						print!("extrinsic_time_ns,storage_root_time_ns,reads,repeat_reads,writes,repeat_writes,proof_size_bytes\n");
+						print!("extrinsic_time_ns,storage_root_time_ns,reads,repeat_reads,writes,repeat_writes,proof_size_bytes,compact_proof_size_bytes\n");
 						// Print the values
 						batch.results.iter().for_each(|result| {
 							let parameters = &result.components;
 							parameters.iter().for_each(|param| print!("{:?},", param.1));
 							// Print extrinsic time and storage root time
-							print!("{:?},{:?},{:?},{:?},{:?},{:?},{:?}\n",
+							print!("{:?},{:?},{:?},{:?},{:?},{:?},{:?},{:?}\n",
 								result.extrinsic_time,
 								result.storage_root_time,
 								result.reads,
 								result.repeat_reads,
 								result.writes,
 								result.repeat_writes,
 								result.proof_size,
+								result.compact_proof_size,
 							);
 						});
 

utils/frame/benchmarking-cli/src/writer.rs

@@ -422,6 +422,7 @@ mod test {
 					writes: (base + slope * i).into(),
 					repeat_writes: 0,
 					proof_size: 0,
+					compact_proof_size: 0,
 				}
 			)
 		}