replace HistoricalValidationCode usages with ValidationCodeByHash (#3210)

* replace HistoricalValidationCode usages with ValidationCodeByHash

* runtime-api: tabify tests file

* update implementers guide

polkadot/node/core/runtime-api/src/cache.rs

@@ -14,20 +14,18 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use polkadot_primitives::v1::{
-	BlockNumber, CandidateCommitments, CommittedCandidateReceipt, CandidateEvent,
-	CoreState, GroupRotationInfo, InboundDownwardMessage, InboundHrmpMessage, Hash,
-	PersistedValidationData, Id as ParaId, OccupiedCoreAssumption,
-	SessionIndex, SessionInfo, ValidationCode, ValidatorId, ValidatorIndex,
-	AuthorityDiscoveryId,
-};
-use sp_consensus_babe::Epoch;
-use parity_util_mem::{MallocSizeOf, MallocSizeOfExt};
-
+use std::collections::btree_map::BTreeMap;
 
 use memory_lru::{MemoryLruCache, ResidentSize};
+use parity_util_mem::{MallocSizeOf, MallocSizeOfExt};
+use sp_consensus_babe::Epoch;
 
-use std::collections::btree_map::BTreeMap;
+use polkadot_primitives::v1::{
+	AuthorityDiscoveryId, BlockNumber, CandidateCommitments, CandidateEvent,
+	CommittedCandidateReceipt, CoreState, GroupRotationInfo, Hash, Id as ParaId,
+	InboundDownwardMessage, InboundHrmpMessage, OccupiedCoreAssumption, PersistedValidationData,
+	SessionIndex, SessionInfo, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex,
+};
 
 const AUTHORITIES_CACHE_SIZE: usize = 128 * 1024;
 const VALIDATORS_CACHE_SIZE: usize = 64 * 1024;
@@ -37,7 +35,6 @@ const PERSISTED_VALIDATION_DATA_CACHE_SIZE: usize = 64 * 1024;
 const CHECK_VALIDATION_OUTPUTS_CACHE_SIZE: usize = 64 * 1024;
 const SESSION_INDEX_FOR_CHILD_CACHE_SIZE: usize = 64 * 1024;
 const VALIDATION_CODE_CACHE_SIZE: usize = 10 * 1024 * 1024;
-const HISTORICAL_VALIDATION_CODE_CACHE_SIZE: usize = 10 * 1024 * 1024;
 const CANDIDATE_PENDING_AVAILABILITY_CACHE_SIZE: usize = 64 * 1024;
 const CANDIDATE_EVENTS_CACHE_SIZE: usize = 64 * 1024;
 const SESSION_INFO_CACHE_SIZE: usize = 64 * 1024;
@@ -80,7 +77,7 @@ pub(crate) struct RequestResultCache {
 	check_validation_outputs: MemoryLruCache<(Hash, ParaId, CandidateCommitments), ResidentSizeOf<bool>>,
 	session_index_for_child: MemoryLruCache<Hash, ResidentSizeOf<SessionIndex>>,
 	validation_code: MemoryLruCache<(Hash, ParaId, OccupiedCoreAssumption), ResidentSizeOf<Option<ValidationCode>>>,
-	historical_validation_code: MemoryLruCache<(Hash, ParaId, BlockNumber), ResidentSizeOf<Option<ValidationCode>>>,
+	validation_code_by_hash: MemoryLruCache<(Hash, ValidationCodeHash), ResidentSizeOf<Option<ValidationCode>>>,
 	candidate_pending_availability: MemoryLruCache<(Hash, ParaId), ResidentSizeOf<Option<CommittedCandidateReceipt>>>,
 	candidate_events: MemoryLruCache<Hash, ResidentSizeOf<Vec<CandidateEvent>>>,
 	session_info: MemoryLruCache<(Hash, SessionIndex), ResidentSizeOf<Option<SessionInfo>>>,
@@ -100,7 +97,7 @@ impl Default for RequestResultCache {
 			check_validation_outputs: MemoryLruCache::new(CHECK_VALIDATION_OUTPUTS_CACHE_SIZE),
 			session_index_for_child: MemoryLruCache::new(SESSION_INDEX_FOR_CHILD_CACHE_SIZE),
 			validation_code: MemoryLruCache::new(VALIDATION_CODE_CACHE_SIZE),
-			historical_validation_code: MemoryLruCache::new(HISTORICAL_VALIDATION_CODE_CACHE_SIZE),
+			validation_code_by_hash: MemoryLruCache::new(VALIDATION_CODE_CACHE_SIZE),
 			candidate_pending_availability: MemoryLruCache::new(CANDIDATE_PENDING_AVAILABILITY_CACHE_SIZE),
 			candidate_events: MemoryLruCache::new(CANDIDATE_EVENTS_CACHE_SIZE),
 			session_info: MemoryLruCache::new(SESSION_INFO_CACHE_SIZE),
@@ -176,12 +173,12 @@ impl RequestResultCache {
 		self.validation_code.insert(key, ResidentSizeOf(value));
 	}
 
-	pub(crate) fn historical_validation_code(&mut self, key: (Hash, ParaId, BlockNumber)) -> Option<&Option<ValidationCode>> {
-		self.historical_validation_code.get(&key).map(|v| &v.0)
+	pub(crate) fn validation_code_by_hash(&mut self, key: (Hash, ValidationCodeHash)) -> Option<&Option<ValidationCode>> {
+		self.validation_code_by_hash.get(&key).map(|v| &v.0)
 	}
 
-	pub(crate) fn cache_historical_validation_code(&mut self, key: (Hash, ParaId, BlockNumber), value: Option<ValidationCode>) {
-		self.historical_validation_code.insert(key, ResidentSizeOf(value));
+	pub(crate) fn cache_validation_code_by_hash(&mut self, key: (Hash, ValidationCodeHash), value: Option<ValidationCode>) {
+		self.validation_code_by_hash.insert(key, ResidentSizeOf(value));
 	}
 
 	pub(crate) fn candidate_pending_availability(&mut self, key: (Hash, ParaId)) -> Option<&Option<CommittedCandidateReceipt>> {
@@ -242,7 +239,7 @@ pub(crate) enum RequestResult {
 	CheckValidationOutputs(Hash, ParaId, CandidateCommitments, bool),
 	SessionIndexForChild(Hash, SessionIndex),
 	ValidationCode(Hash, ParaId, OccupiedCoreAssumption, Option<ValidationCode>),
-	HistoricalValidationCode(Hash, ParaId, BlockNumber, Option<ValidationCode>),
+	ValidationCodeByHash(Hash, ValidationCodeHash, Option<ValidationCode>),
 	CandidatePendingAvailability(Hash, ParaId, Option<CommittedCandidateReceipt>),
 	CandidateEvents(Hash, Vec<CandidateEvent>),
 	SessionInfo(Hash, SessionIndex, Option<SessionInfo>),

polkadot/node/core/runtime-api/src/lib.rs

@@ -119,8 +119,8 @@ impl<Client> RuntimeApiSubsystem<Client> where
 				self.requests_cache.cache_session_index_for_child(relay_parent, session_index),
 			ValidationCode(relay_parent, para_id, assumption, code) =>
 				self.requests_cache.cache_validation_code((relay_parent, para_id, assumption), code),
-			HistoricalValidationCode(relay_parent, para_id, n, code) =>
-				self.requests_cache.cache_historical_validation_code((relay_parent, para_id, n), code),
+			ValidationCodeByHash(relay_parent, validation_code_hash, code) =>
+				self.requests_cache.cache_validation_code_by_hash((relay_parent, validation_code_hash), code),
 			CandidatePendingAvailability(relay_parent, para_id, candidate) =>
 				self.requests_cache.cache_candidate_pending_availability((relay_parent, para_id), candidate),
 			CandidateEvents(relay_parent, events) =>
@@ -183,9 +183,9 @@ impl<Client> RuntimeApiSubsystem<Client> where
 			Request::ValidationCode(para, assumption, sender) =>
 				query!(validation_code(para, assumption), sender)
 					.map(|sender| Request::ValidationCode(para, assumption, sender)),
-			Request::HistoricalValidationCode(para, at, sender) =>
-				query!(historical_validation_code(para, at), sender)
-					.map(|sender| Request::HistoricalValidationCode(para, at, sender)),
+			Request::ValidationCodeByHash(validation_code_hash, sender) =>
+				query!(validation_code_by_hash(validation_code_hash), sender)
+					.map(|sender| Request::ValidationCodeByHash(validation_code_hash, sender)),
 			Request::CandidatePendingAvailability(para, sender) =>
 				query!(candidate_pending_availability(para), sender)
 					.map(|sender| Request::CandidatePendingAvailability(para, sender)),
@@ -341,8 +341,8 @@ where
 		Request::SessionIndexForChild(sender) => query!(SessionIndexForChild, session_index_for_child(), sender),
 		Request::ValidationCode(para, assumption, sender) =>
 			query!(ValidationCode, validation_code(para, assumption), sender),
-		Request::HistoricalValidationCode(para, at, sender) =>
-			query!(HistoricalValidationCode, historical_validation_code(para, at), sender),
+		Request::ValidationCodeByHash(validation_code_hash, sender) =>
+			query!(ValidationCodeByHash, validation_code_by_hash(validation_code_hash), sender),
 		Request::CandidatePendingAvailability(para, sender) =>
 			query!(CandidatePendingAvailability, candidate_pending_availability(para), sender),
 		Request::CandidateEvents(sender) => query!(CandidateEvents, candidate_events(), sender),