openvm-circuit 2.0.1

OpenVM circuits
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use openvm_instructions::{instruction::Instruction, SystemOpcode, VmOpcode};
use openvm_stark_backend::p3_field::{PrimeCharacteristicRing, PrimeField32};
use openvm_stark_sdk::p3_baby_bear::BabyBear;

use super::PhantomExecutor;
use crate::{
    arch::{
        instructions::LocalOpcode,
        testing::{TestBuilder, TestChipHarness, VmChipTestBuilder},
        Arena, ExecutionState, PreflightExecutor,
    },
    system::phantom::{PhantomAir, PhantomChip, PhantomFiller},
};

type F = BabyBear;

fn run_phantom_test<E, RA>(
    tester: &mut impl TestBuilder<F>,
    executor: &mut E,
    arena: &mut RA,
    phantom_opcode: VmOpcode,
    num_nops: usize,
) where
    E: PreflightExecutor<F, RA>,
    RA: Arena,
{
    let nop = Instruction::from_isize(phantom_opcode, 0, 0, 0, 0, 0);
    let mut state: ExecutionState<F> = ExecutionState::new(F::ZERO, F::ONE);

    for _ in 0..num_nops {
        tester.execute_with_pc(executor, arena, &nop, state.pc.as_canonical_u32());
        let new_state = tester.execution_final_state();
        assert_eq!(state.pc + F::from_usize(4), new_state.pc);
        assert_eq!(state.timestamp + F::ONE, new_state.timestamp);
        state = new_state;
    }
}

#[test]
fn test_nops_and_terminate() {
    const NUM_NOPS: usize = 100;
    let phantom_opcode = SystemOpcode::PHANTOM.global_opcode();

    let mut tester = VmChipTestBuilder::default();
    let executor = PhantomExecutor::<F>::new(Default::default(), phantom_opcode);
    let chip = PhantomChip::new(PhantomFiller, tester.memory_helper());
    let air = PhantomAir {
        execution_bridge: tester.execution_bridge(),
        phantom_opcode,
    };
    let mut harness = TestChipHarness::with_capacity(executor, air, chip, NUM_NOPS);

    run_phantom_test(
        &mut tester,
        &mut harness.executor,
        &mut harness.arena,
        phantom_opcode,
        NUM_NOPS,
    );

    let tester = tester.build().load(harness).finalize();
    tester.simple_test().expect("Verification failed");
}

#[cfg(feature = "cuda")]
#[test]
fn test_cuda_phantom_tracegen() {
    use crate::{
        arch::{
            testing::{GpuChipTestBuilder, GpuTestChipHarness},
            EmptyMultiRowLayout,
        },
        system::{cuda::phantom::PhantomChipGPU, phantom::PhantomRecord},
    };

    const NUM_NOPS: usize = 100;
    let phantom_opcode = SystemOpcode::PHANTOM.global_opcode();
    let mut tester = GpuChipTestBuilder::default();

    let executor = PhantomExecutor::<F>::new(Default::default(), phantom_opcode);
    let air = PhantomAir {
        execution_bridge: tester.execution_bridge(),
        phantom_opcode,
    };
    let gpu_chip = PhantomChipGPU::new(tester.range_checker().device_ctx.clone());
    let cpu_chip = PhantomChip::new(PhantomFiller, tester.dummy_memory_helper());
    let mut harness =
        GpuTestChipHarness::with_capacity(executor, air, gpu_chip, cpu_chip, NUM_NOPS);

    run_phantom_test(
        &mut tester,
        &mut harness.executor,
        &mut harness.dense_arena,
        phantom_opcode,
        NUM_NOPS,
    );

    harness
        .dense_arena
        .get_record_seeker::<&mut PhantomRecord, EmptyMultiRowLayout>()
        .transfer_to_matrix_arena(&mut harness.matrix_arena);

    tester
        .build()
        .load_gpu_harness(harness)
        .simple_test()
        .expect("Verification failed");
}