chore: use Arc instead of lifetime parameter

azure-pipelines.yml

@@ -8,7 +8,7 @@ trigger:
 
 variables:
   RUST_BACKTRACE: full
-  TEST_SUITE_COMMIT: ff49a1dfb3c12be9dc18073133d660f0dd176662
+  TEST_SUITE_COMMIT: a1fb578bf802ce1155565d509402e7e00a1c280b
 
 jobs:
   - job: WinCI

benches/vm_benchmark.rs

@@ -58,12 +58,12 @@ fn aot_benchmark(c: &mut Criterion) {
                                       "foo",
                                       "bar"].into_iter().map(|a| a.into()).collect();
         let mut aot_machine = AotCompilingMachine::load(&buffer.clone(), None, ISA_IMC, VERSION0).unwrap();
-        let result = aot_machine.compile().unwrap();
+        let result = std::sync::Arc::new(aot_machine.compile().unwrap());
 
         b.iter(|| {
             let asm_core = AsmCoreMachine::new(ISA_IMC, VERSION0, u64::max_value());
             let core = DefaultMachineBuilder::new(asm_core).build();
-            let mut machine = AsmMachine::new(core, Some(&result));
+            let mut machine = AsmMachine::new(core, Some(result.clone()));
             machine.load_program(&buffer, &args[..]).unwrap();
             machine.run().unwrap()
         });

examples/ckb-vm-runner.rs

@@ -105,7 +105,8 @@ fn main_aot(code: Bytes, args: Vec<Bytes>) -> Result<(), Box<dyn std::error::Err
             .instruction_cycle_func(Box::new(instruction_cycles))
             .syscall(Box::new(DebugSyscall {}))
             .build();
-    let mut machine = ckb_vm::machine::asm::AsmMachine::new(core, Some(&aot_code));
+    let mut machine =
+        ckb_vm::machine::asm::AsmMachine::new(core, Some(std::sync::Arc::new(aot_code)));
     machine.load_program(&code, &args)?;
     let exit = machine.run();
     let cycles = machine.machine.cycles();

src/machine/asm/mod.rs

@@ -1,5 +1,17 @@
-use std::mem::transmute;
-
+use crate::{
+    decoder::{build_decoder, Decoder},
+    instructions::{
+        blank_instruction, execute_instruction, extract_opcode, instruction_length,
+        is_basic_block_end_instruction,
+    },
+    machine::VERSION0,
+    memory::{
+        fill_page_data, get_page_indices, memset, round_page_down, round_page_up, FLAG_DIRTY,
+        FLAG_EXECUTABLE, FLAG_FREEZED, FLAG_WRITABLE, FLAG_WXORX_BIT,
+    },
+    CoreMachine, DefaultMachine, Error, Machine, Memory, SupportMachine, MEMORY_FRAME_SHIFTS,
+    RISCV_MAX_MEMORY, RISCV_PAGES, RISCV_PAGESIZE,
+};
 use byteorder::{ByteOrder, LittleEndian};
 use bytes::Bytes;
 pub use ckb_vm_definitions::asm::AsmCoreMachine;
@@ -17,21 +29,8 @@ use libc::c_uchar;
 use memmap::Mmap;
 use rand::{prelude::RngCore, SeedableRng};
 use std::collections::HashMap;
-
-use crate::{
-    decoder::{build_decoder, Decoder},
-    instructions::{
-        blank_instruction, execute_instruction, extract_opcode, instruction_length,
-        is_basic_block_end_instruction,
-    },
-    machine::VERSION0,
-    memory::{
-        fill_page_data, get_page_indices, memset, round_page_down, round_page_up, FLAG_DIRTY,
-        FLAG_EXECUTABLE, FLAG_FREEZED, FLAG_WRITABLE, FLAG_WXORX_BIT,
-    },
-    CoreMachine, DefaultMachine, Error, Machine, Memory, SupportMachine, MEMORY_FRAME_SHIFTS,
-    RISCV_MAX_MEMORY, RISCV_PAGES, RISCV_PAGESIZE,
-};
+use std::mem::transmute;
+use std::sync::Arc;
 
 impl CoreMachine for Box<AsmCoreMachine> {
     type REG = u64;
@@ -433,9 +432,9 @@ impl AotCode {
     }
 }
 
