HN 日本語サマリー

← 一覧へ戻る
プログラミング

CPythonをykに適合させる

Adapting CPython for Yk (tratt.net)

74 pointsby frostbyte75 コメント

要約

この記事では、C言語で書かれたインタープリタにJITコンパイラを自動的に追加するツールであるykを、CPython(Pythonの標準インタープリタ)に適用した実験について詳述しています。開発者は、CPythonの「ティア2」インタープリタをykに適合させることで、既存のCPythonや実験的なJITコンパイラと比較して、多くのベンチマークで有意なパフォーマンス向上を達成しました。この作業は、インタープリタの内部構造を理解し、最適化のヒントを慎重に適用するプロセスを示しています。

全文翻訳

ykのためのCPythonの適合

今年の初めに、私はykについてブログ記事を書きました。これは、C言語のインタープリタにJITコンパイラを自動的に追加できるツールです。それ以来、ykをより多くのインタープリタに適用し、様々なバグを修正し、パフォーマンスを著しく向上させました。10月末には、ベンチマークスイート[1]でykluaがベースとしているPUC Luaインタープリタよりも2倍高速であることを示すデータを示しました。

私は自分自身にかなり満足していましたが、誰かが「大きなインタープリタでも機能することはどうやってわかるのか?」と尋ねてきて、現実に引き戻されました。それはもっともな質問です。PUC LuaはCPythonやCRubyよりも少なくとも1桁小さい[2]サイズであり、はるかに大きなインタープリタでも機能するかどうかを誰が言えるでしょうか?私たちは1年ほど前にCPythonを調べましたが、その時点ではykにはCPythonが必要とするいくつかの明白なものが欠けていたため、すぐに他のことに移りました。それ以来多くのことが変わり、簡単なLLM実験は、再度調べる価値があることを示唆するまで進みました。

幸いなことに、詳しく調べた結果、CPythonはykに適合させても(ykcpython[3]として)機能するだけでなく、通常のCPythonやPythonの実験的なJIT[4]と比較して、意味のあるパフォーマンス向上が見られました。大まかに言うと、これはykcpython自体に費やした3〜4日間の作業の結果であり、ykcpython自体を調べられる状態にするために、別途1週間半の一般的なykのバグ修正が必要でした。

以下は、ykcpythonとAWFYベンチマークスイートでの私の短い探求の「最終」数値です:

cpythoncpython_jitykcpython
Bounce19.27±0.2011.09±0.0510.09±0.04
CD32.21±0.2326.10±0.0829.33±0.16
DeltaBlue7.43±0.026.21±0.027.62±0.04
Json11.81±0.0810.93±0.059.98±0.03
List15.01±0.228.10±0.0510.44±0.09
Mandelbrot11.66±0.286.94±0.274.20±0.07
NBody18.97±0.1312.77±0.1210.98±0.02
Permute22.97±0.3417.95±0.1321.04±0.05
Queens13.18±0.149.65±0.118.32±0.03
Richards54.80±0.2040.56±0.4033.18±0.17
Sieve23.34±0.0617.02±0.0713.74±0.06
Storage22.03±0.1919.94±0.0819.67±0.04
Towers20.46±0.2512.65±0.0513.67±0.04

