SkelOT: Reusing AOT Compilation Across EVM Contract Families
SkelOT reuses one native AOT artifact per EVM contract family, cutting Base compile units by 47.5%.
Ahead-of-time EVM compilers such as revmc, evmone, and DTVM reuse artifacts only by code hash, even though factory, proxy, and template deployments share instruction structure and differ mainly in constants. Across Base, Ethereum, BSC, and Arbitrum, 23.1-47.6% of unique compilable bytecodes mapped to shared family skeletons in 10K-block windows. SkelOT, built on revmc and LLVM, compiles one native artifact per family and loads variant constants from a per-contract table. On a 10K-block Base corpus of 3.52 million transactions it cut compilation units 47.5%, artifact footprint 57.4%, and compile time 2.19x, with a 1.31x median per-contract speedup and byte-identical execution.
- 23.1-47.6% of bytecodes share family skeletons on four EVM chains.
- SkelOT cut Base compilation units 47.5% and artifact footprint 57.4%.
- Compile time fell 2.19x with byte-identical results versus per-hash AOT.
- Median runtime speedup was 1.31x across family members.
Full article211 words · extracted from arxiv.org · click to collapse
Ahead-of-time (AOT) compilers (e.g., revmc, evmone, and DTVM) for the Ethereum Virtual Machine (EVM) reuse compilation artifacts at contract-code-hash granularity. This granularity is poorly matched to real EVM workloads dominated by \emph{contract families}: factory-, proxy-, and template-driven deployments that share instruction structure but differ in a small set of embedded constants. Across four EVM chains (Base, Ethereum, BSC, and Arbitrum), we find that 23.1--47.6\% of unique compilable bytecodes map to shared family skeletons within 10K-block windows. Per-hash AOT therefore redundantly recompiles structurally equivalent code, inflating compile time and artifact footprint while reducing workload coverage under finite compile budgets. We present \textsc{SkelOT}, an AOT framework that lifts the unit of compilation reuse from code hash to family skeleton. \textsc{SkelOT} compiles one native artifact per family, bakes invariant constants into the artifact, and reads variant constants from a per-contract runtime table. Built on revmc/LLVM and evaluated on a 10K-block Base mainnet corpus (3.52M transactions), \textsc{SkelOT} reduces compilation units by 47.5\%, artifact footprint by 57.4\%, and compile time by $2.19\times$, while preserving byte-identical execution outcomes versus per-hash AOT. At runtime, \textsc{SkelOT} delivers a $1.31\times$ median per-contract speedup across family members. Under a compile budget targeting 75\% execution-time coverage, \textsc{SkelOT} needs far fewer artifacts than per-hash AOT, and the advantage holds at every coverage target.
Text extracted automatically; images, tables and formatting may be missing. Original: https://arxiv.org/abs/2609.24404