Remove secp256k1 benchmark (#481)

* Remove secp256k1 benchmark

* Remove secp256k1 test

Author: mohanson

Cargo.toml

@@ -50,10 +50,5 @@ name = "bits_benchmark"
 path = "benches/bits_benchmark.rs"
 harness = false
 
-[[bench]]
-name = "vm_benchmark"
-path = "benches/vm_benchmark.rs"
-harness = false
-
 [lints.rust]
 unexpected_cfgs = { level = "warn", check-cfg = ['cfg(has_asm)'] }

benches/data/secp256k1_bench

@@ -1,14 +1,10 @@
 #![cfg(has_asm)]
 use ckb_vm::cost_model::constant_cycles;
-use ckb_vm::decoder::{DefaultDecoder, InstDecoder};
+use ckb_vm::decoder::InstDecoder;
 use ckb_vm::error::OutOfBoundKind;
-use ckb_vm::machine::asm::traces::{
-    MemoizedDynamicTraceDecoder, MemoizedFixedTraceDecoder, SimpleFixedTraceDecoder,
-};
-use ckb_vm::machine::asm::{
-    AbstractAsmMachine, AsmCoreMachine, AsmDefaultMachineBuilder, AsmMachine,
-};
-use ckb_vm::machine::{AbstractDefaultMachineBuilder, CoreMachine, VERSION0, VERSION1, VERSION2};
+use ckb_vm::machine::asm::traces::SimpleFixedTraceDecoder;
+use ckb_vm::machine::asm::{AsmCoreMachine, AsmDefaultMachineBuilder, AsmMachine};
+use ckb_vm::machine::{CoreMachine, VERSION0, VERSION1, VERSION2};
 use ckb_vm::memory::Memory;
 use ckb_vm::registers::{A0, A1, A2, A3, A4, A5, A7};
 use ckb_vm::{Debugger, DefaultMachineRunner, Error, ISA_IMC, Register, SupportMachine, Syscalls};
@@ -463,55 +459,6 @@ fn test_zero_address() {
     assert_eq!(result.unwrap(), 0);
 }
 
-#[test]
-fn test_memoized_secp256k1() {
-    let isa = ISA_IMC;
-    let version = VERSION1;
-    let buffer = fs::read("benches/data/secp256k1_bench").unwrap().into();
-    let asm_core = <AsmCoreMachine as SupportMachine>::new(isa, version, u64::MAX);
-    let core = AbstractDefaultMachineBuilder::<_, MemoizedFixedTraceDecoder<DefaultDecoder>>::new(
-        asm_core,
-    )
-    .build();
-    let mut machine = AbstractAsmMachine::new(core);
-    let args = [
-            "secp256k1_bench",
-            "033f8cf9c4d51a33206a6c1c6b27d2cc5129daa19dbd1fc148d395284f6b26411f",
-            "304402203679d909f43f073c7c1dcf8468a485090589079ee834e6eed92fea9b09b06a2402201e46f1075afa18f306715e7db87493e7b7e779569aa13c64ab3d09980b3560a3",
-            "foo",
-            "bar",
-        ].into_iter().map(|a| Ok(a.into()));
-    machine.load_program(&buffer, args).unwrap();
-    let mut decoder = MemoizedFixedTraceDecoder::new::<u64>(isa, version);
-    let result = machine.run_with_decoder(&mut decoder);
-    assert_eq!(result.unwrap(), 0);
-}
-
-#[test]
-fn test_memoized_dynamic_secp256k1() {
-    let isa = ISA_IMC;
-    let version = VERSION1;
-    let buffer = fs::read("benches/data/secp256k1_bench").unwrap().into();
-    let asm_core = <AsmCoreMachine as SupportMachine>::new(isa, version, u64::MAX);
-    let core =
-        AbstractDefaultMachineBuilder::<_, MemoizedDynamicTraceDecoder<DefaultDecoder>>::new(
-            asm_core,
-        )
-        .build();
-    let mut machine = AbstractAsmMachine::new(core);
-    let args = [
-            "secp256k1_bench",
-            "033f8cf9c4d51a33206a6c1c6b27d2cc5129daa19dbd1fc148d395284f6b26411f",
-            "304402203679d909f43f073c7c1dcf8468a485090589079ee834e6eed92fea9b09b06a2402201e46f1075afa18f306715e7db87493e7b7e779569aa13c64ab3d09980b3560a3",
-            "foo",
-            "bar",
-        ].into_iter().map(|a| Ok(a.into()));
-    machine.load_program(&buffer, args).unwrap();
-    let mut decoder = MemoizedDynamicTraceDecoder::new::<u64>(isa, version);
-    let result = machine.run_with_decoder(&mut decoder);
-    assert_eq!(result.unwrap(), 0);
-}
-
 #[test]
 pub fn test_big_binary() {
     let buffer = fs::read("tests/programs/big_binary").unwrap().into();
@@ -535,7 +482,7 @@ pub fn test_big_binary() {
 fn test_fast_memory_initialization_bug() {
     let isa = ISA_IMC;
     let version = VERSION1;
-    let buffer = fs::read("benches/data/secp256k1_bench").unwrap().into();
+    let buffer = fs::read("tests/programs/big_binary").unwrap().into();
     let asm_core = <AsmCoreMachine as SupportMachine>::new(isa, version, u64::MAX);
     let core = AsmDefaultMachineBuilder::new(asm_core).build();
     let mut machine = AsmMachine::new(core);

benches/data/secp256k1_bench_old

@@ -1,5 +1,4 @@
 pub mod machine_build;
-use bytes::Bytes;
 use ckb_vm::error::OutOfBoundKind;
 use ckb_vm::machine::{VERSION1, VERSION2};
 use ckb_vm::{
@@ -160,66 +159,6 @@ pub fn test_mop_ld_32_constants() {
     }
 }
 
-#[test]
-#[cfg_attr(miri, ignore)]
-pub fn test_mop_secp256k1() {
-    let args = vec![
-        Bytes::from("033f8cf9c4d51a33206a6c1c6b27d2cc5129daa19dbd1fc148d395284f6b26411f"),
-        Bytes::from(
-            "304402203679d909f43f073c7c1dcf8468a485090589079ee834e6eed92fea9b09b06a2402201e46f1075afa18f306715e7db87493e7b7e779569aa13c64ab3d09980b3560a3",
-        ),
-        Bytes::from("foo"),
-        Bytes::from("bar"),
-    ];
-
-    let mut machine = machine_build::int(
-        "benches/data/secp256k1_bench",
-        args.clone(),
-        VERSION1,
-        ISA_IMC | ISA_B | ISA_MOP,
-    );
-    let ret = machine.run();
-    assert!(ret.is_ok());
-    assert_eq!(ret.unwrap(), 0);
-    assert_eq!(machine.machine.cycles(), 611871);
-
-    let mut machine = machine_build::int(
-        "benches/data/secp256k1_bench",
-        args.clone(),
-        VERSION2,
-        ISA_IMC | ISA_B | ISA_MOP,
-    );
-    let ret = machine.run();
-    assert!(ret.is_ok());
-    assert_eq!(ret.unwrap(), 0);
-    assert_eq!(machine.machine.cycles(), 576608);
-
-    #[cfg(has_asm)]
-    {
-        let mut machine_asm = machine_build::asm(
-            "benches/data/secp256k1_bench",
-            args.clone(),
-            VERSION1,
-            ISA_IMC | ISA_B | ISA_MOP,
-        );
-        let ret_asm = machine_asm.run();
-        assert!(ret_asm.is_ok());
-        assert_eq!(ret_asm.unwrap(), 0);
-        assert_eq!(machine_asm.machine.cycles(), 611871);
-
-        let mut machine_asm = machine_build::asm(
-            "benches/data/secp256k1_bench",
-            args.clone(),
-            VERSION2,
-            ISA_IMC | ISA_B | ISA_MOP,
-        );
-        let ret_asm = machine_asm.run();
-        assert!(ret_asm.is_ok());
-        assert_eq!(ret_asm.unwrap(), 0);
-        assert_eq!(machine_asm.machine.cycles(), 576608);
-    }
-}
-
 #[test]
 pub fn test_mop_adc() {
     let mut machine =

benches/vm_benchmark.rs

@@ -56,56 +56,6 @@ fn test_resume2_asm_2_asm() {
     resume_asm_2_asm(VERSION0, 8126917);
 }
 
-#[test]
-fn test_resume2_secp256k1_asm_2_interpreter_2_asm() {
-    let data_source = load_program("benches/data/secp256k1_bench");
-
-    let version = VERSION1;
-    let except_cycles = 613073;
-
-    let mut machine1 = MachineTy::Asm.build(data_source.clone(), version);
-    machine1.set_max_cycles(100000);
-    machine1.load_program([
-        "secp256k1_bench",
-        "033f8cf9c4d51a33206a6c1c6b27d2cc5129daa19dbd1fc148d395284f6b26411f",
-        "304402203679d909f43f073c7c1dcf8468a485090589079ee834e6eed92fea9b09b06a2402201e46f1075afa18f306715e7db87493e7b7e779569aa13c64ab3d09980b3560a3",
-        "foo",
-        "bar",
-    ].into_iter().map(|e| Ok(e.into()))).unwrap();
-    let result1 = machine1.run();
-    assert_eq!(result1.unwrap_err(), Error::CyclesExceeded);
-    let snapshot1 = machine1.snapshot().unwrap();
-    assert!(!snapshot1.pages_from_source.is_empty());
-
-    let mut machine2 = MachineTy::Interpreter.build(data_source.clone(), version);
-    machine2.resume(snapshot1).unwrap();
-
-    assert_eq!(machine1.cycles(), machine2.cycles());
-    assert_eq!(machine1.full_registers(), machine2.full_registers());
-    #[cfg(not(feature = "enable-chaos-mode-by-default"))]
-    assert_eq!(machine1.full_memory(), machine2.full_memory());
-
-    machine2.set_max_cycles(100000 + 200000);
-    let result2 = machine2.run();
-    assert_eq!(result2.unwrap_err(), Error::CyclesExceeded);
-    let snapshot2 = machine2.snapshot().unwrap();
-    assert!(!snapshot2.pages_from_source.is_empty());
-
-    let mut machine3 = MachineTy::Asm.build(data_source, version);
-    machine3.resume(snapshot2).unwrap();
-
-    assert_eq!(machine2.cycles(), machine3.cycles());
-    assert_eq!(machine2.full_registers(), machine3.full_registers());
-    #[cfg(not(feature = "enable-chaos-mode-by-default"))]
-    assert_eq!(machine2.full_memory(), machine3.full_memory());
-
-    machine3.set_max_cycles(100000 + 200000 + 400000);
-    let result3 = machine3.run();
-    let cycles3 = machine3.cycles();
-    assert_eq!(result3.unwrap(), 0);
-    assert_eq!(cycles3, except_cycles);
-}
-
 #[test]
 fn test_resume2_load_data_asm_2_interpreter() {
     let data_source = load_program("tests/programs/resume2_load_data");