Skip to content

Commit e9d9b18

Browse files
mohansonmohanson
authored
Implement FlattenedArgsReader (#450)
* Implement FlattenedArgsReader * Fix ci * Modify according to review comments
1 parent 68a5331 commit e9d9b18

20 files changed

+308
-209
lines changed

‎.github/workflows/develop.yml

+3-3
Original file line numberDiff line numberDiff line change
@@ -69,7 +69,7 @@ jobs:
6969
ln -snf .. ckb-vm-test-suite/ckb-vm
7070
docker run --rm -v `pwd`:/code nervos/ckb-riscv-gnu-toolchain:bionic-20210804 cp -r /riscv /code/riscv
7171
cd ckb-vm-test-suite
72-
git checkout 2ef749d0f580958043264a798e560fe25fec0c6e
72+
git checkout 898edc351eeb4de974ca4f0ff8d1e4943a95aecb
7373
git submodule update --init --recursive
7474
RISCV=`pwd`/../riscv ./test.sh
7575
@@ -136,13 +136,13 @@ jobs:
136136
ln -snf .. ckb-vm-test-suite/ckb-vm
137137
docker run --rm -v `pwd`:/code nervos/ckb-riscv-gnu-toolchain:bionic-20210804 cp -r /riscv /code/riscv
138138
cd ckb-vm-test-suite
139-
git checkout 2ef749d0f580958043264a798e560fe25fec0c6e
139+
git checkout 898edc351eeb4de974ca4f0ff8d1e4943a95aecb
140140
git submodule update --init --recursive
141141
RISCV=`pwd`/../riscv ./test.sh --build-only
142142
cd ..
143143
- name: Run test suite
144144
run: |
145-
sudo apt install -y qemu binfmt-support qemu-user-static
145+
sudo apt install -y qemu-system binfmt-support qemu-user-static
146146
sudo apt install -y gcc-multilib
147147
sudo apt install -y gcc-aarch64-linux-gnu g++-aarch64-linux-gnu clang
148148
docker run --rm --privileged multiarch/qemu-user-static --reset -p yes

‎benches/vm_benchmark.rs

+41-33
Original file line numberDiff line numberDiff line change
@@ -21,12 +21,13 @@ use std::fs;
2121
fn interpret_benchmark(c: &mut Criterion) {
2222
c.bench_function("interpret secp256k1_bench", |b| {
2323
let buffer = fs::read("benches/data/secp256k1_bench").unwrap().into();
24-
let args: Vec<Bytes> = vec!["secp256k1_bench",
25-
"033f8cf9c4d51a33206a6c1c6b27d2cc5129daa19dbd1fc148d395284f6b26411f",
26-
"304402203679d909f43f073c7c1dcf8468a485090589079ee834e6eed92fea9b09b06a2402201e46f1075afa18f306715e7db87493e7b7e779569aa13c64ab3d09980b3560a3",
27-
"foo",
28-
"bar"].into_iter().map(|a| a.into()).collect();
29-
24+
let args: Vec<Bytes> = vec![
25+
"secp256k1_bench",
26+
"033f8cf9c4d51a33206a6c1c6b27d2cc5129daa19dbd1fc148d395284f6b26411f",
27+
"304402203679d909f43f073c7c1dcf8468a485090589079ee834e6eed92fea9b09b06a2402201e46f1075afa18f306715e7db87493e7b7e779569aa13c64ab3d09980b3560a3",
28+
"foo",
29+
"bar"
30+
].into_iter().map(|a| a.into()).collect();
3031
b.iter(|| run::<u64, SparseMemory<u64>>(&buffer, &args[..]).unwrap());
3132
});
3233
}
@@ -35,17 +36,18 @@ fn interpret_benchmark(c: &mut Criterion) {
3536
fn asm_benchmark(c: &mut Criterion) {
3637
c.bench_function("interpret secp256k1_bench via assembly", |b| {
3738
let buffer = fs::read("benches/data/secp256k1_bench").unwrap().into();
38-
let args: Vec<Bytes> = vec!["secp256k1_bench",
39-
"033f8cf9c4d51a33206a6c1c6b27d2cc5129daa19dbd1fc148d395284f6b26411f",
40-
"304402203679d909f43f073c7c1dcf8468a485090589079ee834e6eed92fea9b09b06a2402201e46f1075afa18f306715e7db87493e7b7e779569aa13c64ab3d09980b3560a3",
41-
"foo",
42-
"bar"].into_iter().map(|a| a.into()).collect();
43-
39+
let args = [
40+
"secp256k1_bench",
41+
"033f8cf9c4d51a33206a6c1c6b27d2cc5129daa19dbd1fc148d395284f6b26411f",
42+
"304402203679d909f43f073c7c1dcf8468a485090589079ee834e6eed92fea9b09b06a2402201e46f1075afa18f306715e7db87493e7b7e779569aa13c64ab3d09980b3560a3",
43+
"foo",
44+
"bar",
45+
].into_iter().map(|a| Ok(a.into()));
4446
b.iter(|| {
4547
let asm_core = AsmCoreMachine::new(ISA_IMC, VERSION0, u64::MAX);
4648
let core = DefaultMachineBuilder::new(asm_core).build();
4749
let mut machine = AsmMachine::new(core);
48-
machine.load_program(&buffer, &args[..]).unwrap();
50+
machine.load_program(&buffer, args.clone()).unwrap();
4951
machine.run().unwrap()
5052
});
5153
});
@@ -55,17 +57,19 @@ fn asm_benchmark(c: &mut Criterion) {
5557
fn mop_benchmark(c: &mut Criterion) {
5658
c.bench_function("interpret secp256k1_bench via assembly mop", |b| {
5759
let buffer = fs::read("benches/data/secp256k1_bench").unwrap().into();
58-
let args: Vec<Bytes> = vec!["secp256k1_bench",
59-
"033f8cf9c4d51a33206a6c1c6b27d2cc5129daa19dbd1fc148d395284f6b26411f",
60-
"304402203679d909f43f073c7c1dcf8468a485090589079ee834e6eed92fea9b09b06a2402201e46f1075afa18f306715e7db87493e7b7e779569aa13c64ab3d09980b3560a3",
61-
"foo",
62-
"bar"].into_iter().map(|a| a.into()).collect();
60+
let args = [
61+
"secp256k1_bench",
62+
"033f8cf9c4d51a33206a6c1c6b27d2cc5129daa19dbd1fc148d395284f6b26411f",
63+
"304402203679d909f43f073c7c1dcf8468a485090589079ee834e6eed92fea9b09b06a2402201e46f1075afa18f306715e7db87493e7b7e779569aa13c64ab3d09980b3560a3",
64+
"foo",
65+
"bar",
66+
].into_iter().map(|a| Ok(a.into()));
6367
b.iter(|| {
6468
let asm_core = AsmCoreMachine::new(ISA_IMC | ISA_B | ISA_MOP, VERSION2, u64::MAX);
6569
let core = DefaultMachineBuilder::<Box<AsmCoreMachine>>::new(asm_core)
6670
.build();
6771
let mut machine = AsmMachine::new(core);
68-
machine.load_program(&buffer, &args).unwrap();
72+
machine.load_program(&buffer, args.clone()).unwrap();
6973
machine.run().unwrap()
7074
});
7175
});
@@ -77,25 +81,27 @@ fn mop_memoized_benchmark(c: &mut Criterion) {
7781
let isa = ISA_IMC | ISA_B | ISA_MOP;
7882
let version = VERSION2;
7983
let buffer = fs::read("benches/data/secp256k1_bench").unwrap().into();
80-
let args: Vec<Bytes> = vec!["secp256k1_bench",
81-
"033f8cf9c4d51a33206a6c1c6b27d2cc5129daa19dbd1fc148d395284f6b26411f",
82-
"304402203679d909f43f073c7c1dcf8468a485090589079ee834e6eed92fea9b09b06a2402201e46f1075afa18f306715e7db87493e7b7e779569aa13c64ab3d09980b3560a3",
83-
"foo",
84-
"bar"].into_iter().map(|a| a.into()).collect();
84+
let args = [
85+
"secp256k1_bench",
86+
"033f8cf9c4d51a33206a6c1c6b27d2cc5129daa19dbd1fc148d395284f6b26411f",
87+
"304402203679d909f43f073c7c1dcf8468a485090589079ee834e6eed92fea9b09b06a2402201e46f1075afa18f306715e7db87493e7b7e779569aa13c64ab3d09980b3560a3",
88+
"foo",
89+
"bar",
90+
].into_iter().map(|a| Ok(a.into()));
8591
let mut decoder = MemoizedFixedTraceDecoder::new(build_decoder::<u64>(isa, version));
8692
let asm_core = AsmCoreMachine::new(isa, version, u64::MAX);
8793
let core = DefaultMachineBuilder::<Box<AsmCoreMachine>>::new(asm_core)
8894
.build();
8995
let mut machine = AsmMachine::new(core);
90-
machine.load_program(&buffer, &args).unwrap();
96+
machine.load_program(&buffer, args.clone()).unwrap();
9197
machine.run_with_decoder(&mut decoder).unwrap();
9298

9399
b.iter(|| {
94100
let asm_core = AsmCoreMachine::new(isa, version, u64::MAX);
95101
let core = DefaultMachineBuilder::<Box<AsmCoreMachine>>::new(asm_core)
96102
.build();
97103
let mut machine = AsmMachine::new(core);
98-
machine.load_program(&buffer, &args).unwrap();
104+
machine.load_program(&buffer, args.clone()).unwrap();
99105
decoder.clear_traces();
100106
machine.run_with_decoder(&mut decoder).unwrap()
101107
});
@@ -108,25 +114,27 @@ fn mop_memoized_dynamic_benchmark(c: &mut Criterion) {
108114
let isa = ISA_IMC | ISA_B | ISA_MOP;
109115
let version = VERSION2;
110116
let buffer = fs::read("benches/data/secp256k1_bench").unwrap().into();
111-
let args: Vec<Bytes> = vec!["secp256k1_bench",
112-
"033f8cf9c4d51a33206a6c1c6b27d2cc5129daa19dbd1fc148d395284f6b26411f",
113-
"304402203679d909f43f073c7c1dcf8468a485090589079ee834e6eed92fea9b09b06a2402201e46f1075afa18f306715e7db87493e7b7e779569aa13c64ab3d09980b3560a3",
114-
"foo",
115-
"bar"].into_iter().map(|a| a.into()).collect();
117+
let args = [
118+
"secp256k1_bench",
119+
"033f8cf9c4d51a33206a6c1c6b27d2cc5129daa19dbd1fc148d395284f6b26411f",
120+
"304402203679d909f43f073c7c1dcf8468a485090589079ee834e6eed92fea9b09b06a2402201e46f1075afa18f306715e7db87493e7b7e779569aa13c64ab3d09980b3560a3",
121+
"foo",
122+
"bar",
123+
].into_iter().map(|a| Ok(a.into()));
116124
let mut decoder = MemoizedDynamicTraceDecoder::new(build_decoder::<u64>(isa, version));
117125
let asm_core = AsmCoreMachine::new(isa, version, u64::MAX);
118126
let core = DefaultMachineBuilder::<Box<AsmCoreMachine>>::new(asm_core)
119127
.build();
120128
let mut machine = AsmMachine::new(core);
121-
machine.load_program(&buffer, &args).unwrap();
129+
machine.load_program(&buffer, args.clone()).unwrap();
122130
machine.run_with_decoder(&mut decoder).unwrap();
123131

124132
b.iter(|| {
125133
let asm_core = AsmCoreMachine::new(isa, version, u64::MAX);
126134
let core = DefaultMachineBuilder::<Box<AsmCoreMachine>>::new(asm_core)
127135
.build();
128136
let mut machine = AsmMachine::new(core);
129-
machine.load_program(&buffer, &args).unwrap();
137+
machine.load_program(&buffer, args.clone()).unwrap();
130138
decoder.clear_traces();
131139
machine.run_with_decoder(&mut decoder).unwrap()
132140
});

‎examples/check_real_memory.rs

+8-2
Original file line numberDiff line numberDiff line change
@@ -168,7 +168,10 @@ fn check_asm(memory_size: usize) -> Result<(), ()> {
168168
let core = DefaultMachineBuilder::new(asm_core).build();
169169
let mut machine = AsmMachine::new(core);
170170
machine
171-
.load_program(&Bytes::from(BIN_PATH_BUFFER), &vec![Bytes::from(BIN_NAME)])
171+
.load_program(
172+
&Bytes::from(BIN_PATH_BUFFER),
173+
[Ok(Bytes::from(BIN_NAME))].into_iter(),
174+
)
172175
.unwrap();
173176
let result = machine.run();
174177
assert!(result.is_ok());
@@ -192,7 +195,10 @@ fn check_asm_in_thread(memory_size: usize) -> Result<(), ()> {
192195
let core = DefaultMachineBuilder::new(asm_core).build();
193196
let mut machine = AsmMachine::new(core);
194197
machine
195-
.load_program(&Bytes::from(BIN_PATH_BUFFER), &vec![Bytes::from(BIN_NAME)])
198+
.load_program(
199+
&Bytes::from(BIN_PATH_BUFFER),
200+
[Ok(Bytes::from(BIN_NAME))].into_iter(),
201+
)
196202
.unwrap();
197203
let thread_join_handle = thread::spawn(move || {
198204
let result = machine.run();

‎examples/ckb_vm_runner.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,7 @@ fn main_asm(code: Bytes, args: Vec<Bytes>) -> Result<(), Box<dyn std::error::Err
4949
.syscall(Box::new(DebugSyscall {}))
5050
.build();
5151
let mut machine = ckb_vm::machine::asm::AsmMachine::new(core);
52-
machine.load_program(&code, &args)?;
52+
machine.load_program(&code, args.into_iter().map(Ok))?;
5353
let exit = machine.run();
5454
let cycles = machine.machine.cycles();
5555
println!(
@@ -71,7 +71,7 @@ fn main_int(code: Bytes, args: Vec<Bytes>) -> Result<(), Box<dyn std::error::Err
7171
let machine_builder = ckb_vm::DefaultMachineBuilder::new(core_machine)
7272
.instruction_cycle_func(Box::new(estimate_cycles));
7373
let mut machine = machine_builder.syscall(Box::new(DebugSyscall {})).build();
74-
machine.load_program(&code, &args)?;
74+
machine.load_program(&code, args.into_iter().map(Ok))?;
7575
let exit = machine.run();
7676
let cycles = machine.cycles();
7777
println!(

‎src/lib.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@ pub use crate::{
2222
instructions::{Instruction, Register},
2323
machine::{
2424
trace::TraceMachine, CoreMachine, DefaultCoreMachine, DefaultMachine,
25-
DefaultMachineBuilder, InstructionCycleFunc, Machine, SupportMachine,
25+
DefaultMachineBuilder, FlattenedArgsReader, InstructionCycleFunc, Machine, SupportMachine,
2626
},
2727
memory::{flat::FlatMemory, sparse::SparseMemory, wxorx::WXorXMemory, Memory},
2828
syscalls::Syscalls,
@@ -47,7 +47,7 @@ pub fn run<R: Register, M: Memory<REG = R> + Default>(
4747
WXorXMemory::new(M::default()),
4848
);
4949
let mut machine = TraceMachine::new(DefaultMachineBuilder::new(core_machine).build());
50-
machine.load_program(program, args)?;
50+
machine.load_program(program, args.iter().map(|e| Ok(e.clone())))?;
5151
machine.run()
5252
}
5353

@@ -63,7 +63,7 @@ pub fn run_with_memory<R: Register, M: Memory<REG = R>>(
6363
WXorXMemory::new(memory),
6464
);
6565
let mut machine = TraceMachine::new(DefaultMachineBuilder::new(core_machine).build());
66-
machine.load_program(program, args)?;
66+
machine.load_program(program, args.iter().map(|e| Ok(e.clone())))?;
6767
machine.run()
6868
}
6969

‎src/machine/asm/mod.rs

+6-2
Original file line numberDiff line numberDiff line change
@@ -666,15 +666,19 @@ impl AsmMachine {
666666
self.machine.inner.max_cycles = cycles;
667667
}
668668

669-
pub fn load_program(&mut self, program: &Bytes, args: &[Bytes]) -> Result<u64, Error> {
669+
pub fn load_program(
670+
&mut self,
671+
program: &Bytes,
672+
args: impl ExactSizeIterator<Item = Result<Bytes, Error>>,
673+
) -> Result<u64, Error> {
670674
self.machine.load_program(program, args)
671675
}
672676

673677
pub fn load_program_with_metadata(
674678
&mut self,
675679
program: &Bytes,
676680
metadata: &ProgramMetadata,
677-
args: &[Bytes],
681+
args: impl ExactSizeIterator<Item = Result<Bytes, Error>>,
678682
) -> Result<u64, Error> {
679683
self.machine
680684
.load_program_with_metadata(program, metadata, args)

0 commit comments

Comments
 (0)