fix: aot traits

[Maillew]

Add starting code for AotTraits to handle x86 assembly generation.

Refer to design overview here: https://hackmd.io/pKqAnYyzTymu3_34p28F8Q?view#AOT-Traits

[nyunyunyunyu]

We need assembles for the fallback operations anyway. Can we have a trait(AotFallback) for the fallback operations and generate a default implementation for structs implemented AotFallback? This will give us more flexibility if we want to override the implementation(e.g. a different way to preserve registers).

[Maillew]

sounds good, i can add this

[Maillew]

@nyunyunyunyu I think it may be a better idea to have the default implementations for fallback be feature-gated within the respective Executor and MeteredExecutor traits, instead of as a separate trait, since there shouldn't be a case where a struct has the AotFallback trait, but not the regular Executor trait, since the fallback requires the Executor trait to exist anyways

[nyunyunyunyu]

My thought is we could have something like this:

pub trait AotFallback: Executor + MeteredExecutor {}  
impl<F, E: AotFallback> AotExecutor for E {
  fn generate_x86_asm(&self, inst: &Instruction<F>) -> Result<String, AotError> {
    ...
  }
}

When you want a default implementation for an instruction X. You only need to:

impl AotFallback for X {}

[nyunyunyunyu]

Do we need pc to jump to a static label?

[Maillew]

we can discuss this with @GunaDD as well, but in the current example, extern_handler returns the updated PC value to register rax, and there is post-processing x86 assembly to determine where to jump next using the jump table. we can continue this convention that it should be on the onus of the generated x86 to write the next PC value to rax, and then it should be able to use any type of label

[nyunyunyunyu]

I think it means we need to read the jump table based on rax, which brings some extra overheads. If you know pc, for most jumps you can use only 1 instruction to jump into asm_run_pc_base_<pc>(sry the name might be inaccurate) at compile time.

[Maillew]

hm, if thats the case we can pivot so that this function is responsible for handling the updated PC value, and modify the fallback case that uses extern_handler to handle PC changes as well for consistency

[nyunyunyunyu]

Can you add a comment to show how generated ASMs look like and what the responsibility is? I feel we are not on the same page on that.

I supposed it generates:

balabala
call on_suspend
<exit if suspend>
<instruction execution logic>
<pc/context update>
<jump to next instruction>

@GunaDD mentioned the jump instruction for the dynamic case is:

    lea rdx, [rip + map_pc_base]
    movsxd rcx, [rdx + r13]
    add rcx, rdx
    jmp rcx

However if the jump point can be known at AOT compile time, we only need:

  jmp asm_execute_pc_<next_pc>

But we need to know the current PC in order to compute next_pc

[GunaDD]

Could you elaborate on how these traits will be integrated with the current create_assembly function in aot.rs?

[nyunyunyunyu]

Could you elaborate on how these traits will be integrated with the current create_assembly function in aot.rs?

@Maillew I think we have a working prototype here: https://github.com/openvm-org/openvm/blob/feat/aot-rv32-base-alu/crates/vm/src/arch/aot.rs Maybe let's integrate 1 RV32 instruction as an example?

[Maillew]

Could you elaborate on how these traits will be integrated with the current create_assembly function in aot.rs?

@Maillew I think we have a working prototype here: https://github.com/openvm-org/openvm/blob/feat/aot-rv32-base-alu/crates/vm/src/arch/aot.rs Maybe let's integrate 1 RV32 instruction as an example?

Yup, doing this rn

[github-actions]

group	app.proof_time_ms	app.cycles	app.cells_used	leaf.proof_time_ms	leaf.cycles	leaf.cells_used
verify_fibair	282	322,762	2,058,654	-	-	-
fibonacci	1,003	1,500,209	2,100,402	-	-	-
regex	2,338	4,137,502	17,695,216	-	-	-
ecrecover	736	122,859	2,262,718	-	-	-
pairing	1,463	1,745,742	25,468,210	-	-	-

Commit: 12f5b6f

Benchmark Workflow

[nyunyunyunyu]

I'm confusing. Is this different from a/8?

[GunaDD]

yeah that is exactly equal to a/8, I felt like I wanted to be more clear about it but I could probably just do a/8 and write some comments to explain that

[nyunyunyunyu]

Return an error instead of panic because this is due to the user inputs.

[nyunyunyunyu]

Remove "dep:openvm-rv32im-transpiler"