feat(script): remove the code that suspend and resume the scheduler via a fully suspended state (#5262)

### What problem does this PR solve?

Remove some dead code. Currently, the validator does not suspend and
resume the scheduler through a fully suspended state, so attempting to
remove it.

### Related changes

- PR to update `owner/repo`:
- Need to cherry-pick to the release branch

### Check List <!--REMOVE the items that are not applicable-->

Tests <!-- At least one of them must be included. -->

- Unit test
- Integration test
- Manual test (add detailed scripts or steps below)
- No code

Side effects

- Performance regression
- Breaking backward compatibility

Author: mohanson

script/src/scheduler.rs

@@ -5,9 +5,9 @@ use crate::syscalls::{
 };
 
 use crate::types::{
-    DataLocation, DataPieceId, FIRST_FD_SLOT, FIRST_VM_ID, Fd, FdArgs, FullSuspendedState,
-    IterationResult, Message, ReadState, RunMode, SgData, SyscallGenerator, TerminatedResult,
-    VmArgs, VmContext, VmId, VmState, WriteState,
+    DataLocation, DataPieceId, FIRST_FD_SLOT, FIRST_VM_ID, Fd, FdArgs, IterationResult, Message,
+    ReadState, RunMode, SgData, SyscallGenerator, TerminatedResult, VmArgs, VmContext, VmId,
+    VmState, WriteState,
 };
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_types::core::Cycle;
@@ -201,80 +201,6 @@ where
         }
     }
 
-    /// Resume a previously suspended scheduler state
-    pub fn resume(
-        sg_data: SgData<DL>,
-        syscall_generator: SyscallGenerator<DL, V, M::Inner>,
-        syscall_context: V,
-        full: FullSuspendedState,
-    ) -> Self {
-        let mut scheduler = Self {
-            sg_data,
-            syscall_generator,
-            syscall_context,
-            total_cycles: Arc::new(AtomicU64::new(full.total_cycles)),
-            iteration_cycles: full.iteration_cycles,
-            next_vm_id: full.next_vm_id,
-            next_fd_slot: full.next_fd_slot,
-            states: full
-                .vms
-                .iter()
-                .map(|(id, state, _)| (*id, state.clone()))
-                .collect(),
-            fds: full.fds.into_iter().collect(),
-            inherited_fd: full.inherited_fd.into_iter().collect(),
-            instantiated: BTreeMap::default(),
-            suspended: full
-                .vms
-                .into_iter()
-                .map(|(id, _, snapshot)| (id, snapshot))
-                .collect(),
-            message_box: Arc::new(Mutex::new(Vec::new())),
-            terminated_vms: full.terminated_vms.into_iter().collect(),
-            root_vm_args: Vec::new(),
-        };
-        scheduler
-            .ensure_vms_instantiated(&full.instantiated_ids)
-            .unwrap();
-        // NOTE: suspending/resuming a scheduler is part of CKB's implementation
-        // details. It is not part of execution consensue. We should not charge
-        // cycles for them.
-        scheduler.iteration_cycles = 0;
-        scheduler
-    }
-
-    /// Suspend current scheduler into a serializable full state
-    pub fn suspend(mut self) -> Result<FullSuspendedState, Error> {
-        assert!(self.message_box.lock().expect("lock").is_empty());
-        let mut vms = Vec::with_capacity(self.states.len());
-        let instantiated_ids: Vec<_> = self.instantiated.keys().cloned().collect();
-        for id in &instantiated_ids {
-            self.suspend_vm(id)?;
-        }
-        for (id, state) in self.states {
-            let snapshot = self
-                .suspended
-                .remove(&id)
-                .ok_or_else(|| Error::Unexpected("Unable to find VM Id".to_string()))?;
-            vms.push((id, state, snapshot));
-        }
-        Ok(FullSuspendedState {
-            // NOTE: suspending a scheduler is actually part of CKB's
-            // internal execution logic, it does not belong to VM execution
-            // consensus. We are not charging cycles for suspending
-            // a VM in the process of suspending the whole scheduler.
-            total_cycles: self.total_cycles.load(Ordering::Acquire),
-            iteration_cycles: self.iteration_cycles,
-            next_vm_id: self.next_vm_id,
-            next_fd_slot: self.next_fd_slot,
-            vms,
-            fds: self.fds.into_iter().collect(),
-            inherited_fd: self.inherited_fd.into_iter().collect(),
-            terminated_vms: self.terminated_vms.into_iter().collect(),
-            instantiated_ids,
-        })
-    }
-
     /// This is the only entrypoint for running the scheduler,
     /// both newly created instance and resumed instance are supported.
     /// It accepts 2 run mode, one can either limit the cycles to execute,

script/src/types.rs

