Remove mem_info and references to parity-util-mem (#12795)

* Remove mem_info and some references to parity-util-mem

* [Draft] Finish removing references to `parity-util-mem`

* Upgrade dependencies

* Update scripts/ci/deny.toml

Co-authored-by: ordian <write@reusable.software>

* Fix Cargo.lock (remove unwanted dependency changes)

* Removed unused argument

* Run cargo fmt (didn't have pre-commit set up)

* Fix some CI errors

* Fix another CI error

* Remove unused dependency

Co-authored-by: ordian <write@reusable.software>

substrate/client/transaction-pool/src/graph/base_pool.rs

@@ -84,7 +84,7 @@ pub struct PruneStatus<Hash, Ex> {
 
 /// Immutable transaction
 #[cfg_attr(test, derive(Clone))]
-#[derive(PartialEq, Eq, parity_util_mem::MallocSizeOf)]
+#[derive(PartialEq, Eq)]
 pub struct Transaction<Hash, Extrinsic> {
 	/// Raw extrinsic representing that transaction.
 	pub data: Extrinsic,
@@ -207,7 +207,7 @@ const RECENTLY_PRUNED_TAGS: usize = 2;
 /// as-is for the second time will fail or produce unwanted results.
 /// Most likely it is required to revalidate them and recompute set of
 /// required tags.
-#[derive(Debug, parity_util_mem::MallocSizeOf)]
+#[derive(Debug)]
 pub struct BasePool<Hash: hash::Hash + Eq, Ex> {
 	reject_future_transactions: bool,
 	future: FutureTransactions<Hash, Ex>,
@@ -796,27 +796,6 @@ mod tests {
 		}
 	}
 
-	#[test]
-	fn can_track_heap_size() {
-		let mut pool = pool();
-		pool.import(Transaction {
-			data: vec![5u8; 1024],
-			hash: 5,
-			provides: vec![vec![0], vec![4]],
-			..DEFAULT_TX.clone()
-		})
-		.expect("import 1 should be ok");
-		pool.import(Transaction {
-			data: vec![3u8; 1024],
-			hash: 7,
-			provides: vec![vec![2], vec![7]],
-			..DEFAULT_TX.clone()
-		})
-		.expect("import 2 should be ok");
-
-		assert!(parity_util_mem::malloc_size(&pool) > 5000);
-	}
-
 	#[test]
 	fn should_remove_invalid_transactions() {
 		// given

substrate/client/transaction-pool/src/graph/future.rs

@@ -28,7 +28,6 @@ use std::time::Instant;
 
 use super::base_pool::Transaction;
 
-#[derive(parity_util_mem::MallocSizeOf)]
 /// Transaction with partially satisfied dependencies.
 pub struct WaitingTransaction<Hash, Ex> {
 	/// Transaction details.
@@ -108,7 +107,7 @@ impl<Hash, Ex> WaitingTransaction<Hash, Ex> {
 ///
 /// Contains transactions that are still awaiting for some other transactions that
 /// could provide a tag that they require.
-#[derive(Debug, parity_util_mem::MallocSizeOf)]
+#[derive(Debug)]
 pub struct FutureTransactions<Hash: hash::Hash + Eq, Ex> {
 	/// tags that are not yet provided by any transaction and we await for them
 	wanted_tags: HashMap<Tag, HashSet<Hash>>,
@@ -251,33 +250,3 @@ impl<Hash: hash::Hash + Eq + Clone, Ex> FutureTransactions<Hash, Ex> {
 		self.waiting.values().fold(0, |acc, tx| acc + tx.transaction.bytes)
 	}
 }
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-	use sp_runtime::transaction_validity::TransactionSource;
-
-	#[test]
-	fn can_track_heap_size() {
-		let mut future = FutureTransactions::default();
-		future.import(WaitingTransaction {
-			transaction: Transaction {
-				data: vec![0u8; 1024],
-				bytes: 1,
-				hash: 1,
-				priority: 1,
-				valid_till: 2,
-				requires: vec![vec![1], vec![2]],
-				provides: vec![vec![3], vec![4]],
-				propagate: true,
-				source: TransactionSource::External,
-			}
-			.into(),
-			missing_tags: vec![vec![1u8], vec![2u8]].into_iter().collect(),
-			imported_at: std::time::Instant::now(),
-		});
-
-		// data is at least 1024!
-		assert!(parity_util_mem::malloc_size(&future) > 1024);
-	}
-}

substrate/client/transaction-pool/src/graph/pool.rs

@@ -144,15 +144,6 @@ pub struct Pool<B: ChainApi> {
 	validated_pool: Arc<ValidatedPool<B>>,
 }
 
-impl<B: ChainApi> parity_util_mem::MallocSizeOf for Pool<B>
-where
-	ExtrinsicFor<B>: parity_util_mem::MallocSizeOf,
-{
-	fn size_of(&self, ops: &mut parity_util_mem::MallocSizeOfOps) -> usize {
-		self.validated_pool.size_of(ops)
-	}
-}
-
 impl<B: ChainApi> Pool<B> {
 	/// Create a new transaction pool.
 	pub fn new(options: Options, is_validator: IsValidator, api: Arc<B>) -> Self {

substrate/client/transaction-pool/src/graph/ready.rs

@@ -37,7 +37,7 @@ use super::{
 /// An in-pool transaction reference.
 ///
 /// Should be cheap to clone.
-#[derive(Debug, parity_util_mem::MallocSizeOf)]
+#[derive(Debug)]
 pub struct TransactionRef<Hash, Ex> {
 	/// The actual transaction data.
 	pub transaction: Arc<Transaction<Hash, Ex>>,
@@ -74,7 +74,7 @@ impl<Hash, Ex> PartialEq for TransactionRef<Hash, Ex> {
 }
 impl<Hash, Ex> Eq for TransactionRef<Hash, Ex> {}
 
-#[derive(Debug, parity_util_mem::MallocSizeOf)]
+#[derive(Debug)]
 pub struct ReadyTx<Hash, Ex> {
 	/// A reference to a transaction
 	pub transaction: TransactionRef<Hash, Ex>,
@@ -105,7 +105,7 @@ qed
 "#;
 
 /// Validated transactions that are block ready with all their dependencies met.
-#[derive(Debug, parity_util_mem::MallocSizeOf)]
+#[derive(Debug)]
 pub struct ReadyTransactions<Hash: hash::Hash + Eq, Ex> {
 	/// Next free insertion id (used to indicate when a transaction was inserted into the pool).
 	insertion_id: u64,
@@ -742,25 +742,6 @@ mod tests {
 		assert_eq!(it.next(), None);
 	}
 
-	#[test]
-	fn can_report_heap_size() {
-		let mut ready = ReadyTransactions::default();
-		let tx = Transaction {
-			data: vec![5],
-			bytes: 1,
-			hash: 5,
-			priority: 1,
-			valid_till: u64::MAX, // use the max here for testing.
-			requires: vec![],
-			provides: vec![],
-			propagate: true,
-			source: Source::External,
-		};
-		import(&mut ready, tx).unwrap();
-
-		assert!(parity_util_mem::malloc_size(&ready) > 200);
-	}
-
 	#[test]
 	fn should_order_refs() {
 		let mut id = 1;

substrate/client/transaction-pool/src/graph/tracked_map.rs

@@ -33,7 +33,7 @@ pub trait Size {
 /// Map with size tracking.
 ///
 /// Size reported might be slightly off and only approximately true.
-#[derive(Debug, parity_util_mem::MallocSizeOf)]
+#[derive(Debug)]
 pub struct TrackedMap<K, V> {
 	index: Arc<RwLock<HashMap<K, V>>>,
 	bytes: AtomicIsize,

substrate/client/transaction-pool/src/graph/validated_pool.rs

@@ -110,16 +110,6 @@ pub struct ValidatedPool<B: ChainApi> {
 	rotator: PoolRotator<ExtrinsicHash<B>>,
 }
 
-impl<B: ChainApi> parity_util_mem::MallocSizeOf for ValidatedPool<B>
-where
-	ExtrinsicFor<B>: parity_util_mem::MallocSizeOf,
-{
-	fn size_of(&self, ops: &mut parity_util_mem::MallocSizeOfOps) -> usize {
-		// other entries insignificant or non-primary references
-		self.pool.size_of(ops)
-	}
-}
-
 impl<B: ChainApi> ValidatedPool<B> {
 	/// Create a new transaction pool.
 	pub fn new(options: Options, is_validator: IsValidator, api: Arc<B>) -> Self {