この表では、cpythonは「通常の」CPython 3.15.1、cpython_jitは実験的なJITを有効にしたCPython 3.15.1、ykcpythonはコミット31b4d387です。時間は秒単位(小さいほど良い)で、30回のプロセス実行からブートストラップされた平均値と99%信頼区間です。64コアのAMD EPYC 7773X Debianマシンでperformanceモードで実行しました(再現可能な実験と生データはこちらからダウンロードできます:https://tratt.net/laurie/blog/extra/2026/adapting_cpython_for_yk/adapting_experiment.tgz)。各行で最も速いエントリは太字で表示されています。

表の簡単な要約は次のとおりです:ykcpythonは、DeltaBlueを除くすべてのベンチマークでcpythonよりも高速であり(約2.5%遅い)、13のベンチマークのうち8つでcpython_jitよりも高速です。

この記事の目的は、ykcpythonが誰かが使用できる状態にあると主張することではありません。間違いなくそうではありません!また、より広い範囲のプログラムでパフォーマンスが上記の数値と同じくらいになると期待できると主張することでもありません。間違いなくそうではありません!私の見解では、ベンチマークスイートのパフォーマンスは、それ自体が目的というよりも、飛び越えるべきハードルです。ベンチマークでうまくいくシステムは、現実世界ではパフォーマンスが悪くなる可能性があります。しかし、ベンチマークでパフォーマンスが悪くなるシステムは、現実世界でもほぼ常にパフォーマンスが悪くなります。

むしろ、この記事を、インタープリタをykに適合させるのがどのようなものかを示す方法として使用したいと考えています。私が経てきた段階、そして追加したわずか450行未満のコードが意味のある効果を上げるのに十分であった感覚を伝えるためです。幸いなことに、これが有用な旅になる可能性があるという感覚があったため、この完全な記事を fleshing out するのに十分なものを書き留めることができました。

簡単な復習

以前のykの記事を読んでいない場合は、非常に簡単な復習です。わずかに変更されたCインタープリタ[6]を入力として与えると、ykはメタトレーシングJITコンパイラを備えたVMを出力します[7]。ykは可能な限り最速のJITコンパイル言語実装を生成することを目指しているわけではありません。むしろ、あなたが知っていて愛している言語実装を、100%の互換性を維持しながら、いくらか高速にすることを目指しています。別の言い方をすれば、「yk化された」インタープリタは、既存のCバージョンのインタープリタのフォークであり、(うまくいけば!)いくつかの調整が加えられています。

任意のメタトレーシングJITコンパイラと同様に、ykはゲスト言語(例:LuaまたはPython)のホットループを特定し、インタープリタをトレースします(つまり、ゲスト言語を解釈しながら実行されているCコードを記録します)。その後、それらのトレースを最適化し、マシンコードに変換します。

ykは、YkLocation構造体を通じて、ゲスト言語の潜在的なループがどこにあるかをインタープリタに伝える必要があります。オプションで(ただし、良いパフォーマンスを得たい場合は絶対に必要です!)、インタープリタの作成者は、言語やその一般的な使用法に関する知識を埋め込む最適化ヒントを追加できます。たとえば、「この時点で、この一見動的な値はほとんど変化しない」といったものです。一般的に、YkLocationをどこに配置するかは比較的簡単ですが、ヒントをどこに配置するかを理解するには、インタープリタのより深い理解と、どのヒントが役立つか役立たないかを理解するための慎重な測定が必要です。

インタープリタをykに適合させる際に私が直面する課題は、インタープリタをよく知っていることがほとんどないことです。一度にすべてをやろうとするのではなく、できるだけシンプルに始めることを学びました。私は、いくつかのトレースが記録され、マシンコードにコンパイルされるようになるための最小限の変更を試みます。これは、見かけよりも難しい場合があります。ビルドシステム[8]を理解し、いくらかまともなYkLocationをどこに配置するかを見つける必要があります。また、この最初のステップから言語のテストスイートが機能することを確認することも学びました。それを維持することははるかに簡単であるだけでなく、無効な最適化を試みる回数を減らします。

シンプルなインタープリタの場合、変更されたコード行数が10行未満のインタープリタから基本的なJITコンパイラを取得できます。ある程度大きなインタープリタの場合、さらにいくつかの変更が必要になる傾向があります。たとえば、ykはgotoを使用してオペコード間を移動する「スレッド化された」インタープリタを好みません。なぜなら、ykが介入して何が起こっているかを見る機会が十分に得られないからです。幸いなことに、そのような変更は一般的にそれほど大きくありません。

適切な開始点の発見

CPythonの内部[9]を調べたのは久しぶりだったので、漠然と知っていた部分から始めました。後で発見したように、これは現在「ティア1」インタープリタと呼ばれています。ykのサポートを迅速にハッキングしたところ、ykにいくつかの欠けているもの(基本的なアトミックロードから subにおける未実装ビット幅)、マイナーな非互換性(例:CPythonテストが削除した環境変数の読み取り)、そして明白なバグ(スタックマップの修正から fork後の無駄な処理の回避まで)が明らかになりました。それらをすべて修正するには約1週間半かかりました。これらはykcpython固有ではない一般的な修正なので、この記事で詳細を説明するつもりはありません。

ティア1インタープリタの私の適合[https://github.com/ykjit/ykcpython/pull/11]は意図的にミニマリストです。200行の差分のほとんどの変更は些細なもので、それほど興味深いものではありません。CPythonに(組み込みだがデフォルトではない)switchベースのインタープリタを使用させる必要があります。また、ykはシャドウスタックを使用するため、CPythonのCスタックリサイズもそれを考慮する必要があります。私がやった最も興味深いことは、バックワードジャンプオペコードにYkLocationを追加したことです。これにより、ある程度まともなトレースが作成されるのに十分だと予想していました。

この最初のバージョンのykcpythonがCPythonよりも高速になるとは予想していませんでした。最適化ヒントはほとんど含まれていませんでしたが、予想よりもはるかに遅かったです。トレースは確かに作成されており、正しく実行されていました。テストスイートはパスしましたが、メモリを予想より多く使用しました[10]。しかし、何かが明らかに正しくありませんでした。

幸いなことに、原因を突き止めるのに時間はかかりませんでした。4年前に、CPythonは「スペシャライゼーション」という見出しの下でクイックニングのサポートを追加しました。クイックニングは、可能な場合に「汎用」オペコード(例:「オブジェクトを追加」)を「特殊化された」より高速なオペコード(例:「2つの整数を追加」)に書き換える、シンプルで巧妙な手法であり、必要に応じて汎用オペコードに戻ります。私はクイックニングを、マシンコード生成の手間なしにJITコンパイラの利点の大部分を得るものと考えています[11]。ykにとっての問題は、プログラムのオペコードが特殊化されたオペコードと非特殊化されたオペコードの間で多数回遷移することがあり、ykサポートを追加した単純な方法では、各遷移で関連するトレースが暗黙的に破棄され、新しいトレースが作成されていました。ほとんどの場合、トレースは作成コストを上回るほど長くは使用されませんでした。

この問題を克服するテクニックがありますが、私はそれらを少し実験しました。しかし、昨年CPythonの開発者と話した会話を思い出しました。CPythonの内部を少し調べると、私の記憶が確認されました。CPythonには「ティア2」インタープリタも含まれています。これは完全に新しいインタープリタではありません。むしろ、メインインタープリタループのコア部分の代替実装であり、主にCPythonの実験的なJITコンパイラを対象としています。

さらに簡単な実験の後、ティア2インタープリタは、少なくとも基本的なレベルでは、yk[12]により適していることが示唆されました。そこで、ティア1サポートを削除し、ティア2インタープリタにykサポートを追加しました[https://github.com/ykjit/ykcpython/pull/12]。幸いなことに、ティア2サポートはティア1サポートよりもさらに簡単で、わずか80行のコードで構成されています。ykサポートがどのようなものか簡単に説明するために、ループの(開始)にYkLocationをアタッチする部分を以下に示します。

for (uint32_t i = 0; i < executor->code_size; i++) {
  const _PyUOpInstruction *uop = &executor->trace[i];
  if (_PyUOp_Uncached[uop->opcode] == _JUMP_TO_TOP) {
    uint16_t target = uop_get_jump_target(uop);
    if (yk_location_is_null(executor->yk_locs[target])) {
      executor->yk_locs[target] = yk_location_new();
    }
  }
}

この記事の残りの部分では、ykcpythonの開始点としてykとティア2インタープリタを使用します。

ベンチマークされているもの

任意の言語実装を最適化する際には、パフォーマンスが広範なパフォーマンスランドスケープの中でどこに位置するかを知ることが重要です。ykcpythonのパフォーマンスを理解するために、私は他の2つのベースラインを使用しました。「ストック」CPythonと、実験的なJITを備えたCPythonです。cpythonは次のように設定しました。

CC=clang-21 CXX=clang++-21 \
  ./configure \
  --enable-optimizations \
  --with-lto

後者がLLVM-21を必要とするため、cpythonとcpython_jitの両方に同じバージョンのLLVMを使用していることに注意してください。ykで使用されるLLVMのフォークであるykllvmは、LLVM-21よりも約6か月後のバージョンに基づいています[https://github.com/ykjit/ykllvm/pull/312]。これは比較をわずかに歪める可能性がありますが、効果はかなり小さいと期待できるほど小さな違いです。それを念頭に置いて、ykcpythonは次のように設定されています。

../configure \
  --without-computed-gotos \
  --without-tail-call-interp \
  --enable-experimental-jit=interpreter \
  --without-ensurepip

私は、smarr/are-we-fast-yetのベンチマークスイートの、私たちのフォーク[14]を使用しました。なぜなら、考えずに実行する方法を知っているからです。

次の課題は、パフォーマンスを報告するためのメトリックを定義することです。すべてのメトリックは誤解を招く可能性があり、多くは理解が困難です。私の意見では、最も悪くない単一のメトリックは壁時計時間です。プログラムが最初から最後まで実行されるのにどれくらいの時間がかかるか?これはすべてを捉えるわけではありませんが、多くのことを捉え、理解しやすいです。

最も重要なのは、このメトリックが起動時間とウォームアップ時間を暗黙的に含んでいることです。つまり、通常のインタープリタを優先し、JITコンパイラを「罰する」傾向のあるタイミングメトリックを意図的に選択しています。これをいくらか相殺するために、各AWFYベンチマークを10回のインプロセス反復(つまり、ベンチマーク全体を for 0..10 ループで実行)で実行するため、最適化の利点が長時間実行されるプログラムにどのように影響するかについても感覚を得られます。

記事の冒頭にある大きなパフォーマンステーブルは、アイドル状態のマシンでカスタムベンチマークランナーを使用しています。ここからのすべてのタイミングは、私が通常のユーザーとして time を一度実行したものであり、マシンが完全にアイドル状態かどうかをあまり気にしていません。インタープリタの最適化を開始するときは、多くのベンチマークで変更をベンチマークするために1時間待つのは実用的ではありません。効果は一般的にかなり大きいからです[15]。

インタープリタディスパッチの最適化

メタトレーシングのためにインタープリタを最適化する方法はいくつかあり、それぞれに長所と短所があります。ここで示す最適化のシーケンスは、その方法の1つにすぎません[16]。

cpythonのマンデルブロートベンチマークから始めましょう。

$ time cpython harness.py Mandelbrot 10 500
Starting Mandelbrot benchmark ...
Mandelbrot: iterations=1 runtime: 1166072us
Mandelbrot: iterations=1 runtime: 1163564us
Mandelbrot: iterations=1 runtime: 1166220us
Mandelbrot: iterations=1 runtime: 1164960us
Mandelbrot: iterations=1 runtime: 1166583us
Mandelbrot: iterations=1 runtime: 1166431us
Mandelbrot: iterations=1 runtime: 1168500us
Mandelbrot: iterations=1 runtime: 1168757us
Mandelbrot: iterations=1 runtime: 1165289us
Mandelbrot: iterations=1 runtime: 1170343us
Mandelbrot: iterations=10 average: 1166672us total: 11666719us

Total Runtime: 11666719us
cpython/python harness.py Mandelbrot 10 500  11.67s user 0.01s system 99% cpu 11.687 total

つまり、10回のインプロセス反復と500のパラメータでベンチマークを実行しました。AWFYハーネスは、各反復にどれだけの時間がかかったかを出力します。インタープリタでは一般的ですが、決して普遍的ではありませんが、CPythonは反復ごとに比較的安定した時間を示しました。

このベンチマークでは、cpython_jitは6.746秒(CPythonの0.58倍)、ykcpythonは驚異的な13.70秒(CPythonの1.17倍)かかります[17]。

$ time ykcpython harness.py Mandelbrot 10 500
Starting Mandelbrot benchmark ...
Mandelbrot: iterations=1 runtime: 1488078us
Mandelbrot: iterations=1 runtime: 1353013us
Mandelbrot: iterations=1 runtime: 1354018us
Mandelbrot: iterations=1 runtime: 1350854us
Mandelbrot: iterations=1 runtime: 1351681us
Mandelbrot: iterations=1 runtime: 1351815us
Mandelbrot: iterations=1 runtime: 1351454us
Mandelbrot: iterations=1 runtime: 1352860us
Mandelbrot: iterations=1 runtime: 1352099us
Mandelbrot: iterations=1 runtime: 1352516us
Mandelbrot: iterations=10 average: 1365839us total: 13658388us

Total Runtime: 13658388us
ykcpython/build-yk/python harness.py Mandelbrot 10 500  13.94s user 0.07s system 102% cpu 13.691 total

ここに注目すべき点がいくつかあります。まず、ウォームアップが発生していることがわかります。ykcpythonの最初の反復は、後続の反復よりも遅いです。これは私の考えでは問題ありません。ykは、0.数秒で実行されるプログラム向けではありません。次に、102% cpuとユーザー時間は、ykがトレースコンパイルをスレッドで実行しているため、壁時計時間よりも高くなっています。これにより、インタープリタは実行を継続でき、認識される一時停止を減らすことができます。

この状況で最初に行うことは、ykが生成したトレースの「高レベルIR」(HIR)を見て、それが妥当に見えるか確認することです。

$ YKD_LOG_IR=/tmp/l1:hir ykcpython harness.py Mandelbrot 10 500
... 
$ rg Begin /tmp/l1 | wc -l
11
$ rg Loop /tmp/l1 | wc -l
1

ログファイルには11個のトレースが含まれており、そのうち1つは「ループ」トレースです。一般的に、ループトレースはykが最も効果を発揮する場所であり、非ループトレースはループトレースという約束の地を得るために支払う代償です。この場合、簡単なプロファイルにより、ほとんどの実行時間が単一のループトレースに費やされていることが示され、ykにとって有望な出発点となります。

この時点で、HIRをこの高レベル分析よりもさらに詳しく調べるのは困難です。なぜなら、出力は次のような20,772行に及ぶからです。

%68: ptr = 0x13D581D4
%69: i8 = 0
store %69, %68
%71: i16 = load %64
%72: i32 = zext %71
%73: i32 = 32767
%74: i32 = and %72, %73
%75: i16 = trunc %74
%76: ptr = 0x13D58218
%77: ptr = load %76
%78: ptr = 0x0
%79: i1 = icmp eq %77, %78
guard false, %79, [%0, %2, %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, %64, %74, %75, %78, %56, %49, %50, %51, %52, %53]

この構文や思考方法に慣れている人でも、森を見て木を見失うのは非常に困難です。あまりにも多くのものがあります。そして、これは人間(またはAI)が読むだけでなく、問題です。より多くのHIRは、より多くのマシンコードを意味し、実行速度の低下を意味します。

インタープリタを最適化する際に、私の最初の関心事はインタープリタディスパッチに対処することです。インタープリタがプログラムを実行するとき、それは継続的に「現在の命令のオペコードは何ですか? addですか、それともsubですか…?」と尋ね、次に適切なアクションを実行するコードにディスパッチします。その20KLoCのHIRの大部分は、インタープリタがメモリからオペコードをロードし、それが何であるかを確認している可能性が高いです。ykのトレースオプティマイザには様々な古典的なコンパイラトリックがありますが、この場合、ほとんどの場合、同じ命令がメモリから2回ロードされる間に、そのメモリを変更した可能性のある他のコードが呼び出されるため、それらはあまり役立ちません。これは不要な保守主義ではありません。Pythonプログラムは実際にそれらの関数の命令を変更できます!

ティア2インタープリタが「エグゼキュータ」を使用しているため、私は特に幸運でした。エグゼキュータは(最適化された)命令のトレースです。これらの命令は、特定のエグゼキュータのコンテキストでは不変です。Python関数の命令が変更された場合、関連するエグゼキュータは無効になります。これにより、_PyExecutorObjectに単純な単調増加整数コードIDをアタッチでき、特定のコードIDに対して、インデックスIのオペコードは常に同じであることを知ることができます。

これにより、ykで最も効果的な最適化ヒントである冪等関数を使用できます。本質的に、冪等関数は「同じ入力に対して、この関数は常に同じ出力を生成する」と言います[18]。ここで「常に」は本当に「常に」を意味します!冪等はykがサポートできない非常に強力な保証です。それに失敗すると、システムは奇妙な方法で誤動作します。

ykはヘルパー関数yk_idempotent_loadを提供していますが、より特殊なものが必要です。幸いなことに、必要なものを書くのは難しくありません。

__attribute__((yk_idempotent))
uint16_t idempotent_load_opcode(uint64_t code_id, const _PyUOpInstruction *pc)
{
    __asm__ volatile("" : "+r"(code_id));
    return pc->opcode;
}

予想どおり、yk_idempotent属性はidempotent_load_opcodeが冪等関数であることをykに伝えます。つまり、特定のトレースで、関数が定数値のパラメータで呼び出された場合、ykはその冪等関数呼び出しを削除し、その出力に置き換えることができます。__asm__行は、LLVMが関数をインライン化しないように促すためです[19](関数がインライン化された場合、ykはもはやそこに冪等なものがあることを知りません)。

これを使用するには、コアインタープリターループの数行を変更する必要があります。最も重要な行は次のとおりです。

yk_promote(next_uop);
yk_promote_code_id(yk_code_id);
uopcode = idempotent_load_opcode(yk_code_id, next_uop);

プロモーション(例:yk_promote)[20]は、「この変数は半定数であることが期待される:その具体的な値を記録し、その値が後で変更された場合に備えてガードを挿入してトレースを特殊化する」と言います。yk_promote(x)があり、後でトレースが記録されたときに、xが偶然3だったと想像してください。トレースはguard true (x == 3)を記録します。後続の実行でxが3でなかった場合、ガードは失敗し、トレースは非最適化されます。ガードが成功した場合、今後xが確実に3であることを知ることができます。

つまり、記録しているトレースのコンテキストでは、ykは定数引数を持つidempotent_load_opcodeへの呼び出しを見て、関数呼び出しを定数結果に置き換えることができます。これのポイントは、ロードコストを削除するだけではありません。むしろ、定数データをykのトレースオプティマイザに公開することで、トレースの最適化をはるかにうまく行うことができます。この場合の効果はかなり大きいです。

$ time ykcpython harness.py Mandelbrot 10 500
Starting Mandelbrot benchmark ...
Mandelbrot: iterations=1 runtime: 606714us
Mandelbrot: iterations=1 runtime: 485324us
Mandelbrot: iterations=1 runtime: 485994us
Mandelbrot: iterations=1 runtime: 484999us
Mandelbrot: iterations=1 runtime: 483824us
Mandelbrot: iterations=1 runtime: 485431us
Mandelbrot: iterations=1 runtime: 484752us
Mandelbrot: iterations=1 runtime: 486160us
Mandelbrot: iterations=1 runtime: 486125us
Mandelbrot: iterations=1 runtime: 483481us
Mandelbrot: iterations=10 average: 497280us total: 4972804us


Total Runtime: 4972804us
ykcpython/build-yk/python harness.py Mandelbrot 10 500  5.09s user 0.08s system 103% cpu 5.005 total

つまり、その単純な変更により、ykcpythonは2.7倍高速になっただけでなく、CPythonの0.43倍、cpython_jitの0.74倍になりました!つまり、30行のコードを変更した単純なPRにより、このベンチマークはCPythonの2倍以上、CPythonのJITの25%高速になりました。この最適化の効果を判断する別の方法は、20,772行のHIR出力を7,648行に削減したことです[21]。

コードは最適化されるためにトレースされる必要がある

しかし、浮かれる前に、これだけではすべてのベンチマークが魔法のように速くなるわけではありません。経験から、過学習を避けるためにベンチマークをローテーションすることを学びました[22]。この場合、ykluaで難しいターゲットであることがわかっているデルタブルーベンチマークを見てみることにしました。ykcpythonでの状況は予想よりも悪かったです。cpythonは7.67秒、cpython_jitは6.20秒、そしてykcpython(冪等変更あり)は37.51秒かかります。ひどい!

私の次の関心事は、トレースがコンパイルできない場合に警告を表示する YKD_LOG=2 を実行することです。案の定です。

$ ykcpython harness.py DeltaBlue 10 12000
Starting DeltaBlue benchmark ...
yk-warning: stop-tracing-aborted: Trace too long
yk-warning: stop-tracing-aborted: Trace too long
yk-warning: stop-tracing-aborted: Trace too long
yk-warning: stop-tracing-aborted: Trace too long
yk-warning: stop-tracing-aborted: Trace too long
yk-warning: stop-tracing-aborted: Trace too long
DeltaBlue: iterations=1 runtime: 3362822us
yk-warning: trace-compilation-aborted: Unimplemented: '%188 = atomicrmw or ptr %187, i64 16 seq_cst, align 8'
...

今のところ「トレースが長すぎる」はスキップします。本質的にykには、「このトレースは長すぎておそらく役に立たない」という固定された制限があります。制限が低すぎたため、この記事の作業を行う前に一方的に引き上げました。正確な値が何であるかはわかりません。実際、この粗雑なヒューリスティックはおそらくより洗練されたものに置き換える必要があると考えています。それは別の日の問題です。

「未実装」の警告に進みましょう。まだ複雑なアトミック命令を実装する時間がありませんでした。そのため、それらのいずれかに遭遇すると、ykはそのトレースを完全に断念するしかありません。それがベンチマークのホットな部分である場合、パフォーマンスを完全に低下させることができます。この場合、幸いなことに、atomicrmwの警告は、そもそもトレースにインライン化すべきではない関数から発生しました。

トレーシングの利点の1つは、関数を積極的にインライン化することですが、それは後続の実行で失敗しすぎるチェックをインライン化する可能性があります。たとえば、デフォルトでインライン化される関数の一つに_PyObject_GC_Linkがあります。これは、ガベージコレクションのスケジュールに値するかどうかを判断するために十分なオブジェクトが割り当てられたかどうかをチェックします。運が悪ければ、ガベージコレクションをスケジュールするループの反復をトレースする可能性があります。ほとんどの後続の実行では、結果のガードは失敗し、やや遅いパスを取ることになります。ここでの解決策は、そのような関数をyk_outlineとしてマークすることです。

__attribute__((yk_outline))
void _PyObject_GC_Link(PyObject *op) { ... }

yk_outlineとしてマークされた関数は、トレースではcallになります。おそらくyk_outlineとしてマークされるべき関数は多数ありますが、警告を発生させ、かつトレースに含めたくないと明白な2つをマークしました[https://github.com/ykjit/ykcpython/pull/14]。これを行うことで実行時間が36.63秒(約2.5%高速)に改善されましたが、このケースでの減速の主な原因ではないことは明らかです。

私が心配し始めたちょうどその時、実行のプロファイリングにより、驚いたことに、デルタブルーは実行時間の約半分しかJITコンパイルされたコードで費やしておらず、90%以上を費やすと予想されるはずでした。主な理由は、すべてのエグゼキュータが_JUMP_TO_TOPオペコードを持っているわけではなく、トレースされていなかったことです。

私の迅速な修正は、エグゼキュータの最初のオペコードにYkLocationを追加することでした。1行の修正はまさにそれを行います。これにより、ykはエグゼキュータに入るとすぐにトレースを開始します。これを行うことで、デルタブルーの実行時間は8.64秒に改善されます(以前より4.23倍高速)。それでもCPythonの1.13倍ですが、以前よりはるかに良くなりました!

この変更を行ったとき、エグゼキュータの先頭にYkLocationを追加することが、すでに_JUMP_TO_TOPに追加されたYkLocationとどのように相互作用するかを完全に考えませんでした。運の良いことに、私は合理的な組み合わせを偶然見つけました。_JUMP_TO_TOPは通常、インデックス1の命令にジャンプします。それでも、エグゼキュータにYkLocationを追加するより良い方法があるかもしれませんが、すべての問題を一度に解決することはできません。次のことに進む時間です!

インタープリタディスパッチのさらに奥へ

以前の冪等ロードの使用はインタープリタディスパッチに非常に大きな影響を与えたため、それが単純で浅い変更であったことを見落としがちです。それは命令オペコードの種類をロードするのを最適化しただけでした。命令には、同様に冪等ロードに適した他のフィールドがいくつか含まれています。

これらの追加フィールドを最適化する方法はいくつかあります。たとえば、ヘッダーファイル内のいくつかのstatic関数の定義を置き換えることもできます。シンプルにするために、必要な2つのパラメータ関数を生成できるマクロを定義し、その後、適切なポイントでそれを呼び出すように他のマクロを調整しました。結果の変更により、デルタブルーのパフォーマンスは8.09秒に改善されました。私たちは今、CPythonのパフォーマンスの10%以内に入っています。

アンローリング

前述のように、すべての関数がトレースにインライン化されるのに適しているわけではありません。ykには非常に単純なヒューリスティックがあります。RPython/PyPyから無造作に盗まれたもので、ループを含む関数を「アウトライン化」としてマークします。つまり、Cが関数f()を呼び出し、fがfor (...) { ... }を含む場合、ykはfへの呼び出しをインライン化しません。

関数(ループ付き)をインライン化しない根本的な理由は、トレースがループを展開し、それが良いアイデアではない傾向があることです。第一に、一部のループは膨大な数の反復を実行するため、逆効果的に長いトレースが発生します。第二に、ループの反復は動的で常に変化する値によって制御されることがよくあります。展開すると、トレースはその値の1つに特殊化され、他のすべての値で最適ではないパフォーマンスが得られます。

しかし、インタープリタには、積極的に展開したい少数の関数があります。通常、それらの関数のループは2つのプロパティを満たします。反復回数が少なく、反復回数はユーザープログラムの側面によって決まり、まれにしか変更されません。たとえば、unpack_args(int num_args)という名前の関数で、for (int i=0; i<num_args; i++)が含まれている場合、これは良い候補となるでしょう。なぜなら、トレースの同じ場所で呼び出されるたびに、おそらく同じ数のパラメータをアンパックするからです。

ykはyk_unroll属性を提供しており、これは、アウトライン化される可能性のある関数を実際にはインライン化してループを展開するようにykに通知します。CPythonのすべての関数を調べて候補を探すのではなく、HIRで単純なgrep/sortを実行して、トレースに最も頻繁に現れる(暗黙的に非インライン化された)C関数を確認しました[23]。

$ YKD_LOG_IR=/tmp/l1:hir ykcpython harness.py Json 10 100
... 
$ rg call /tmp/l1|grep "@"|cut -d "@" -f 2|sort|uniq -c|sort -n
   2 PyLong_FromLong
   6 _Py_HandlePending
   6 do_lookup
  24 _PyList_FromStackRefStealOnSuccess
  50 _PyEvalFramePushAndInit
  50 _PyObject_GC_Link
  50 _PyObject_InitInlineValues
 263 PyLong_FromSsize_t
1035 _PyFrame_Initialize.5328
1158 _PyFrame_ClearLocals
1194 bcmp

bcmpは標準のlibc関数です。他のすべての関数はCPython自体にあります。これらのすべての関数にループが含まれているわけではありませんが、ほとんどが含まれている可能性が高いです。私がこのような状況で行うことは、リストを下に(または見方によっては上に)移動し、各関数のコードを見ることです。一般的な関数をいくつかカバーするために、いくつかのベンチマークでそれを行いました。

最も頻繁に呼び出される2つのCPython関数は、すぐに良い候補に見えました。_PyFrame_Initializeは最も明白なもので、私が最も一致させたいパターンをほぼ正確に含んでいます。

_PyFrame_Initialize(..., int null_locals_from, ...) {
  ... 
  for (int i = null_locals_from; i < code->co_nlocalsplus; i++) {
    frame->localsplus[i] = PyStackRef_NULL;
  }
  ... 
}

_PyFrame_ClearLocalsは少しトリッキーです。ポインタ演算を含むwhileループが含まれていますが、良い候補であると確信するにはそれほど時間はかかりませんでした。

以前に_PyObject_GC_Linkをインライン化不可能にしたので、それを元に戻したくありません!同様に、do_lookupは辞書で値を検索するため、アウトライン化されたままにしておきたいです。それは頻繁に変化する動的な値に依存します。

PyLong_FromSsize_tとPyLong_FromLongは判断が難しかったです。これらの関数の内部ループは動的な値に依存しますが、実際にはかなり安定していると推測しています。初期の判断が正しかったという中程度の自信しかないので、将来的にはこれらの関数に注意を払うつもりです。

これらの例が示唆するように、私は一般的にyk_unrollを追加することにかなり慎重です。不適切な配置は、1つのベンチマークを助け、他の多くのベンチマークを悪化させる可能性があります。そのため、通常は1つか2つの関数をyk_unrollとしてマークし、ベンチマークしてから次に進みます。この場合、5つの小さなPRを実行した結果、JSONのパフォーマンスは11.52秒から10.85秒に改善されました。

間接インライン化

一般的に、C言語のほとんどの関数呼び出しは直接です。f()はfという名前の関数を呼び出します。しかし、少数の関数は間接です。fは、互換性のある任意の関数になりうる汎用ポインタです。これは、実行時に型固有のコードへのディスパッチを可能にするために、インタープリタで一般的に使用されます。

デフォルトでは、ykは間接関数呼び出しをインライン化できません。なぜなら、どのポインタが呼び出されているかを正確に知らずに、実行がたどったパスを確実に再構築できないからです[24]。幸いなことに、この問題を解決するために必要なツールはすでにあります。yk_promoteです!ykが間接関数呼び出しで定数ポインタを目にした場合、どの関数が呼び出されているかを正確に知り、通常どおりインライン化できます。私が使用する一般的なパターンは次のとおりです。

function_type f = ...;
if (!yk_is_interpreting())
  yk_promote(f);
(f)(...);

yk_is_interpreting()は「通常の」解釈中はtrue、トレース中はfalseです。そして(定数falseであるため)トレース中は削除されます。つまり、yk_promoteはトレースフェーズ中にのみ呼び出されます。yk_is_interpreting()はかなり高速(yk_promote()よりもはるかに高速)なので、このイディオムは小さくても有用なパフォーマンス向上です。

しかし、しばしば第二の問題があります。ykは、トレース可能なパスから到達可能であることが静的に証明できる場合にのみ、関数にトレース機構を配置します。一般的に、間接呼び出しから呼び出される関数はトレース可能であることが静的に証明できず、そのためトレースにアウトライン化された呼び出しが残ります。これはyk_indirect_inline関数で解決できます。これはykに「この関数は間接呼び出しから到達可能であり、トレースの対象として考慮されるべきです」と伝えます[25]。

いくつかのベンチマークのプロファイリングにより、すぐにいくつかの有望な候補が見つかりました[26]。私の経験では、すべての間接呼び出しサイトがプロモーションに適しているわけではありません。たとえば、これまで調べたインタープリタの中で、mallocとfreeの間接呼び出しをインライン化しても利益が得られることはめったにありませんでした。しかし、私はすぐに有望な候補をいくつか見つけました。

より有望ではないが、説明しやすい方から始めましょう。デルタブルーやJSONのようなベンチマークは、リストや文字列のlenを呼び出します。簡単に言うと、sq_lengthはCPythonの型内の関数のポインタなので、これはトレースでは間接呼び出しになります。len([...])の場合、最終的に呼び出される関数はlist_lengthです。

static Py_ssize_t list_length(PyObject *a) {
  return PyList_GET_SIZE(a);
}

ここでPyList_GET_SIZEは、単純なロードa->ob_sizeに(わずかに省略されて)還元されます。これは、ykがトレースにインライン化されるのを見るのが好きなコードの種類です!

結果のPRでは、ykがyk_promote呼び出しを受け入れるようにするために、少し面倒なダンスを行う必要があります。本質的に、yk_promoteがykllvmによってトレースする必要がないと判断された関数に静的にインライン化された場合、奇妙なことが起こり、ykllvmは静的エラーを発生させます。この場合、「yk_promoteを含むべき」関数は複数のパスでインライン化される可能性があり、そのうちの1つがこのチェックに違反します。ハッキーな修正は、プロモートを静的にインライン化されない関数に引き出すことです[27]。その後、2番目のPRでrangeの構築と反復をインライン化しました。

これらの両方のPRで、ベンチマーク証拠よりもはるかに多くの関数をyk_indirect_inlineとしてマークしていることに気づくかもしれません。その理由は、上記で言及したことのバリエーションです。私の経験では、間接呼び出しサイトは、ほとんどすべてのターゲットが間接インライン化の恩恵を受けるか、まったく受けないかのどちらかです。これは明らかに宇宙の鉄則ではありませんが、私がやること、つまりすべての可能なターゲットを見て、それらが妥当に見える場合はyk_indirect_inlineとしてマークすることです。これまでのところ、後悔したことはめったにありません。

これら2つのPRを collectively に実行すると、JSONのパフォーマンスは10.41秒に低下しますが、デルタブルーへの影響は、何も言えないほど小さかったです。インタープリタをykに適合させるにつれて、これは一般的です。すべてのベンチマークがすべての最適化の恩恵を受けるわけではありません。

まとめ

この時点で、インタープリタをyk化するアプローチの感覚を掴んでいることでしょう。さらにいくつかのPRを提起しましたが、この投稿に概念的に有用なものを追加することはできないと気づきました。この段階の作業を終了し、書き留める時間でした。

この小さな旅を始める前に、ykがCPythonのようなサイズと複雑さのインタープリタで本当に機能するかどうか、ましてや「うまく」機能するかどうかは確信が持てませんでした。初期段階では、私の懸念は完全に払拭されませんでした。ykcpythonが機能するために修正する必要のある、ykの欠けている部分やバグがたくさんありました。ykcpythonが機能し、かなりうまく機能するという事実は、少なくとも1つの大きくて複雑なインタープリタが比較的容易にyk化でき、パフォーマンスで驚くほど競争力があることを証明しています。

もちろん、私は多くの点で幸運です。ykはすでに、数人のハードワークのおかげで、まともな基盤を持っていました。CPythonのティア2インタープリタは、私の人生を以前よりもはるかに楽にしてくれました。小さなベンチマークは、この投稿で使用したようなものは、JITコンパイル技術としての(メタ)トレーシングを称賛する傾向があります。そして、インタープリタをyk化することに関しては、私は何度か経験があります。

しかし、物事を完全に過小評価したくはありません。3〜4日というのは、CPythonのようなインタープリタに費やすにはそれほど長い時間ではありません。LLMの驚異が旅をスピードアップするのを助けてくれたとしても、徹底的な仕事をしてykcpythonがykに公開できるすべてのジュースを絞り出すには、はるかに長い時間がかかります。同様に、私は数個のベンチマークしか見ていません。ykcpythonがまだ幅広いプログラムを魔法のようにスピードアップするとは考えにくいです。なぜなら、最適化を考慮する必要のあるCPythonの他の多くの部分があるからです。これの多くはロケット科学ではありませんが、それは仕事であり、そのすべてをまだ自動化できるわけではありません。

また、私はまだykcpythonに特化したykのパフォーマンス最適化を行っていません(ただし、以前は無視できたいくつかのボトルネックを修正しました)。特に、私が完全に確信していることの1つは、ykcpythonがykがまだ効果的に最適化していないHIRパターンを生成することです。それらを修正すると、ykcpythonのパフォーマンスが無料で、おそらくかなり向上します。それなしでも、ykcpythonは以前は問題にならなかったykの追加のボトルネックを浮き彫りにしました。それらのそれぞれが修正されるたびに、ykcpythonは魔法のように高速になります。

ある意味で、これはykが提供する良い点の1つです。ykの改善は、ほぼ常にすべてのyk化されたインタープリタに利益をもたらします。私が短期間でykcpythonを軌道に乗せることができた理由です。私はゼロからJITコンパイラを書いているのではなく、汎用ツールキットを再利用していました。たとえば、ykcpythonがykで明らかにしたさまざまな欠けている部分やバグは、次のインタープリタをyk化するのを間違いなく容易にするでしょう。そして、ykの将来の改善はykcpythonをさらにさらに良くするでしょう!

謝辞: Edd BarrettとLukas Diekmannはykの初期の作業の多くを行いました。ShopifyとRoyal Academy of Engineeringは、基盤となる研究に寛大に資金を提供しました。Chris Seatonは、ykの作業を可能にした人物でした。

2026-11-12 12:10 古い記事

新しいブログ記事の更新情報をご希望の場合は、MastodonまたはTwitterでフォローしてください。または、RSSフィードを購読するか、メール更新を購読してください。

注釈

1

AWFYおよびCBLGスイートと、他のソースから抽出したいくつかの「実際の」ベンチマークの組み合わせ。

☒

AWFYおよびCBLGスイートと、他のソースから抽出したいくつかの「実際の」ベンチマークの組み合わせ。

2

PUC Luaは、私が他に見たことのないスタイルで書かれています。最初は、深くネストされたマクロの使用と広範な暗黙の規約に圧倒されました。それに時間を費やすにつれて、コードの構造の美しさを深く理解するようになりました。コードの文字通りの美しさだけでなく、コードを高速に実行できるようにするためにどれだけの考えが費やされたかについてもです。

☒

PUC Luaは、私が他に見たことのないスタイルで書かれています。最初は、深くネストされたマクロの使用と広範な暗黙の規約に圧倒されました。それに時間を費やすにつれて、コードの構造の美しさを深く理解するようになりました。コードの文字通りの美しさだけでなく、コードを高速に実行できるようにするためにどれだけの考えが費やされたかについてもです。

3

命名は私の得意ではありません。

☒

命名は私の得意ではありません。

4

実験的なJITは削除される可能性がありますが、その正確な状況は私には不明です。

☒

実験的なJITは削除される可能性がありますが、その正確な状況は私には不明です。

5

また、この記事が将来エージェントがインタープリタをyk化する上でより良い仕事をするのに役立つことを願っています。現状では、非常に巧妙な機会を見つけますが、多くの明白な機会を見逃しており、見つけた機会を過度に複雑にする傾向があります。

☒

また、この記事が将来エージェントがインタープリタをyk化する上でより良い仕事をするのに役立つことを願っています。現状では、非常に巧妙な機会を見つけますが、多くの明白な機会を見逃しており、見つけた機会を過度に複雑にする傾向があります。

6

技術的にはLLVM IRを持つ任意のインタープリタです。C++インタープリタの少なくとも一部が機能することはテストしましたが、(例えば)Rustインタープリタが機能するかどうかは将来の懸念事項です。

☒

技術的にはLLVM IRを持つ任意のインタープリタです。C++インタープリタの少なくとも一部が機能することはテストしましたが、(例えば)Rustインタープリタが機能するかどうかは将来の懸念事項です。

7

ykを考える別の方法は、それがLLVM IRのためのRPython(つまり「PyPy」)であるということです。それは示唆するように、ykはRPythonに深い借りがあり、それがその主なインスピレーションです。

☒

ykを考える別の方法は、それがLLVM IRのためのRPython(つまり「PyPy」)であるということです。それは示唆するように、ykはRPythonに深い借りがあり、それがその主なインスピレーションです。

8

誰かが他人のビルドシステムを見るのを好む人はいません。

☒

誰かが他人のビルドシステムを見るのを好む人はいません。

9

CPythonと私はかなり長い付き合いです。1997年か1998年に、RISC OSパッチをCPythonに貢献したと思います。私が関与したと確実に言える最初のコミットは1999年でした。それ以来、CPythonは大きく変化しました!

☒

CPythonと私はかなり長い付き合いです。1997年か1998年に、RISC OSパッチをCPythonに貢献したと思います。私が関与したと確実に言える最初のコミットは1999年でした。それ以来、CPythonは大きく変化しました!

10

執筆時点では、ykはトレースに関連するメモリを解放しません。ほとんど必要な部分を実装しましたが、最後の部分を完成させるだけです。

☒

執筆時点では、ykはトレースに関連するメモリを解放しません。ほとんど必要な部分を実装しましたが、最後の部分を完成させるだけです。

11

CPythonにこれがあることを完全に忘れていました。恥ずかしいです。なぜなら、以前は様々なインタープリタにその組み込みを主張していたからです。成功は大きくありませんでしたが。

☒

CPythonにこれがあることを完全に忘れていました。恥ずかしいです。なぜなら、以前は様々なインタープリタにその組み込みを主張していたからです。成功は大きくありませんでしたが。

12

いくつかの欠けている部分やバグがykで見つかり、修正する必要がありましたが、それでも確信を持つことができました。

☒

いくつかの欠けている部分やバグがykで見つかり、修正する必要がありましたが、それでも確信を持つことができました。

13

不思議に思うかもしれませんが、これは非常に高速です。YkLocationは単語サイズの値で、その場所がホットにならない限り、追加のメモリは関連付けられません。アイデアは、コールドコードの一般的なケースのコストを非常に低くすることです。

☒

不思議に思うかもしれませんが、これは非常に高速です。YkLocationは単語サイズの値で、その場所がホットにならない限り、追加のメモリは関連付けられません。アイデアは、コールドコードの一般的なケースのコストを非常に低くすることです。

14

技術的にはサブセットです。なぜなら、Havlakは標準CPythonではそのまま機能しないからです。

☒

技術的にはサブセットです。なぜなら、Havlakは標準CPythonではそのまま機能しないからです。

15

インタープリタが成熟し、最適化の効果が小さくなるにつれて、より注意深くなる必要があります。ykcpythonはまだそこまで到達していません!

☒

インタープリタが成熟し、最適化の効果が小さくなるにつれて、より注意深くなる必要があります。ykcpythonはまだそこまで到達していません!

16

ykcpythonは、ほとんどの人が昔ながらの経験しかしたことのない制約を課しています。私のマシンではリンクに数分かかります。非常に高速なコンパイルに慣れている人にとっては、これはショックとなる可能性があります。幸いなことに、後でわかるように、少数の小さな変更が大きな効果をもたらしたため、当初予想していたほど煩わしくはありませんでした。

私はリンク速度を2倍以上に改善するローカルパッチを持っていますが、それが正しいかどうかまだ確信が持てません。この記事で説明されていることには使用していません。

☒

ykcpythonは、ほとんどの人が昔ながらの経験しかしたことのない制約を課しています。私のマシンではリンクに数分かかります。非常に高速なコンパイルに慣れている人にとっては、これはショックとなる可能性があります。幸いなことに、後でわかるように、少数の小さな変更が大きな効果をもたらしたため、当初予想していたほど煩わしくはありませんでした。

私はリンク速度を2倍以上に改善するローカルパッチを持っていますが、それが正しいかどうかまだ確信が持てません。この記事で説明されていることには使用していません。

17

ykでのウォームアップコストを可能な限り低くするために多くの作業を行いましたが、ゼロになることはありません。最初の反復は、トレースなどの作業を行っているため、後続の反復よりも10%遅いです。

☒

ykでのウォームアップコストを可能な限り低くするために多くの作業を行いましたが、ゼロになることはありません。最初の反復は、トレースなどの作業を行っているため、後続の反復よりも10%遅いです。

18

関数が内部の状態を変更しても問題ありません。ただし、(1)常に同じ入力に対して同じ出力を生成することを保証し、(2)呼び出しとその変更を削除しても全体的な正しさに影響しない場合です。

☒

関数が内部の状態を変更しても問題ありません。ただし、(1)常に同じ入力に対して同じ出力を生成することを保証し、(2)呼び出しとその変更を削除しても全体的な正しさに影響しない場合です。

19

yk_idempotentはnoinlineを意味しますが、LLVMは明白な理由なくそのような要求を無視する傾向があります。__asm__トリックは、LLVMがnoinlineを無視する可能性を低くします(私の慎重な言葉遣いに注意してください!)。

☒

yk_idempotentはnoinlineを意味しますが、LLVMは明白な理由なくそのような要求を無視する傾向があります。__asm__トリックは、LLVMがnoinlineを無視する可能性を低くします(私の慎重な言葉遣いに注意してください!)。

20

奇妙なことに、これは変数に適用され、(単に)その結果に適用されるわけではありません。長い話です。

☒

奇妙なことに、これは変数に適用され、(単に)その結果に適用されるわけではありません。長い話です。

21

HIRがほぼ同じ要因で削減されたのは偶然です。HIR命令はすべて同じコストを持つわけではなく、ガードボディなど、さらに状況を複雑にする重複の形態があります(本当に興味がある場合は)。

☒

HIRがほぼ同じ要因で削減されたのは偶然です。HIR命令はすべて同じコストを持つわけではなく、ガードボディなど、さらに状況を複雑にする重複の形態があります(本当に興味がある場合は)。

23

これは、最も頻繁に呼び出されると言っているのと同じことではありませんが、それのひどい代理ではありません。

☒

これは、最も頻繁に呼び出されると言っているのと同じことではありませんが、それのひどい代理ではありません。

24

未知のポインタPを呼び出し、その後関数FのブロックBがトレースされたとします。P==Fなのか、それともトレース不可能な関数Gを指し、それがFを呼び出したのかを判断できません。

☒

未知のポインタPを呼び出し、その後関数FのブロックBがトレースされたとします。P==Fなのか、それともトレース不可能な関数Gを指し、それがFを呼び出したのかを判断できません。

25

yk_indirect_inlineは、ループを含む関数をトレース可能と見なさないというヒューリスティックを尊重するため、両方(yk_indirect_inlineとyk_unroll)を一緒に使用したい場合があります。

☒

yk_indirect_inlineは、ループを含む関数をトレース可能と見なさないというヒューリスティックを尊重するため、両方(yk_indirect_inlineとyk_unroll)を一緒に使用したい場合があります。

26

トレースから「間接的に直接」呼び出された関数を特定することは以前は困難でしたが、LLMは今では喜んで数分で正確な答えを返してくれます。

☒

トレースから「間接的に直接」呼び出された関数を特定することは以前は困難でしたが、LLMは今では喜んで数分で正確な答えを返してくれます。

27

この問題は以前には見たことがありません。ykllvmはこのハッキーな修正を回避するように拡張できる可能性がありますが、それは別の日の問題です。

☒

この問題は以前には見たことがありません。ykllvmはこのハッキーな修正を回避するように拡張できる可能性がありますが、それは別の日の問題です。

コメント