-pub struct AsmMachine<'a> {
-    pub machine: DefaultMachine<'a, Box<AsmCoreMachine>>,
-    pub aot_code: Option<&'a AotCode>,
+pub struct AsmMachine {
+    pub machine: DefaultMachine<Box<AsmCoreMachine>>,
+    pub aot_code: Option<Arc<AotCode>>,
 }
 
 extern "C" {
@@ -445,10 +444,10 @@ extern "C" {
     fn ckb_vm_asm_labels();
 }
 
-impl<'a> AsmMachine<'a> {
+impl AsmMachine {
     pub fn new(
-        machine: DefaultMachine<'a, Box<AsmCoreMachine>>,
-        aot_code: Option<&'a AotCode>,
+        machine: DefaultMachine<Box<AsmCoreMachine>>,
+        aot_code: Option<Arc<AotCode>>,
     ) -> Self {
         Self { machine, aot_code }
     }

src/machine/mod.rs

@@ -409,20 +409,20 @@ impl<R: Register, M: Memory + Default> DefaultCoreMachine<R, M> {
 pub type InstructionCycleFunc = dyn Fn(Instruction) -> u64;
 
 #[derive(Default)]
-pub struct DefaultMachine<'a, Inner> {
+pub struct DefaultMachine<Inner> {
     inner: Inner,
 
     // We have run benchmarks on secp256k1 verification, the performance
     // cost of the Box wrapper here is neglectable, hence we are sticking
     // with Box solution for simplicity now. Later if this becomes an issue,
     // we can change to static dispatch.
     instruction_cycle_func: Option<Box<InstructionCycleFunc>>,
-    debugger: Option<Box<dyn Debugger<Inner> + 'a>>,
-    syscalls: Vec<Box<dyn Syscalls<Inner> + 'a>>,
+    debugger: Option<Box<dyn Debugger<Inner>>>,
+    syscalls: Vec<Box<dyn Syscalls<Inner>>>,
     exit_code: i8,
 }
 
-impl<Inner: CoreMachine> CoreMachine for DefaultMachine<'_, Inner> {
+impl<Inner: CoreMachine> CoreMachine for DefaultMachine<Inner> {
     type REG = <Inner as CoreMachine>::REG;
     type MEM = <Inner as CoreMachine>::MEM;
 
@@ -463,7 +463,7 @@ impl<Inner: CoreMachine> CoreMachine for DefaultMachine<'_, Inner> {
     }
 }
 
-impl<Inner: SupportMachine> SupportMachine for DefaultMachine<'_, Inner> {
+impl<Inner: SupportMachine> SupportMachine for DefaultMachine<Inner> {
     fn cycles(&self) -> u64 {
         self.inner.cycles()
     }
@@ -498,7 +498,7 @@ impl<Inner: SupportMachine> SupportMachine for DefaultMachine<'_, Inner> {
     }
 }
 
-impl<Inner: SupportMachine> Machine for DefaultMachine<'_, Inner> {
+impl<Inner: SupportMachine> Machine for DefaultMachine<Inner> {
     fn ecall(&mut self) -> Result<(), Error> {
         let code = self.registers()[A7].to_u64();
         match code {
@@ -534,7 +534,7 @@ impl<Inner: SupportMachine> Machine for DefaultMachine<'_, Inner> {
     }
 }
 
-impl<Inner: CoreMachine> Display for DefaultMachine<'_, Inner> {
+impl<Inner: CoreMachine> Display for DefaultMachine<Inner> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         writeln!(f, "pc  : 0x{:16X}", self.pc().to_u64())?;
         for (i, name) in REGISTER_ABI_NAMES.iter().enumerate() {
@@ -549,7 +549,7 @@ impl<Inner: CoreMachine> Display for DefaultMachine<'_, Inner> {
     }
 }
 
-impl<'a, Inner: SupportMachine> DefaultMachine<'a, Inner> {
+impl<Inner: SupportMachine> DefaultMachine<Inner> {
     pub fn load_program(&mut self, program: &Bytes, args: &[Bytes]) -> Result<u64, Error> {
         let elf_bytes = self.load_elf(program, true)?;
         for syscall in &mut self.syscalls {
@@ -627,14 +627,14 @@ impl<'a, Inner: SupportMachine> DefaultMachine<'a, Inner> {
 }
 
 #[derive(Default)]
-pub struct DefaultMachineBuilder<'a, Inner> {
+pub struct DefaultMachineBuilder<Inner> {
     inner: Inner,
     instruction_cycle_func: Option<Box<InstructionCycleFunc>>,
-    debugger: Option<Box<dyn Debugger<Inner> + 'a>>,
-    syscalls: Vec<Box<dyn Syscalls<Inner> + 'a>>,
+    debugger: Option<Box<dyn Debugger<Inner>>>,
+    syscalls: Vec<Box<dyn Syscalls<Inner>>>,
 }
 
-impl<'a, Inner> DefaultMachineBuilder<'a, Inner> {
+impl<Inner> DefaultMachineBuilder<Inner> {
     pub fn new(inner: Inner) -> Self {
         Self {
             inner,
@@ -652,17 +652,17 @@ impl<'a, Inner> DefaultMachineBuilder<'a, Inner> {
         self
     }
 
-    pub fn syscall(mut self, syscall: Box<dyn Syscalls<Inner> + 'a>) -> Self {
+    pub fn syscall(mut self, syscall: Box<dyn Syscalls<Inner>>) -> Self {
         self.syscalls.push(syscall);
         self
     }
 
-    pub fn debugger(mut self, debugger: Box<dyn Debugger<Inner> + 'a>) -> Self {
+    pub fn debugger(mut self, debugger: Box<dyn Debugger<Inner>>) -> Self {
         self.debugger = Some(debugger);
         self
     }
 
-    pub fn build(self) -> DefaultMachine<'a, Inner> {
+    pub fn build(self) -> DefaultMachine<Inner> {
         DefaultMachine {
             inner: self.inner,
             instruction_cycle_func: self.instruction_cycle_func,

src/machine/trace.rs

@@ -32,13 +32,13 @@ fn calculate_slot(addr: u64) -> usize {
     (addr as usize >> TRACE_ADDRESS_SHIFTS) & TRACE_MASK
 }
 
-pub struct TraceMachine<'a, Inner> {
-    pub machine: DefaultMachine<'a, Inner>,
+pub struct TraceMachine<Inner> {
+    pub machine: DefaultMachine<Inner>,
 
     traces: Vec<Trace>,
 }
 
-impl<Inner: SupportMachine> CoreMachine for TraceMachine<'_, Inner> {
+impl<Inner: SupportMachine> CoreMachine for TraceMachine<Inner> {
     type REG = <Inner as CoreMachine>::REG;
     type MEM = <Inner as CoreMachine>::MEM;
 
@@ -79,7 +79,7 @@ impl<Inner: SupportMachine> CoreMachine for TraceMachine<'_, Inner> {
     }
 }
 
-impl<Inner: SupportMachine> Machine for TraceMachine<'_, Inner> {
+impl<Inner: SupportMachine> Machine for TraceMachine<Inner> {
     fn ecall(&mut self) -> Result<(), Error> {
         self.machine.ecall()
     }
@@ -89,8 +89,8 @@ impl<Inner: SupportMachine> Machine for TraceMachine<'_, Inner> {
     }
 }
 
-impl<'a, Inner: SupportMachine> TraceMachine<'a, Inner> {
-    pub fn new(machine: DefaultMachine<'a, Inner>) -> Self {
+impl<Inner: SupportMachine> TraceMachine<Inner> {
+    pub fn new(machine: DefaultMachine<Inner>) -> Self {
         Self {
             machine,
             traces: vec![],

tests/machine_build.rs

@@ -3,18 +3,17 @@ use ckb_vm::machine::asm::{AsmCoreMachine, AsmMachine};
 #[cfg(has_aot)]
 use ckb_vm::machine::{aot::AotCompilingMachine, asm::AotCode};
 
+use bytes::Bytes;
 use ckb_vm::machine::{trace::TraceMachine, DefaultCoreMachine, VERSION1};
 use ckb_vm::{DefaultMachineBuilder, ISA_B, ISA_IMC, ISA_MOP};
 use ckb_vm::{Instruction, SparseMemory, WXorXMemory};
 
-use bytes::Bytes;
-
 pub fn instruction_cycle_func(_: Instruction) -> u64 {
     1
 }
 
 #[cfg(has_asm)]
-pub fn asm_v1_imcb<'a>(path: &str) -> AsmMachine<'a> {
+pub fn asm_v1_imcb(path: &str) -> AsmMachine {
     let buffer: Bytes = std::fs::read(path).unwrap().into();
     let asm_core = AsmCoreMachine::new(ISA_IMC | ISA_B, VERSION1, u64::max_value());
     let core = DefaultMachineBuilder::<Box<AsmCoreMachine>>::new(asm_core)
@@ -36,14 +35,14 @@ pub fn aot_v1_imcb_code(path: &str) -> AotCode {
 }
 
 #[cfg(has_aot)]
-pub fn aot_v1_imcb<'a>(path: &str, code: &'a AotCode) -> AsmMachine<'a> {
+pub fn aot_v1_imcb(path: &str, code: AotCode) -> AsmMachine {
     let buffer: Bytes = std::fs::read(path).unwrap().into();
 
     let asm_core = AsmCoreMachine::new(ISA_IMC | ISA_B, VERSION1, u64::max_value());
     let core = DefaultMachineBuilder::<Box<AsmCoreMachine>>::new(asm_core)
         .instruction_cycle_func(Box::new(instruction_cycle_func))
         .build();
-    let mut machine = AsmMachine::new(core, Some(code));
+    let mut machine = AsmMachine::new(core, Some(std::sync::Arc::new(code)));
     machine
         .load_program(&buffer, &vec![Bytes::from("main")])
         .unwrap();
@@ -71,7 +70,7 @@ pub fn int_v1_imcb(
 }
 
 #[cfg(has_asm)]
-pub fn asm_v1_mop<'a>(path: &str, args: Vec<Bytes>) -> AsmMachine<'a> {
+pub fn asm_v1_mop(path: &str, args: Vec<Bytes>) -> AsmMachine {
     let buffer: Bytes = std::fs::read(path).unwrap().into();
     let asm_core = AsmCoreMachine::new(ISA_IMC | ISA_B | ISA_MOP, VERSION1, u64::max_value());
     let core = DefaultMachineBuilder::<Box<AsmCoreMachine>>::new(asm_core)
@@ -93,7 +92,7 @@ pub fn aot_v1_mop_code(path: &str) -> AotCode {
 }
 
 #[cfg(has_aot)]
-pub fn aot_v1_mop<'a>(path: &str, args: Vec<Bytes>, code: &'a AotCode) -> AsmMachine<'a> {
+pub fn aot_v1_mop(path: &str, args: Vec<Bytes>, code: AotCode) -> AsmMachine {
     let buffer: Bytes = std::fs::read(path).unwrap().into();
 
     let asm_core = AsmCoreMachine::new(ISA_IMC | ISA_B | ISA_MOP, VERSION1, u64::max_value());
@@ -102,7 +101,7 @@ pub fn aot_v1_mop<'a>(path: &str, args: Vec<Bytes>, code: &'a AotCode) -> AsmMac
         .build();
     let mut argv = vec![Bytes::from("main")];
     argv.extend_from_slice(&args);
-    let mut machine = AsmMachine::new(core, Some(code));
+    let mut machine = AsmMachine::new(core, Some(std::sync::Arc::new(code)));
     machine.load_program(&buffer, &argv).unwrap();
     machine
 }