[core] refactor global storage allocator initialization routines

core/src/storage2/alloc/allocator.rs

@@ -104,19 +104,6 @@ impl DynamicAllocator {
         }
     }
 
-    /// Resets the dynamic allocator.
-    ///
-    /// # Note
-    ///
-    /// This method is only needed for testing when tools such as `miri` run all
-    /// tests on the same thread in sequence so every test has to reset the
-    /// statically allocated instances like the storage allocator before running.
-    #[cfg(test)]
-    pub fn reset(&mut self) {
-        self.counts = StorageVec::new();
-        self.free = StorageBitvec::new();
-    }
-
     /// Returns the bit position of the first 256-bit chunk with zero bits
     /// in the `free` list.
     ///

core/src/storage2/alloc/init.rs

@@ -0,0 +1,155 @@
+// Copyright 2019-2020 Parity Technologies (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use super::DynamicAllocator;
+use cfg_if::cfg_if;
+use crate::storage2::traits::pull_spread_root;
+use ink_primitives::Key;
+
+/// The default dynamic allocator key offset.
+///
+/// This is where the dynamic allocator is stored on the contract storage.
+const DYNAMIC_ALLOCATOR_KEY_OFFSET: [u8; 32] = [0xFE; 32];
+
+/// The phase in which a contract execution can be.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ContractPhase {
+    /// Initializes the global dynamic storage allocator from scratch.
+    ///
+    /// Upon initialization it will be created from scratch as if the
+    /// contract has been deployed for the first time.
+    Deploy,
+    /// Initializes the global dynamic storage allocator from storage.
+    ///
+    /// Upon initialization the dynamic storage allocator will be pulled
+    /// from the contract storage with the assumption that a former
+    /// contract deployment has already taken place in the past.
+    Call,
+}
+
+/// The state of the dynamic allocator global instance.
+#[derive(Debug)]
+enum DynamicAllocatorState {
+    /// The global instance has not yet been initialized.
+    ///
+    /// Upon initialization it will be created from scratch as if the
+    /// contract has been deployed for the first time.
+    UninitDeploy,
+    /// The global instance has not yet been initialized.
+    ///
+    /// Upon initialization it will be pulled from the contract storage
+    /// with the assumption that a former contract deployment has already
+    /// taken place in the past.
+    UninitCall,
+    /// The global instance has already been initialized successfully.
+    Initialized(DynamicAllocator),
+}
+
+impl From<ContractPhase> for DynamicAllocatorState {
+    fn from(phase: ContractPhase) -> Self {
+        match phase {
+            ContractPhase::Deploy => DynamicAllocatorState::UninitDeploy,
+            ContractPhase::Call => DynamicAllocatorState::UninitCall,
+        }
+    }
+}
+
+cfg_if! {
+    if #[cfg(all(not(feature = "std"), target_arch = "wasm32"))] {
+        // Procedures for the Wasm compilation:
+
+        /// The global instance for the dynamic storage allocator.
+        static mut GLOBAL_INSTANCE: DynamicAllocatorState = DynamicAllocatorState::UninitDeploy;
+
+        /// Commands the (re-)initialization of the global instance for the dynamic
+        /// storage allocator.
+        pub fn initialize_for(phase: ContractPhase) {
+            let instance = unsafe { &mut GLOBAL_INSTANCE };
+            // We do not allow reinitialization for Wasm targets for performance reasons.
+            assert!(!instance.is_initialized());
+            *instance = phase.into();
+        }
+
+        /// Runs the given closure on the global instance for the dynamic storage allocator.
+        pub fn on_call<F, R>(f: F) -> R
+        where
+            F: FnOnce(&mut DynamicAllocator) -> R,
+        {
+            let instance = unsafe { &mut GLOBAL_INSTANCE };
+            match instance {
+                DynamicAllocatorState::UninitDeploy => {
+                    let mut allocator = DynamicAllocator::new();
+                    let result = f(&mut allocator);
+                    *instance = allocator;
+                    result
+                }
+                DynamicAllocatorState::UninitCall => {
+                    let mut allocator = pull_spread_root::<DynamicAllocator>(&Key(DYNAMIC_ALLOCATOR_KEY_OFFSET));
+                    let result = f(&mut allocator);
+                    *instance = allocator;
+                    result
+                }
+                DynamicAllocatorState::Initialized(ref mut allocator) => {
+                    f(allocator)
+                }
+            }
+        }
+
+    } else if #[cfg(feature = "std")] {
+        // Procedures for the off-chain environment and testing compilation:
+
+        use ::core::cell::RefCell;
+        thread_local!(
+            /// The global instance for the dynamic storage allocator.
+            static GLOBAL_INSTANCE: RefCell<DynamicAllocatorState> = RefCell::new(DynamicAllocatorState::UninitDeploy);
+        );
+
+        /// Commands the (re-)initialization of the global instance for the dynamic
+        /// storage allocator.
+        pub fn initialize_for(phase: ContractPhase) {
+            GLOBAL_INSTANCE.with(|instance| instance.replace_with(|_| phase.into()));
+        }
+
+        /// Runs the given closure on the global instance for the dynamic storage allocator.
+        pub fn on_call<F, R>(f: F) -> R
+        where
+            F: FnOnce(&mut DynamicAllocator) -> R,
+        {
+            GLOBAL_INSTANCE.with(|instance| {
+                match &mut *instance.borrow_mut() {
+                    instance @ DynamicAllocatorState::UninitDeploy => {
+                        let mut allocator = DynamicAllocator::new();
+                        let result = f(&mut allocator);
+                        *instance = DynamicAllocatorState::Initialized(allocator);
+                        result
+                    }
+                    instance @ DynamicAllocatorState::UninitCall => {
+                        let mut allocator = pull_spread_root::<DynamicAllocator>(&Key(DYNAMIC_ALLOCATOR_KEY_OFFSET));
+                        let result = f(&mut allocator);
+                        *instance = DynamicAllocatorState::Initialized(allocator);
+                        result
+                    }
+                    DynamicAllocatorState::Initialized(instance) => {
+                        f(instance)
+                    }
+                }
+            })
+        }
+
+    } else {
+        compile_error! {
+            "ink! only support compilation as `std` or `no_std` + `wasm32-unknown`"
+        }
+    }
+}

