Compile is 1.5–3× slower than QuickJS: the stack-code layer and front-end allocation

未关闭
#154 0 条评论 0 个 reaction 已指派 0 人 在 GitHub 查看

还没有人认领这个 Issue。

评估

难度
5/5
预计耗时
一周以上
新手友好度
30/100
Issue 类型
重构
描述清晰度
基本清楚
活跃度
活跃
技术栈
rust

调研方向

Start with the compiler path described in the issue: lexer and parser, FunctionIr, resolution, lowering, flow, and register::analysis; use compile_matrix.py and the listed profiles to locate the measured costs. The proposed direct IR-to-register lowering and front-end allocation changes span several compiler subsystems. Done means reaching within 1.5× of QuickJS on every listed corpus row while keeping Test262, the differential corpus, and register-stress unchanged.

由索引模型根据 Issue 内容生成。

描述

Compile-only throughput of 0.3.0 against QuickJS 2026-06-04 (compile_matrix.py, generated corpus, one process per sample, median of 5, Ryzen 7 7840HS):

Corpus Size oxide MB/s QuickJS MB/s QuickJS faster by
expressions 64 KB 11.7 27.2 2.3×
expressions 512 KB 10.0 29.7 3.0×
expressions 4 MB 10.3 25.0 2.4×
functions 64 KB 8.1 14.1 1.7×
syntax-mixed 64 KB 6.8 10.3 1.5×

(At 512 KB and 4 MB the functions and syntax-mixed corpora are superlinear in QuickJS, so those rows are left out; see the name-resolution issue for ours.)

The whole-program effect shows in Octane CodeLoad, 2.32× QuickJS's time: 56% of its samples are in the compiler and another 33% in malloc/free, mostly compile-time allocation. Top symbols: Lexer::next_token_into 8.8%, _int_malloc 4.8%, Parser::probe_token 4.7%, lowering::lower_unlinked_tree 4.1%, lowering::lower_ops 4.1%, register::analysis::analyze 4.0%.

Where the work goes

Source reaches register code through: lexer and parser → linear FunctionIr → resolution → lowering to QuickJS-shaped stack code (UnlinkedFunction) → relocation/flow/optimize → register::analysis (re-derives stack depth and catch regions per instruction) → register lowering → CodeStore::publish validation. QuickJS emits bytecode while parsing and then runs resolve_variables and resolve_labels.

  • The stack code is a complete intermediate representation (instructions, constants, debug tables, closure-variable tables) whose only consumer is the register lowering.
  • Stack depth is computed twice (flow and register::analysis); source positions are projected for stack code and mapped again for register code.
  • The lexer re-scans by cloning itself (probe_token), and the front end allocates per identifier and per function table without an arena.

Direction

  • Lower from the IR (after resolution) straight to register code, removing the stack-code layer and its second analysis.
  • Until then: hand flow's depths to the register lowering instead of recomputing them; cut front-end allocation (arena or reused buffers; no lexer clones for lookahead).

Acceptance: compile throughput within 1.5× of QuickJS on every corpus row above, with Test262, the differential corpus and register-stress unchanged.

主要语言
Rust
星标
61
派生
2
PR 合并指标
30 天内没有已合并 PR

环境准备

我们还没有检查这个项目的环境配置文件。先看它的 README,通用步骤见我们的新手贡献指南。

从这里开始

  1. 先读完整个 Issue,再读项目的贡献指南。
  2. 在 Issue 下留言说明你要接手 —— 这能避免两个人做同样的事。
  3. Fork 仓库,在一个分支上完成修改。
  4. 提交 Pull Request,并在描述里引用这个 Issue 编号。

pocket-stack/quickjs-oxide 的其他 Issue

查看 pocket-stack/quickjs-oxide 的全部 Issue

相似的 Issue

更多 Rust Issue

把新 issue 发到你的邮箱

精选适合新手参与的 GitHub issue 摘要。