refactor(core-code) Optimisation of read-write structures for code instrumentation

common/src/benchmarking.rs

@@ -20,7 +20,7 @@ use super::*;
 
 use gear_core::{
     ids::prelude::*,
-    pages::{WasmPage, WasmPagesAmount},
+    pages::WasmPage,
     program::{MemoryInfix, ProgramState},
     reservation::GasReservationMap,
 };
@@ -117,21 +117,16 @@ pub fn generate_wasm(num_pages: WasmPage) -> Result<Vec<u8>, &'static str> {
     Ok(code)
 }
 
-pub fn set_program<ProgramStorage, BlockNumber>(
-    program_id: ProgramId,
-    code: Vec<u8>,
-    static_pages: WasmPagesAmount,
-) where
+pub fn set_program<ProgramStorage, BlockNumber>(program_id: ProgramId, code: Vec<u8>)
+where
     ProgramStorage: super::ProgramStorage<BlockNumber = BlockNumber>,
     BlockNumber: Zero + Copy + Saturating,
 {
     ProgramStorage::add_program(
         program_id,
         ActiveProgram {
             allocations_tree_len: 0,
-            code_hash: CodeId::generate(&code).into_origin(),
-            code_exports: Default::default(),
-            static_pages,
+            code_id: CodeId::generate(&code),
             state: ProgramState::Initialized,
             gas_reservation_map: GasReservationMap::default(),
             expiration_block: Zero::zero(),

common/src/code_storage.rs

@@ -18,7 +18,7 @@
 
 use super::*;
 use crate::storage::MapStorage;
-use gear_core::code::{CodeAndId, InstrumentedCode, InstrumentedCodeAndId};
+use gear_core::code::{CodeAndId, CodeAttribution, CodeMetadata, InstrumentedCode};
 
 #[derive(Clone, Copy, Debug)]
 pub enum Error {
@@ -29,44 +29,48 @@ pub enum Error {
 /// Trait to work with program binary codes in a storage.
 pub trait CodeStorage {
     type InstrumentedCodeStorage: MapStorage<Key = CodeId, Value = InstrumentedCode>;
-    type InstrumentedLenStorage: MapStorage<Key = CodeId, Value = u32>;
     type OriginalCodeStorage: MapStorage<Key = CodeId, Value = Vec<u8>>;
-    type MetadataStorage: MapStorage<Key = CodeId, Value = CodeMetadata>;
+    type CodeMetadataStorage: MapStorage<Key = CodeId, Value = CodeMetadata>;
+    type CodeAttributionStorage: MapStorage<Key = CodeId, Value = CodeAttribution>;
 
     /// Attempt to remove all items from all the associated maps.
     fn reset() {
-        Self::MetadataStorage::clear();
+        Self::CodeAttributionStorage::clear();
+        Self::CodeMetadataStorage::clear();
         Self::OriginalCodeStorage::clear();
-        Self::InstrumentedLenStorage::clear();
         Self::InstrumentedCodeStorage::clear();
     }
 
-    fn add_code(code_and_id: CodeAndId, metadata: CodeMetadata) -> Result<(), Error> {
+    /// Add the code to the storage.
+    fn add_code(code_and_id: CodeAndId, code_attribution: CodeAttribution) -> Result<(), Error> {
         let (code, code_id) = code_and_id.into_parts();
-        let (code, original_code) = code.into_parts();
+        let (instrumented_code, original_code, code_metadata) = code.into_parts();
 
         Self::InstrumentedCodeStorage::mutate(code_id, |maybe| {
             if maybe.is_some() {
                 return Err(CodeStorageError::DuplicateItem);
             }
 
-            Self::InstrumentedLenStorage::insert(code_id, code.code().len() as u32);
             Self::OriginalCodeStorage::insert(code_id, original_code);
-            Self::MetadataStorage::insert(code_id, metadata);
+            Self::CodeMetadataStorage::insert(code_id, code_metadata);
+            Self::CodeAttributionStorage::insert(code_id, code_attribution);
 
-            *maybe = Some(code);
+            *maybe = Some(instrumented_code);
             Ok(())
         })
     }
 
     /// Update the corresponding code in the storage.
-    fn update_code(code_and_id: InstrumentedCodeAndId) {
-        let (code, code_id) = code_and_id.into_parts();
+    fn update_instrumented_code(code_id: CodeId, instrumented_code: InstrumentedCode) {
+        Self::InstrumentedCodeStorage::insert(code_id, instrumented_code);
+    }
 
-        Self::InstrumentedLenStorage::insert(code_id, code.code().len() as u32);
-        Self::InstrumentedCodeStorage::insert(code_id, code);
+    /// Update the corresponding metadata in the storage.
+    fn update_code_metadata(code_id: CodeId, metadata: CodeMetadata) {
+        Self::CodeMetadataStorage::insert(code_id, metadata);
     }
 
+    /// Returns true if the code associated with given id exists.
     fn exists(code_id: CodeId) -> bool {
         Self::InstrumentedCodeStorage::contains_key(&code_id)
     }
@@ -80,28 +84,28 @@ pub trait CodeStorage {
                 return false;
             }
 
-            Self::InstrumentedLenStorage::remove(code_id);
             Self::OriginalCodeStorage::remove(code_id);
-            Self::MetadataStorage::remove(code_id);
+            Self::CodeMetadataStorage::remove(code_id);
+            Self::CodeAttributionStorage::remove(code_id);
 
             *maybe = None;
             true
         })
     }
 
-    fn get_code(code_id: CodeId) -> Option<InstrumentedCode> {
+    fn get_instrumented_code(code_id: CodeId) -> Option<InstrumentedCode> {
         Self::InstrumentedCodeStorage::get(&code_id)
     }
 
-    fn get_code_len(code_id: CodeId) -> Option<u32> {
-        Self::InstrumentedLenStorage::get(&code_id)
-    }
-
     fn get_original_code(code_id: CodeId) -> Option<Vec<u8>> {
         Self::OriginalCodeStorage::get(&code_id)
     }
 
-    fn get_metadata(code_id: CodeId) -> Option<CodeMetadata> {
-        Self::MetadataStorage::get(&code_id)
+    fn get_code_metadata(code_id: CodeId) -> Option<CodeMetadata> {
+        Self::CodeMetadataStorage::get(&code_id)
+    }
+
+    fn get_code_attribution(code_id: CodeId) -> Option<CodeAttribution> {
+        Self::CodeAttributionStorage::get(&code_id)
     }
 }

common/src/lib.rs

@@ -231,24 +231,6 @@ pub trait BlockLimiter {
     type GasAllowance: storage::Limiter<Value = Self::Balance>;
 }
 
-#[derive(Clone, Debug, Decode, Encode, PartialEq, Eq, TypeInfo)]
-#[codec(crate = codec)]
-#[scale_info(crate = scale_info)]
-pub struct CodeMetadata {
-    pub author: H256,
-    #[codec(compact)]
-    pub block_number: u32,
-}
-
-impl CodeMetadata {
-    pub fn new(author: H256, block_number: u32) -> Self {
-        CodeMetadata {
-            author,
-            block_number,
-        }
-    }
-}
-
 /// A trait whose purpose is to extract the `Call` variant of an extrinsic
 pub trait ExtractCall<Call> {
     fn extract_call(&self) -> Call;

core-processor/src/common.rs

@@ -26,7 +26,7 @@ use alloc::{
     vec::Vec,
 };
 use gear_core::{
-    code::InstrumentedCode,
+    code::{CodeMetadata, InstrumentedCode},
     gas::{GasAllowanceCounter, GasAmount, GasCounter},
     ids::{CodeId, MessageId, ProgramId, ReservationId},
     memory::{MemoryError, MemorySetupError, PageBuf},
@@ -57,6 +57,15 @@ pub enum DispatchResultKind {
     GasAllowanceExceed,
 }
 
+/// Possible variants of the [`DispatchResult`] if the latter contains value.
+#[allow(missing_docs)]
+#[derive(Debug)]
+pub enum SuccessfulDispatchResultKind {
+    Exit(ProgramId),
+    Wait(Option<u32>, MessageWaitedType),
+    Success,
+}
+
 /// Result of the specific dispatch.
 pub struct DispatchResult {
     /// Kind of the dispatch.
@@ -534,6 +543,15 @@ pub struct ExecutableActorData {
     pub gas_reservation_map: GasReservationMap,
 }
 
+/// Executable allocations data.
+#[derive(Clone, Debug)]
+pub struct ExecutableAllocationsData {
+    /// Amount of reservations can exist for 1 program.
+    pub max_reservations: u64,
+    /// Size of wasm memory buffer which must be created in execution environment
+    pub memory_size: WasmPagesAmount,
+}
+
 /// Program.
 #[derive(Clone, Debug)]
 pub(crate) struct Program {
@@ -543,6 +561,8 @@ pub(crate) struct Program {
     pub memory_infix: MemoryInfix,
     /// Instrumented code.
     pub code: InstrumentedCode,
+    /// Code metadata.
+    pub code_metadata: CodeMetadata,
     /// Allocations.
     pub allocations: IntervalsTree<WasmPage>,
 }

core-processor/src/context.rs

@@ -18,9 +18,12 @@
 
 //! Module contains context-structures for processing.
 
-use crate::common::{ExecutableActorData, Program};
+use crate::{
+    common::Program,
+    precharge::{ContextCharged, ForModuleInstantiation},
+};
 use gear_core::{
-    code::InstrumentedCode,
+    code::{CodeMetadata, InstrumentedCode},
     gas::{GasAllowanceCounter, GasCounter},
     ids::ProgramId,
     message::IncomingDispatch,
@@ -29,88 +32,6 @@ use gear_core::{
     reservation::GasReserver,
 };
 
-/// Struct with dispatch and counters charged for program data.
-#[derive(Debug)]
-pub struct ContextChargedForProgram {
-    pub(crate) dispatch: IncomingDispatch,
-    pub(crate) destination_id: ProgramId,
-    pub(crate) gas_counter: GasCounter,
-    pub(crate) gas_allowance_counter: GasAllowanceCounter,
-}
-
-impl ContextChargedForProgram {
-    /// Unwraps into inner data.
-    #[cfg(feature = "gtest")]
-    pub fn into_inner(self) -> (IncomingDispatch, ProgramId, GasCounter) {
-        (self.dispatch, self.destination_id, self.gas_counter)
-    }
-}
-
-pub struct ContextChargedForAllocations(pub(crate) ContextChargedForProgram);
-
-pub(crate) struct ContextData {
-    pub(crate) gas_counter: GasCounter,
-    pub(crate) gas_allowance_counter: GasAllowanceCounter,
-    pub(crate) dispatch: IncomingDispatch,
-    pub(crate) destination_id: ProgramId,
-    pub(crate) actor_data: ExecutableActorData,
-}
-
-pub struct ContextChargedForCodeLength {
-    pub(crate) data: ContextData,
-}
-
-impl ContextChargedForCodeLength {
-    /// Returns reference to the ExecutableActorData.
-    pub fn actor_data(&self) -> &ExecutableActorData {
-        &self.data.actor_data
-    }
-}
-
-/// The instance returned by `precharge_for_code`.
-/// Existence of the instance means that corresponding counters were
-/// successfully charged for fetching the binary code from storage.
-pub struct ContextChargedForCode {
-    pub(crate) data: ContextData,
-}
-
-impl From<ContextChargedForCodeLength> for ContextChargedForCode {
-    fn from(context: ContextChargedForCodeLength) -> Self {
-        Self { data: context.data }
-    }
-}
-
-/// The instance returned by `precharge_for_instrumentation`.
-/// Existence of the instance means that corresponding counters were
-/// successfully charged for reinstrumentation of the code.
-pub struct ContextChargedForInstrumentation {
-    pub(crate) data: ContextData,
-}
-
-impl From<ContextChargedForCode> for ContextChargedForInstrumentation {
-    fn from(context: ContextChargedForCode) -> Self {
-        Self { data: context.data }
-    }
-}
-
-pub struct ContextChargedForMemory {
-    pub(crate) data: ContextData,
-    pub(crate) max_reservations: u64,
-    pub(crate) memory_size: WasmPagesAmount,
-}
-
-impl ContextChargedForMemory {
-    /// Returns reference to the ExecutableActorData.
-    pub fn actor_data(&self) -> &ExecutableActorData {
-        &self.data.actor_data
-    }
-
-    /// Returns reference to the GasCounter.
-    pub fn gas_counter(&self) -> &GasCounter {
-        &self.data.gas_counter
-    }
-}
-
 /// Checked parameters for message execution across processing runs.
 pub struct ProcessExecutionContext {
     pub(crate) gas_counter: GasCounter,
@@ -134,33 +55,47 @@ impl ProcessExecutionContext {
     }
 }
 
-impl From<(ContextChargedForMemory, InstrumentedCode, u128)> for ProcessExecutionContext {
-    fn from(args: (ContextChargedForMemory, InstrumentedCode, u128)) -> Self {
-        let (context, code, balance) = args;
-
-        let ContextChargedForMemory {
-            data:
-                ContextData {
-                    gas_counter,
-                    gas_allowance_counter,
-                    dispatch,
-                    destination_id,
-                    actor_data,
-                },
-            max_reservations,
-            memory_size,
-        } = context;
+impl
+    From<(
+        ContextCharged<ForModuleInstantiation>,
+        InstrumentedCode,
+        CodeMetadata,
+        u128,
+    )> for ProcessExecutionContext
+{
+    fn from(
+        args: (
+            ContextCharged<ForModuleInstantiation>,
+            InstrumentedCode,
+            CodeMetadata,
+            u128,
+        ),
+    ) -> Self {
+        let (context, code, code_metadata, balance) = args;
+
+        let (
+            destination_id,
+            dispatch,
+            gas_counter,
+            gas_allowance_counter,
+            actor_data,
+            allocations_data,
+        ) = context.into_final_parts();
 
         let program = Program {
             id: destination_id,
             memory_infix: actor_data.memory_infix,
             code,
+            code_metadata,
             allocations: actor_data.allocations,
         };
 
         // Must be created once per taken from the queue dispatch by program.
-        let gas_reserver =
-            GasReserver::new(&dispatch, actor_data.gas_reservation_map, max_reservations);
+        let gas_reserver = GasReserver::new(
+            &dispatch,
+            actor_data.gas_reservation_map,
+            allocations_data.max_reservations,
+        );
 
         Self {
             gas_counter,
@@ -169,7 +104,7 @@ impl From<(ContextChargedForMemory, InstrumentedCode, u128)> for ProcessExecutio
             dispatch,
             balance,
             program,
-            memory_size,
+            memory_size: allocations_data.memory_size,
         }
     }
 }