core/src/storage2/alloc/mod.rs

@@ -70,15 +70,17 @@
 
 mod allocation;
 mod allocator;
+mod init;
 
 #[cfg(test)]
 mod tests;
 
 pub use self::allocation::DynamicAllocation;
 use self::allocator::DynamicAllocator;
-use crate::storage2::traits::pull_spread_root;
-use cfg_if::cfg_if;
-use ink_primitives::Key;
+use self::init::{
+    on_call,
+};
+pub use self::init::{ContractPhase, initialize_for};
 
 /// Returns a new dynamic storage allocation.
 pub fn alloc() -> DynamicAllocation {
@@ -92,176 +94,3 @@ pub fn alloc() -> DynamicAllocation {
 pub fn free(allocation: DynamicAllocation) {
     on_call(|allocator| allocator.free(allocation))
 }
-
-/// Resets the allocator to the initial values.
-///
-/// # Note
-///
-/// This function is only needed for testing when tools such as `miri` run all
-/// tests on the same thread in sequence so every test has to reset the
-/// statically allocated instances like the storage allocator before running.
-#[cfg(test)]
-pub fn reset_allocator() {
-    assert_eq!(get_contract_phase(), ContractPhase::Deploy);
-    on_call(|allocator| allocator.reset())
-}
-
-/// The default dynamic allocator key offset.
-///
-/// This is where the dynamic allocator is stored on the contract storage.
-const DYNAMIC_ALLOCATOR_KEY_OFFSET: [u8; 32] = [0xFE; 32];
-
-mod phase {
-    use super::cfg_if;
-
-    /// The phase in which a contract execution can be.
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    pub enum ContractPhase {
-        /// A contract has been deployed initially.
-        Deploy,
-        /// An already deployed contract has been called.
-        Call,
-    }
-
-    cfg_if! {
-        if #[cfg(all(not(feature = "std"), target_arch = "wasm32"))] {
-
-            /// The global static phase capturing the state.
-            static mut PHASE: Option<ContractPhase> = None;
-
-            /// Sets the contract phase (either call or deploy).
-            ///
-            /// # Note
-            ///
-            /// This must happen before the first dynamic storage allocation and thus
-            /// generally as early as possible upon contract execution.
-            ///
-            /// # Panics
-            ///
-            /// If a contract phase has already been submitted.
-            pub fn set_contract_phase(phase: ContractPhase) {
-                assert!(unsafe { &PHASE }.is_none());
-                unsafe { PHASE = Some(phase) };
-            }
-
-            /// Returns the contract phase.
-            ///
-            /// # Panics
-            ///
-            /// If no contract phase has yet been submitted.
-            pub fn get_contract_phase() -> ContractPhase {
-                unsafe { PHASE }.expect("a contract phase has not yet been submitted")
-            }
-
-        } else if #[cfg(feature = "std")] {
-
-            use ::core::cell::Cell;
-            thread_local!(
-                static PHASE: Cell<Option<ContractPhase>> = Cell::new(None);
-            );
-
-            /// Sets the contract phase (either call or deploy).
-            ///
-            /// # Note
-            ///
-            /// This must happen before the first dynamic storage allocation and thus
-            /// generally as early as possible upon contract execution.
-            ///
-            /// # Panics
-            ///
-            /// If a contract phase has already been submitted.
-            pub fn set_contract_phase(new_phase: ContractPhase) {
-                PHASE.with(|phase| {
-                    phase.replace(Some(new_phase));
-                });
-            }
-
-            /// Returns the contract phase.
-            ///
-            /// # Panics
-            ///
-            /// If no contract phase has yet been submitted.
-            pub fn get_contract_phase() -> ContractPhase {
-                PHASE.with(|phase| {
-                    assert!(phase.get().is_some());
-                    phase.get().expect("a contract phase has not yet been submitted")
-                })
-            }
-
-        } else {
-            compile_error! {
-                "ink! only support compilation as `std` or `no_std` + `wasm32-unknown`"
-            }
-        }
-    }
-}
-use phase::get_contract_phase;
-pub use phase::{
-    set_contract_phase,
-    ContractPhase,
-};
-
-cfg_if! {
-    if #[cfg(all(not(feature = "std"), target_arch = "wasm32"))] {
-
-        // Runs the given closure with the dynamic allocator for contract calls.
-        fn on_call<F, R>(f: F) -> R
-        where
-            F: FnOnce(&mut DynamicAllocator) -> R,
-        {
-            static mut INSTANCE: Option<DynamicAllocator> = None;
-            // Lazily initialize the dynamic allocator if not done, yet.
-            if unsafe { &INSTANCE }.is_none() {
-                match get_contract_phase() {
-                    ContractPhase::Deploy => unsafe {
-                        INSTANCE = Some(
-                            DynamicAllocator::new()
-                        );
-                    }
-                    ContractPhase::Call => unsafe {
-                        INSTANCE = Some(
-                            pull_spread_root::<DynamicAllocator>(&Key(DYNAMIC_ALLOCATOR_KEY_OFFSET))
-                        );
-                    }
-                }
-            }
-            f(unsafe { INSTANCE.as_mut().expect("uninitialized dynamic storage allocator") })
-        }
-
-    } else if #[cfg(feature = "std")] {
-
-        // Off-chain environment:
-        fn on_call<F, R>(f: F) -> R
-        where
-            F: FnOnce(&mut DynamicAllocator) -> R,
-        {
-            use ::core::cell::RefCell;
-            thread_local!(
-                static INSTANCE: RefCell<Option<DynamicAllocator>> = RefCell::new(None);
-            );
-            // Lazily initialize the dynamic allocator if not done, yet.
-            INSTANCE.with(|instance| {
-                if instance.borrow().is_none() {
-                    match get_contract_phase() {
-                        ContractPhase::Deploy => {
-                            instance.replace_with(|_| Some(
-                                DynamicAllocator::new()
-                            ));
-                        }
-                        ContractPhase::Call => {
-                            instance.replace_with(|_| Some(
-                                pull_spread_root::<DynamicAllocator>(&Key(DYNAMIC_ALLOCATOR_KEY_OFFSET))
-                            ));
-                        }
-                    }
-                }
-            });
-            INSTANCE.with(|instance| f(&mut instance.borrow_mut().as_mut().expect("uninitialized dynamic storage allocator")))
-        }
-
-    } else {
-        compile_error! {
-            "ink! only support compilation as `std` or `no_std` + `wasm32-unknown`"
-        }
-    }
-}