@@ -26,12 +26,8 @@ use ckb_traits::CellDataProvider;
 use ckb_vm::snapshot2::Snapshot2Context;
 
 use ckb_vm::{
-    DefaultMachineRunner, RISCV_GENERAL_REGISTER_NUMBER, SupportMachine,
-    bytes::Bytes,
-    machine::Pause,
-    snapshot2::{DataSource, Snapshot2},
+    DefaultMachineRunner, SupportMachine, bytes::Bytes, machine::Pause, snapshot2::DataSource,
 };
-use std::mem::size_of;
 
 /// The type of CKB-VM ISA.
 pub type VmIsa = u8;
@@ -197,13 +193,10 @@ impl fmt::Display for ScriptGroupType {
 }
 
 /// Struct specifies which script has verified so far.
-/// State is lifetime free, but capture snapshot need heavy memory copy
 #[derive(Clone)]
 pub struct TransactionState {
     /// current suspended script index
     pub current: usize,
-    /// vm scheduler suspend state
-    pub state: Option<FullSuspendedState>,
     /// current consumed cycle
     pub current_cycles: Cycle,
     /// limit cycles
@@ -212,15 +205,9 @@ pub struct TransactionState {
 
 impl TransactionState {
     /// Creates a new TransactionState struct
-    pub fn new(
-        state: Option<FullSuspendedState>,
-        current: usize,
-        current_cycles: Cycle,
-        limit_cycles: Cycle,
-    ) -> Self {
+    pub fn new(current: usize, current_cycles: Cycle, limit_cycles: Cycle) -> Self {
         TransactionState {
             current,
-            state,
             current_cycles,
             limit_cycles,
         }
@@ -488,67 +475,6 @@ impl TryFrom<(u64, u64, u64)> for DataPieceId {
     }
 }
 
-/// Full state representing all VM instances from verifying a CKB script.
-/// It should be serializable to binary formats, while also be able to
-/// fully recover the running environment with the full transaction environment.
-#[derive(Clone, Debug)]
-pub struct FullSuspendedState {
-    /// Total executed cycles
-    pub total_cycles: Cycle,
-    /// Iteration cycles. Due to an implementation bug in Meepo hardfork,
-    /// this value will not always be zero at visible execution boundaries.
-    /// We will have to preserve this value.
-    pub iteration_cycles: Cycle,
-    /// Next available VM ID
-    pub next_vm_id: VmId,
-    /// Next available file descriptor
-    pub next_fd_slot: u64,
-    /// Suspended VMs
-    pub vms: Vec<(VmId, VmState, Snapshot2<DataPieceId>)>,
-    /// Opened file descriptors with owners
-    pub fds: Vec<(Fd, VmId)>,
-    /// Inherited file descriptors for each spawned process
-    pub inherited_fd: Vec<(VmId, Vec<Fd>)>,
-    /// Terminated VMs with exit codes
-    pub terminated_vms: Vec<(VmId, i8)>,
-    /// Currently instantiated VMs. Upon resumption, those VMs will
-    /// be instantiated.
-    pub instantiated_ids: Vec<VmId>,
-}
-
-impl FullSuspendedState {
-    /// Calculates the size of current suspended state, should be used
-    /// to derive cycles charged for suspending / resuming.
-    pub fn size(&self) -> u64 {
-        (size_of::<Cycle>()
-            + size_of::<VmId>()
-            + size_of::<u64>()
-            + size_of::<u64>()
-            + self.vms.iter().fold(0, |mut acc, (_, _, snapshot)| {
-                acc += size_of::<VmId>() + size_of::<VmState>();
-                acc += snapshot.pages_from_source.len()
-                    * (size_of::<u64>()
-                        + size_of::<u8>()
-                        + size_of::<DataPieceId>()
-                        + size_of::<u64>()
-                        + size_of::<u64>());
-                for dirty_page in &snapshot.dirty_pages {
-                    acc += size_of::<u64>() + size_of::<u8>() + dirty_page.2.len();
-                }
-                acc += size_of::<u32>()
-                    + RISCV_GENERAL_REGISTER_NUMBER * size_of::<u64>()
-                    + size_of::<u64>()
-                    + size_of::<u64>()
-                    + size_of::<u64>();
-                acc
-            })
-            + (self.fds.len() * (size_of::<Fd>() + size_of::<VmId>()))) as u64
-            + (self.inherited_fd.len() * (size_of::<Fd>())) as u64
-            + (self.terminated_vms.len() * (size_of::<VmId>() + size_of::<i8>())) as u64
-            + (self.instantiated_ids.len() * size_of::<VmId>()) as u64
-    }
-}
-
 /// A cell that is either loaded, or not yet loaded.
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum DataGuard {