HN 日本語サマリー

← 一覧へ戻る
AI・機械学習

vLLMの内部:高スループットLLM推論システムの解剖 (2025)

Inside vLLM: Anatomy of a High-Throughput LLM Inference System (2025) (aleksagordic.com)

121 pointsby sebg7 コメント

要約

この記事は、高スループットなLLM推論システムを支えるvLLMのコアコンポーネントと高度な機能を解説します。特に、vLLMのアーキテクチャを詳細に分解し、スケジューリング、ページドアテンション、連続バッチ処理などの基本から、チャンク化プリフィル、プレフィックスキャッシング、スケーリングアップ、サービングレイヤー、ベンチマークといった高度な機能までを段階的に説明します。これは、LLMエンジンの仕組みに興味がある読者や、vLLMへの貢献を考えている開発者を対象としています。

全文翻訳

Inside vLLM: Anatomy of a High-Throughput LLM Inference System

この記事では、最新の高スループットLLM推論システムを構成するすべてのコアシステムコンポーネントと高度な機能を段階的に紹介します。特に、vLLM \ [1] がどのように機能するかを分解していきます。

この記事はシリーズの最初のものです。詳細に飛び込む前に、まず全体像を把握し、その後で詳細を積み重ねていく(逆ピラミッドアプローチに従う)ことで、細部に溺れることなく、システム全体の正確な高レベルなメンタルモデルを形成できるようにします。

後の記事では、特定のサブシステムについて深く掘り下げます。

この記事は5つのパートで構成されています:

  1. LLMエンジンとエンジンコア:vLLMの基本(スケジューリング、ページドアテンション、連続バッチ処理など)
  2. 高度な機能:チャンク化プリフィル、プレフィックスキャッシング、ガイド付き・推論的デコーディング、分離されたP/D
  3. スケーリングアップ:シングルGPUからマルチGPU実行へ
  4. サービングレイヤー:分散/並行Webスキャフォールディング
  5. ベンチマークと自動チューニング:レイテンシとスループットの測定

📝注記

  • 分析はコミット 42172ad(2025年8月9日)に基づいています。
  • 対象読者:最先端のLLMエンジンの仕組みに興味がある人、およびvLLM、SGLangなどに貢献したい人。
  • V1エンジンに焦点を当てます。V0(現在は非推奨)も調査しましたが、プロジェクトの進化を理解する上で価値があり、多くの概念は現在も引き継がれています。
  • LLMエンジン/エンジンコアに関する最初のセクションは、少し圧倒的で退屈かもしれませんが、ブログの残りの部分には多くの例とビジュアルがあります。:)

LLMエンジンとエンジンコア

LLMエンジンはvLLMの基本的な構成要素です。これだけでも高スループットな推論が可能ですが、オフライン設定に限られます。まだWeb経由で顧客に提供することはできません。

実行例として、以下のオフライン推論スニペットを使用します(basic.pyから適応)。

from vllm import LLM, SamplingParams

prompts = [
    "Hello, my name is",
    "The president of the United States is",
]

sampling_params = SamplingParams(temperature=0.8, top_p=0.95)

def main():
    llm = LLM(model="TinyLlama/TinyLlama-1.1B-Chat-v1.0")

    outputs = llm.generate(prompts, sampling_params)

if __name__ == "__main__":
    main()

📝環境変数:

  • VLLM_USE_V1="1" # エンジンV1を使用
  • VLLM_ENABLE_V1_MULTIPROCESSING="0" # シングルプロセスで実行

この構成は以下の通りです:

  • オフライン(Web/分散システムのスキャフォールディングなし)
  • 同期(すべての実行は単一のブロッキングプロセスで発生)
  • シングルGPU(データ/モデル/パイプライン/エキスパート並列なし;DP/TP/PP/EP = 1)
  • 標準トランスフォーマーを使用 \ [2] (Jambaのようなハイブリッドモデルをサポートするには、より複雑なハイブリッドKVキャッシュメモリallocatorが必要です)

ここから、オンライン、非同期、マルチGPU、マルチノードの推論システムへと徐々に構築していきますが、それでも標準トランスフォーマーをサーブします。

この例では2つのことを行います:

  1. エンジンのインスタンス化
  2. それに対してgenerateを呼び出してプロンプトからサンプリングする

コンストラクタの分析から始めましょう。

LLMエンジンのコンストラクタ

エンジンの主なコンポーネントは以下の通りです:

  • vLLM config(モデル、キャッシュ、並列処理などを設定するためのすべてのノブを含みます)
  • processor(生の入力 → EngineCoreRequests を検証、トークン化、処理を通じて変換します)
  • engine core client(実行中の例ではInprocClientを使用しています。これは基本的にEngineCoreと等価です。スケールでのサービングを可能にするDPLBAsyncMPClientへと徐々に構築していきます)
  • output processor(生のEngineCoreOutputs → ユーザーが見るRequestOutputに変換します)

📝注記:

V0エンジンが非推奨になったため、クラス名や詳細は変更される可能性があります。正確なシグネチャよりもコアのアイデアを強調します。それらの詳細の一部は抽象化しますが、すべてではありません。

エンジンコア自体は、いくつかのサブコンポーネントで構成されています:

  • Model Executor(モデルのフォワードパスを駆動します。現在、単一GPU上の単一Workerプロセスを持つUniProcExecutorを扱っています。複数のGPUをサポートするMultiProcExecutorへと徐々に構築していきます)
  • Structured Output Manager(ガイド付きデコーディングに使用されます - 後でカバーします)
  • Scheduler(次のエンジンステップにどのリクエストを入れるかを決定します) - さらに以下を含みます:
    1. ポリシー設定 - FCFS(先着順)または優先度(優先度の高いリクエストが先に処理される)のいずれかになります。
    2. waitingおよびrunningキュー
    3. KVキャッシュマネージャー - Paged Attentionの心臓部 \ [3]

KVキャッシュマネージャーはfree_block_queueを維持します - 利用可能なKVキャッシュブロックのプール(VRAMサイズとブロックサイズに応じて、しばしば数十万のオーダー)。Paged Attention中、ブロックはトークンを計算されたKVキャッシュブロックにマッピングするインデックス構造として機能します。

[画像: LLM engine constructor]

このセクションで説明されたコアコンポーネントとその関係

標準トランスフォーマーレイヤー(非MLA \ [4] )のブロックサイズは次のように計算されます:
2 (key/value) * block_size (デフォルト=16) * num_kv_heads * head_size * dtype_num_bytes (例: bf16の場合は2)

モデルエグゼキュータの構築中、Workerオブジェクトが作成され、3つの主要な手順が実行されます。(後でMultiProcExecutorを使用する場合、これらの同じ手順は異なるGPU上の各ワーカープロセスで独立して実行されます。)

  1. デバイスの初期化:
    • CUDAデバイス(例: "cuda:0")をワーカーに割り当て、モデルのdtypeがサポートされているか(例: bf16)を確認します。
    • 要求されたgpu_memory_utilization(例: 0.8 → 総VRAMの80%)に基づいて、十分なVRAMが利用可能か検証します。
    • 分散設定(DP / TP / PP / EPなど)を設定します。
    • model_runner(サンプラー、KVキャッシュ、およびinput_ids、positionsなどのフォワードパスバッファを保持します)をインスタンス化します。
    • InputBatchオブジェクト(CPU側のフォワードパスバッファ、KVキャッシュインデックス用のブロックテーブル、サンプリングメタデータなどを保持します)をインスタンス化します。
  2. モデルのロード:
    • モデルアーキテクチャをインスタンス化します。
    • モデルの重みをロードします。
    • model.eval()(PyTorchの推論モード)を呼び出します。
    • オプション:モデルに対してtorch.compile()を呼び出します。
  3. KVキャッシュの初期化:
    • レイヤーごとのKVキャッシュ仕様を取得します。歴史的にはこれは常にFullAttentionSpec(均質なトランスフォーマー)でしたが、ハイブリッドモデル(スライディングウィンドウ、JambaのようなTransformer/SSM)ではより複雑になりました(Jenga \ [5] を参照)。
    • ダミー/プロファイリングフォワードパスを実行し、GPUメモリのスナップショットを取得して、利用可能なVRAMにいくつのKVキャッシュブロックが収まるかを計算します。
    • KVキャッシュテンソルをアテンションレイヤーに割り当て、リシェイプし、バインドします。
    • アテンションメタデータを準備します(例: バックエンドをFlashAttentionに設定)。これは後でフォワードパス中にカーネルによって消費されます。
    • --enforce-eagerが提供されない限り、ウォームアップバッチサイズの各々に対してダミー実行を行い、CUDAグラフをキャプチャします。CUDAグラフはGPUワークのシーケンス全体をDAGに記録します。後でフォワードパス中に、プリベイクされたグラフを起動/リプレイし、カーネル起動オーバーヘッドを削減してレイテンシを改善します。

ここでは多くの低レベルな詳細を抽象化しましたが、これらは次のセクションで繰り返し参照するため、 now 紹介するコア部分です。

エンジンが初期化されたので、generate関数に進みましょう。

generate関数

最初のステップは、リクエストを検証してエンジンにフィードすることです。各プロンプトについて、以下を行います:

  1. 一意のリクエストIDを作成し、その到着時刻をキャプチャします。
  2. 入力プリプロセッサを呼び出し、プロンプトをトークン化し、prompt、prompt_token_ids、およびtype(text、tokens、embedsなど)を含む辞書を返します。
  3. この情報をEngineCoreRequestにパックし、優先度、サンプリングパラメータ、その他のメタデータを追加します。
  4. リクエストをエンジンコアに渡します。エンジンコアはそれをRequestオブジェクトでラップし、ステータスをWAITINGに設定します。このリクエストはスケジューラのwaitingキューに追加されます(FCFSの場合は追加、優先度の場合はヒーププッシュ)。

この時点でエンジンにリクエストがフィードされ、実行を開始できます。同期エンジン例では、これらの初期プロンプトのみが処理されます。実行中に新しいリクエストを注入するメカニズムはありません。対照的に、非同期エンジンはこれをサポートします(いわゆる連続バッチ処理 \ [6] ):各ステップの後、新しいリクエストと古いリクエストの両方が考慮されます。

フォワードパスはバッチを単一のシーケンスにフラット化し、カスタムカーネルが効率的に処理するため、同期エンジンでも連続バッチ処理が基本的にサポートされています。

次に、処理すべきリクエストがある限り、エンジンは繰り返しstep()関数を呼び出します。各ステップには3つのステージがあります:

  1. スケジュール:このステップで実行するリクエストを選択します(デコード、および/または(チャンク化)プリフィル)。
  2. フォワードパス:モデルを実行し、トークンをサンプリングします。
  3. ポストプロセス:サンプリングされたトークンIDを各Requestに追加し、デトークン化し、停止条件を確認します。リクエストが完了した場合、クリーンアップ(例: KVキャッシュブロックをfree_block_queueに戻す)して、出力を早期に返します。

📝停止条件は以下の通りです:

  • リクエストが長さ制限(max_model_lengthまたは独自のmax_tokens)を超える。
  • サンプリングされたトークンがEOS IDである(ignore_eosが有効な場合を除く - 特定の数のアウトトークンを生成するように強制したいベンチマークに便利)。
  • サンプリングされたトークンがサンプリングパラメータで指定されたstop_token_idsのいずれかに一致する。
  • ストップ文字列が出力に存在する場合 - 出力を最初のストップ文字列の出現まで切り捨て、エンジンでリクエストを中止します(stop_token_idsは出力に存在しますが、ストップ文字列は存在しません)。

[画像: Engine loop]

エンジンループ

ストリーミングモードでは、生成された中間トークンを送信しますが、今回は無視します。

次に、スケジューリングをより詳細に調べます。

スケジューラ

推論エンジンが処理する主なワークロードタイプは2つあります:

  1. プリフィルリクエスト - すべてのプロンプトトークンに対するフォワードパス。これらは通常計算バウンドです(しきい値はハードウェアとプロンプト長に依存します)。最後に、最終トークンの位置の確率分布から単一トークンをサンプリングします。
  2. デコードリクエスト - 最後のトークンのみに対するフォワードパス。以前のすべてのKVベクトルはすでにキャッシュされています。これらはメモリ帯域幅バウンドです。なぜなら、1つのトークンを計算するためだけに、すべてのLLM重み(およびKVキャッシュ)をロードする必要があるからです。

ベンチマークセクションで、GPUパフォーマンスのいわゆるルーフラインモデルを分析します。そこでは、プリフィル/デコードパフォーマンスプロファイルの後ろにある詳細について説明します。

V1スケジューラは、よりスマートな設計上の選択のおかげで、同じステップで両方のタイプの要求を混在させることができます。対照的に、V0エンジンは一度にプリフィルまたはデコードのいずれかのみを処理できました。

スケジューラはデコードリクエストを優先します。つまり、すでにrunningキューにあるリクエストです。各リクエストについて、以下を行います:

  1. 生成する新しいトークンの数を計算します(推論的デコーディングと非同期スケジューリングのため、常に1とは限りません - 後述)。
  2. KVキャッシュマネージャーのallocate_slots関数を呼び出します(詳細は後述)。
  3. ステップ1のトークン数を差し引いて、トークンバジェットを更新します。

その後、waitingキューからのプリフィルリクエストを処理します。以下を行います:

  1. 計算されたブロック数を取得します(プレフィックスキャッシングが無効な場合は0を返します - 後でカバーします)。
  2. KVキャッシュマネージャーのallocate_slots関数を呼び出します。
  3. リクエストをwaitingからポップし、runningに移動させ、ステータスをRUNNINGに設定します。
  4. トークンバジェットを更新します。

次に、allocate_slotsが何をするか見てみましょう。以下を行います:

  1. ブロック数の計算 - 割り当てる必要がある新しいKVキャッシュブロック数(n)を決定します。各ブロックはデフォルトで16トークンを格納します。例えば、プリフィルリクエストに17個の新しいトークンがある場合、ceil(17/16) = 2ブロックが必要です。
  2. 利用可能性の確認 - マネージャーのプールに十分なブロックがない場合、早期に終了します。デコードリクエストかプリフィルリクエストかによって、エンジンは再計算プリエンプション(V0ではスワッププリエンプションがサポートされていました)を試みるか、スケジューリングをスキップして実行を続行する可能性があります。低優先度のリクエストをエビクトして(kv_cache_manager.freeを呼び出し、KVブロックをブロックプールに戻します)、または実行を続行します。
  3. ブロックの割り当て - KVキャッシュマネージャーのコーディネーターを介して、ブロックプール(前述のfree_block_queue双方向連結リスト)から最初のn個のブロックを取得します。req_to_blocksに格納します。これは、各request_idをKVキャッシュブロックのリストにマッピングする辞書です。

[画像: KV cache blocks]

KVキャッシュブロックのリスト

これでフォワードパスを実行する準備ができました!

フォワードパスの実行

モデルエグゼキュータのexecute_modelを呼び出します。これはWorkerに委譲し、Workerはモデルランナーに委譲します。

主なステップは以下の通りです:

  1. 状態の更新 - input_batchから完了したリクエストを削除します。ページドKVキャッシュメモリにインデックス付けするために使用されるリクエストごとのKVキャッシュブロックなどの、その他のフォワードパス関連メタデータを更新します。
  2. 入力の準備 - CPUからGPUへのバッファのコピー。位置の計算。slot_mappingの構築(例でさらに説明)。アテンションメタデータの構築。
  3. フォワードパス - カスタムページドアテンションカーネルを使用してモデルを実行します。すべてのシーケンスはフラット化され、単一の長い「スーパーシーケンス」に連結されます。位置インデックスとアテンションマスクにより、各シーケンスは自身のトークンのみにアテンションを向けられるため、右パディングなしで連続バッチ処理が可能になります。
  4. 最後のトークン状態の収集 - 各シーケンスの最後の位置の隠れ状態を抽出し、ロジットを計算します。
  5. サンプリング - サンプリング設定(greedy、temperature、top-p、top-kなど)に従って、計算されたロジットからトークンをサンプリングします。

フォワードパスステップ自体には、2つの実行モードがあります:

  1. Eagerモード - イーガー実行が有効な場合に標準のPyTorchフォワードパスを実行します。
  2. 「キャプチャ済み」モード - イーガーが強制されない場合に、事前にキャプチャされたCUDAグラフを実行/リプレイします(エンジン構築中の初期化KVキャッシュ手順でキャプチャしたことを思い出してください)。

連続バッチ処理とページドアテンションを明確にするための具体的な例を以下に示します:

[画像: fwd pass - continuous batching & paged attn]

フォワードパス:連続バッチ処理とページドアテンション

高度な機能 - コアエンジンロジックの拡張

基本的なエンジンフローが整ったので、高度な機能を見ていきましょう。

プリエンプション、ページドアテンション、連続バッチ処理についてはすでに説明しました。

次に、以下について詳しく見ていきます:

  1. チャンク化プリフィル
  2. プレフィックスキャッシング
  3. ガイド付きデコーディング(文法ベースの有限状態機械を通じて)
  4. 推論的デコーディング
  5. 分離されたP/D(プリフィル/デコード)

チャンク化プリフィル

チャンク化プリフィルは、プリフィルステップを小さなチャンクに分割して長いプロンプトを処理する技術です。これがないと、単一の非常に長いリクエストが1つのエンジンステップを独占し、他のプリフィルリクエストを実行できなくなる可能性があります。これにより、他のすべてのリクエストが遅延し、レイテンシが増加します。

例えば、各チャンクにn(=8)トークンを含め、小文字のアルファベットでハイフン区切りでラベル付けするとします。長いプロンプトPはx-y-zのようになり、zは不完全なチャンク(例: 2トークン)です。Pの完全なプリフィルを実行するには、≥ 3つのエンジンステップが必要になり(1つのステップで実行されない場合はさらに多くなる可能性があります)、最後のチャンク化プリフィルステップで初めて1つの新しいトークンがサンプリングされます。

同じ例を視覚的に示します:

[画像: Chunked prefilling - pt 1]

実装は簡単です:ステップあたりの新しいトーク数を制限します。要求された数がlong_prefill_token_thresholdを超える場合、それをその値に正確にリセットします。基盤となるインデックスロジック(前述)が残りを処理します。

vLLM V1では、long_prefill_token_thresholdを正の整数に設定することでチャンク化プリフィルを有効にします。(技術的には、プロンプト長がトークンバジェットを超える場合、それを切り捨ててチャンク化プリフィルを実行すれば、これに関係なく発生する可能性があります。)

プレフィックスキャッシング

プレフィックスキャッシングの仕組みを説明するために、元のコード例を少し変更してみましょう:

from vllm import LLM, SamplingParams

long_prefix = "<a piece of text that is encoded into more than block_size tokens>"

prompts = [
    "Hello, my name is",
    "The president of the United States is",
]

sampling_params = SamplingParams(temperature=0.8, top_p=0.95)

def main():
    llm = LLM(model="TinyLlama/TinyLlama-1.1B-Chat-v1.0")

    outputs = llm.generate(long_prefix + prompts[0], sampling_params)
    outputs = llm.generate(long_prefix + prompts[1], sampling_params)

if __name__ == "__main__":
    main()

プレフィックスキャッシングは、複数のプロンプトが先頭で共有するトークンを再計算することを回避します。したがって、プレフィックスです。

重要な部分はlong_prefixです:これはKVキャッシュブロック(デフォルトで16トークン)よりも長いプレフィックスとして定義されます。例を単純化するために、long_prefixが正確にn x block_sizeの長さであると仮定します(n ≥ 1)。

つまり、ブロック境界に完全に一致します。そうでない場合、不完全なブロックはキャッシュできないため、long_prefix_len % block_sizeトークンを再計算する必要があります。

プレフィックスキャッシングなしでは、同じlong_prefixを持つ新しいリクエストを処理するたびに、n x block_sizeトークンすべてを再計算することになります。

プレフィックスキャッシングありでは、これらのトークンは一度計算され(それらのKVはKVキャッシュページメモリに格納され)、再利用されるため、新しいプロンプトトークンのみを処理する必要があります。これにより、プリフィルリクエストが高速化されます(ただし、デコードには役立ちません)。

vLLMではこれがどのように機能するか?

最初のgenerate呼び出し中、スケジューリングステージで、kv_cache_manager.get_computed_blocks内で、エンジンはhash_request_tokensを呼び出します:

  1. この関数は、long_prefix + prompts[0]を16トークンごとのチャンクに分割します。
  2. 完全なチャンクごとに、ハッシュ(組み込みハッシュまたはSHA-256を使用。後者は遅いが衝突は少ない)を計算します。ハッシュは、前のブロックのハッシュ、現在のトークン、およびオプションのメタデータを組み合わせます。

オプションのメタデータには、MMハッシュ、LoRA ID、キャッシュソルト(最初のブロックのハッシュに注入され、このキャッシュソルトを持つリクエストのみがブロックを再利用できることを保証します)が含まれます。

  1. 各結果は、ハッシュとそのトークンIDの両方を含むBlockHashオブジェクトとして格納されます。ブロックハッシュのリストを返します。

リストはself.req_to_block_hashes[request_id]に格納されます。

次に、エンジンはfind_longest_cache_hitを呼び出して、これらのハッシュのいずれかがcached_block_hash_to_blockに既に存在するかどうかを確認します。最初のリクエストでは、ヒットは見つかりません。

[画像: Prefix caching logic - pt 1]

次にallocate_slotsを呼び出し、これがcoordinator.cache_blocksを呼び出します。これは、新しいBlockHashエントリを割り当てられたKVブロックに関連付け、cached_block_hash_to_blockに記録します。

その後、フォワードパスは、上記で割り当てたKVキャッシュブロックに対応するKVをページドKVキャッシュメモリに格納します。

多くのエンジンステップの後、さらにKVキャッシュブロックが割り当てられますが、プレフィックスはlong_prefixの直後に分岐したため、例には影響しません。

[画像: Prefix caching logic - pt 2]

同じプレフィックスを持つ2回目のgenerate呼び出しでは、ステップ1〜3が繰り返されますが、今度はfind_longest_cache_hitが(線形検索を通じて)すべてのnブロックの一致を見つけます。エンジンはこれらのKVブロックを直接再利用できます。

[画像: Prefix caching logic - pt 3]

元のリクエストがまだアクティブだった場合、これらのブロックの参照カウントが増加します(例: 2に)。この例では、最初のリクエストは既に完了しているため、ブロックはプールに戻され、参照カウントは0に戻されています。cached_block_hash_to_blockから取得できたため、それらが有効であることがわかります(KVキャッシュマネージャーのロジックはそのように設定されています)。そのため、free_block_queueから再度削除するだけです。

📝高度な注記:

KVキャッシュブロックは、free_block_queueから再割り当てされようとしているとき(左からポップされる)にのみ無効になり、ブロックがまだ関連するハッシュを持っており、cached_block_hash_to_blockに存在することを発見した場合です。その時点で、ブロックのハッシュをクリアし、cached_block_hash_to_blockからそのエントリを削除し、プレフィックスキャッシングを通じて(少なくとも古いプレフィックスに対しては)再利用できないようにします。

これがプレフィックスキャッシングの要点です:以前見たプレフィックスは再計算せず、KVキャッシュを再利用するだけです!

この例を理解できれば、ページドアテンションの仕組みも理解できたことになります。

プレフィックスキャッシングはデフォルトで有効です。無効にするには:enable_prefix_caching = False。

ガイド付きデコーディング(FSM)

ガイド付きデコーディングは、各デコーディングステップで、ロジットが文法ベースの有限状態機械によって制約される技術です。これにより、文法で許可されたトークンのみをサンプリングできます。

これは強力なセットアップです:正規文法(チョムスキータイプ3、例: 任意の正規表現パターン)から文脈自由文法(タイプ2、ほとんどのプログラミング言語をカバー)まで、あらゆるものを強制できます。

これをより抽象的でないものにするために、最も簡単な例から始め、以前のコードを拡張します:

from vllm import LLM, SamplingParams
from vllm.sampling_params import GuidedDecodingParams

prompts = [
    "This sucks",
    "The weather is beautiful",
]

guided_decoding_params = GuidedDecodingParams(choice=["Positive", "Negative"])
sampling_params = SamplingParams(guided_decoding=guided_decoding_params)

def main():
    llm = LLM(model="TinyLlama/TinyLlama-1.1B-Chat-v1.0")

    outputs = llm.generate(prompts, sampling_params)

if __name__ == "__main__":
    main()

私が提供したトイ例(文字レベルのトークン化を想定)では、プリフィル時にFSMはロジットをマスクし、PまたはNのみが有効になります。Pがサンプリングされると、FSMは「Positive」ブランチに移動します。次のステップではoのみが許可され、以下同様です。

[画像: FSM]

トイ例FSM

vLLMではこれがどのように機能するか:

  1. LLMエンジンの構築時に、StructuredOutputManagerが作成されます。これはトークナイザーにアクセスでき、_grammar_bitmaskテンソルを維持します。
  2. リクエストを追加する際、そのステータスはWAITING_FOR_FSMに設定され、grammar_initがバックエンドコンパイラ(例: xgrammar \ [7] ; バックエンドはサードパーティのコードであることに注意)を選択します。
  3. 文法はこのリクエストのために非同期でコンパイルされます。
  4. スケジューリング中、非同期コンパイルが完了した場合、ステータスはWAITINGに切り替わり、request_idがstructured_output_request_idsに追加されます。完了していない場合は、次のエンジンステップで再試行するためにskipped_waiting_requestsに配置されます。
  5. スケジューリングループの後(まだスケジューリング内)、FSMリクエストがある場合、StructuredOutputManagerはバックエンドに_grammar_bitmaskの準備/更新を要求します。
  6. フォワードパスがロジットを生成した後、xgr_torch_compileの関数はビットマスクを語彙サイズに拡張し(32ビット整数を使用するため32倍の拡張率)、無効なロジットを-∞にマスクします。
  7. 次のトークンをサンプリングした後、リクエストのFSMはaccept_tokensを介して進められます。視覚的にはFSMダイアグラムの次の状態に移動します。

ステップ6はさらに明確化する価値があります。

vocab_size = 32の場合、_grammar_bitmaskは単一の整数です。そのバイナリ表現は、許可されるトークン("1")と無効なトークン("0")をエンコードします。例えば、「101…001」は長さ32の配列[1, 0, 1, …, 0, 0, 1]に展開されます。0の位置のロジットは-∞に設定されます。より大きな語彙の場合、複数の32ビットワードが使用され、展開/連結されます。バックエンド(例: xgrammar)は、現在のFSM状態を使用してこれらのビットパターンを生成する責任があります。

📝注記:

ほとんどの複雑さは、xgrammarのようなサードパーティライブラリに隠されています。

語彙サイズ=8、8ビット整数を使用した、さらに簡単な例を以下に示します(私のビジュアルを好む方のために):

[画像: FSM]

トイ例

guided_decoding設定を渡すことで、vLLMでこれを有効にできます。

推論的デコーディング

自己回帰生成では、各新しいトークンは大きなLMのフォワードパスを必要とします。これは高価です - 各ステップで、単一トークンを計算するためだけにすべてのモデル重みを再ロードして適用します!(バッチサイズ==1を仮定、一般的にはB)

推論的デコーディング \ [8] は、より小さなドラフトLMを導入することでこれを高速化します。ドラフトはkトークンを安価に提案します。しかし、最終的には小さいモデルからサンプリングしたいわけではありません - それは候補の継続を推測するためだけです。大きなモデルが依然として有効性を決定します。

手順は以下の通りです:

  1. ドラフト:現在のコンテキストで小さいモデルを実行し、kトークンを提案します。
  2. 検証:コンテキスト+kドラフトトークンで大きなモデルを1回実行します。これにより、それらのk位置とさらに1つの位置の確率が生成されます(これによりk+1候補が得られます)。
  3. 承認/拒否:k個のドラフトトークンを左から右へ移動させます:
    • 大きなモデルのドラフトトークンに対する確率がドラフトの確率以上の場合、それを承認します。

    • それ以外の場合、確率p_large(token)/p_draft(token)で承認します。

    • 最初の拒否で停止するか、k個のドラフトトークンすべてを承認します。

    • k個のドラフトトークンすべてが承認された場合、大きなモデルから追加の(k+1)番目のトークンを「無料で」サンプリングします(その分布は既に計算済みです)。

    • 拒否があった場合、その位置で新しい再調整された分布(p_large - p_draft、最小値を0にクランプ、合計が1になるように正規化)を作成し、そこから最後のトークンをサンプリングします。

これが機能する理由:小さいモデルを候補提案に使用しますが、承認/拒否ルールは、期待値としてシーケンスが大きなモデルからトークンごとにサンプリングした場合と同じように分布することを保証します。これは、推論的デコーディングが標準的な自己回帰デコーディングと統計的に同等であることを意味します - しかし、単一の大きなモデルパスで最大k+1トークンが得られる可能性があるため、潜在的に非常に高速です。

📝注記:

簡単な実装についてはgpt-fastを、数学的な詳細と完全なモデルからのサンプリングとの等価性の証明については元の論文を参照することをお勧めします。

vLLM V1はLLMドラフトモデル方式をサポートしていませんが、代わりに高速ですが精度が低い提案スキームを実装しています:n-gram、EAGLE \ [9] 、およびMedusa \ [10] 。

各々の一行説明:

  1. n-gram:最後のprompt_lookup_maxトークンを取得します。シーケンス内で以前の一致を見つけます。見つかった場合、その一致に続いたkトークンを提案します。見つからなかった場合は、ウィンドウをデクリメントしてprompt_lookup_minまで再試行します。

現在の実装は、最初の一致の後にkトークンを返します。最近のバイアスを導入し、検索方向を反転させる方が自然に感じませんか?(つまり、最後の一致)
3. Eagle:大きなLMで「モデル手術」を実行します - 埋め込みとLMヘッドを保持し、トランスフォーマーのスタックを軽量MLPに置き換えます。それを安価なドラフトとしてファインチューニングします。
4. Medusa:大きなモデルの上に補助的な線形ヘッド(LMヘッド前の埋め込み)をトレーニングして、次のkトークンを並列に予測します。これらのヘッドを使用して、別の小さいLMを実行するよりも効率的にトークンを提案します。

ngramをドラフトメソッドとして使用してvLLMで推論的デコーディングを呼び出す方法を以下に示します:

from vllm import LLM, SamplingParams

prompts = [
    "Hello, my name is",
    "The president of the United States is",
]

sampling_params = SamplingParams(temperature=0.8, top_p=0.95)

speculative_config={
    "method": "ngram",
    "prompt_lookup_max": 5,
    "prompt_lookup_min": 3,
    "num_speculative_tokens": 3,
}

def main():
    llm = LLM(model="TinyLlama/TinyLlama-1.1B-Chat-v1.0", speculative_config=speculative_config)

    outputs = llm.generate(prompts, sampling_params)

if __name__ == "__main__":
    main()

vLLMではこれがどのように機能するか?

セットアップ(エンジン構築中):

  1. デバイスの初期化:drafter(ドラフトモデル、例: NgramProposer)とrejection_sampler(その一部はTritonで記述されています)を作成します。
  2. モデルのロード:ドラフトモデルの重みをロードします(n-gramの場合は不要)。

その後、generate関数で(新しいリクエストが届いたと仮定):

  1. 大きなモデルで通常のプリフィルステップを実行します。
  2. フォワードパスと標準サンプリングの後、propose_draft_token_ids(k)を呼び出してドラフトモデルからk個のドラフトトークンをサンプリングします。
  3. これらをrequest.spec_token_idsに格納します(リクエストメタデータを更新します)。
  4. 次のエンジンステップで、リクエストが実行キューにある場合、「新しいトークン」カウントにlen(request.spec_token_ids)を追加して、allocate_slotsがフォワードパスに必要なKVブロックを予約するようにします。
  5. spec_token_idsをinput_batch.token_ids_cpuにコピーして、(コンテキスト+ドラフト)トークンを形成します。
  6. _calc_spec_decode_metadataを介してメタデータを計算します(これはinput_batch.token_ids_cpuからトークンをコピーし、ロジットなどを準備します)。その後、ドラフトトークン全体で大きなモデルのフォワードパスを実行します。
  7. ロジットからの通常のサンプリングの代わりに、rejection_samplerを使用して左から右へ承認/拒否し、output_token_idsを生成します。
  8. 停止条件が満たされるまで、ステップ2〜7を繰り返します。

これを最もよく理解するには、デバッガを起動してコードベースをステップ実行することですが、このセクションでその雰囲気を掴んでいただければ幸いです。これも同様です:

[画像: Drafting stage]

[画像: Verify stage & rejection sampling stage]

分離されたP/D

分離されたP/D(プリフィル/デコード)の動機については、以前に触れました。

プリフィルとデコードは非常に異なるパフォーマンスプロファイル(計算バウンド対メモリ帯域幅バウンド)を持つため、それらの実行を分離することは合理的な設計です。レイテンシ(TTFT(Time-To-First-Token)とITL(Inter-Token Latency)の両方)をより厳密に制御できます - これについてはベンチマークセクションで詳しく説明します。

実際には、ライブリクエストのミックスに基づいて、N個のvLLMプリフィルインスタンスとM個のvLLMデコードインスタンスを実行し、それらを自動スケーリングします。プリフィルワーカーはKVを専用のKVキャッシュサービスに書き込み、デコードワーカーはそこから読み取ります。これにより、長くバースト的なプリフィルと、安定したレイテンシに敏感なデコードが分離されます。

vLLMではこれがどのように機能するか?

明確にするために、以下の例はSharedStorageConnectorに依存しています。これは、メカニズムを説明するために使用されるデバッグコネクタ実装です。

コネクタは、インスタンス間のKVの交換を処理するためのvLLMの抽象化です。コネクタインターフェースはまだ安定していませんが、変更を伴ういくつかの短期的な改善が計画されており、一部は破壊的である可能性があります。

2つのvLLMインスタンス(プリフィル用にGPU 0、デコード用にGPU 1)を起動し、それらの間でKVキャッシュを転送します:


import os
import time
from multiprocessing import Event, Process
import multiprocessing as mp

from vllm import LLM, SamplingParams
from vllm.config import KVTransferConfig

prompts = [
    "Hello, my name is",
    "The president of the United States is",
]

def run_prefill(prefill_done):
  os.environ["CUDA_VISIBLE_DEVICES"] = "0"

  sampling_params = SamplingParams(temperature=0, top_p=0.95, max_tokens=1)

  ktc=KVTransferConfig(
      kv_connector="SharedStorageConnector",
      kv_role="kv_both",
      kv_connector_extra_config={"shared_storage_path": "local_storage"},
  )

  llm = LLM(model="TinyLlama/TinyLlama-1.1B-Chat-v1.0", kv_transfer_config=ktc)
  llm.generate(prompts, sampling_params)

  prefill_done.set()  # notify decode instance that KV cache is ready

  # To keep the prefill node running in case the decode node is not done;
  # otherwise, the script might exit prematurely, causing incomplete decoding.
  try:
      while True:
          time.sleep(1)
  except KeyboardInterrupt:
      print("Script stopped by user.")

def run_decode(prefill_done):
  os.environ["CUDA_VISIBLE_DEVICES"] = "1"

  sampling_params = SamplingParams(temperature=0, top_p=0.95)

  ktc=KVTransferConfig(
      kv_connector="SharedStorageConnector",
      kv_role="kv_both",
      kv_connector_extra_config={"shared_storage_path": "local_storage"},
  )

  llm = LLM(model="TinyLlama/TinyLlama-1.1B-Chat-v1.0", kv_transfer_config=ktc)

  prefill_done.wait()  # block waiting for KV cache from prefill instance

  # Internally it'll first fetch KV cache before starting the decoding loop
  outputs = llm.generate(prompts, sampling_params)

if __name__ == "__main__":
  prefill_done = Event()
  prefill_process = Process(target=run_prefill, args=(prefill_done,))
  decode_process = Process(target=run_decode, args=(prefill_done,))

  prefill_process.start()
  decode_process.start()

  decode_process.join()
  prefill_process.terminate()

📝注記:

LMCache \ [11] (NVIDIAのNIXLをバックエンドとして使用する最速のプロダクション対応コネクタ)も実験しましたが、まだ最先端であり、いくつかのバグに遭遇しました。その複雑さの多くは外部リポジトリにあるため、SharedStorageConnectorは説明に適しています。

vLLMでの手順は以下の通りです:

  1. インスタンス化 - エンジン構築中、コネクタは2つの場所で作成されます:
    • ワーカーのデバイス初期化手順内(init worker distributed environment関数下)、ロールは"worker"。
    • スケジューラコンストラクタ内、ロールは"scheduler"。
  2. キャッシュルックアップ - スケジューラがwaitingキューからプリフィルリクエストを処理する際(ローカルプレフィックスキャッシュチェックの後)、コネクタのget_num_new_matched_tokensを呼び出します。これは外部でキャッシュされたトークンをKVキャッシュサーバーで確認します。プリフィルは常にここで0を返します。デコードはキャッシュヒットする可能性があります。結果はallocate_slotsを呼び出す前にローカルカウントに追加されます。
  3. 状態更新 - スケジューラはconnector.update_state_after_allocを呼び出し、キャッシュがあったリクエストを記録します(プリフィルの場合はノープ)。
  4. メタデータ構築 - スケジューリングの終わりに、スケジューラはmeta = connector.build_connector_metaを呼び出します:
    • プリフィルは、KVをアップロードするためにis_store=Trueを持つすべてリクエストを追加します。
    • デコードは、KVを取得するためにis_store=Falseを持つリクエストを追加します。
  5. コンテキストマネージャー - フォワードパスの前に、エンジンはKVコネクタコンテキストマネージャーに入ります:
    • 入力時:kv_connector.start_load_kvが呼び出されます。デコードの場合、これは外部サーバーからKVをロードし、ページメモリに注入します。プリフィルの場合はノープです。
    • 出力時:kv_connector.wait_for_saveが呼び出されます。プリフィルの場合、これはKVが外部サーバーにアップロードされるまでブロックします。デコードの場合はノープです。

視覚的な例を以下に示します:

[画像: disaggregated P/D]

分離されたP/D

📝追加注記:

  • SharedStorageConnectorの場合、「外部サーバー」は単なるローカルファイルシステムです。
  • 設定によっては、KV転送はレイヤーごと(各アテンションレイヤーの前/後)に行うこともできます。
  • デコードは外部KVを一度だけロードします。リクエストの最初のステップの後、それ以降はローカルで計算/保存します。

UniProcExecutorからMultiProcExecutorへ

コア技術が整ったので、スケーリングについて話すことができます。

モデルの重みが単一GPUのVRAMに収まらなくなったと仮定します。

最初のオプションは、テンソル並列処理(例: TP=8)を使用して、同じノード上の複数のGPUにモデルをシャードすることです。それでもモデルが収まらない場合は、次のステップはノード間のパイプライン並列処理です。

📝注記:

  • ノード内帯域幅はノード間帯域幅よりも大幅に高いため、テンソル並列処理(TP)はパイプライン並列処理(PP)よりも一般的に好まれます。(PPはTPよりも通信データ量が少ないという事実もあります。)
  • Expert Parallelism (EP) は、MoEではなく標準トランスフォーマーに焦点を当てているため、またSequence Parallelismも、TPとPPが実際によく使用されるため、カバーしません。

この段階では、複数のGPUプロセス(ワーカー)とそれらを調整するオーケストレーションレイヤーが必要です。まさにMultiProcExecutorが提供するものです。

[画像: MultiProcExecutor]

TP=8設定でのMultiProcExecutor(ドライバーワーカーはランク0)

vLLMではこれがどのように機能するか:

  1. MultiProcExecutorはrpc_broadcast_mqメッセージキュー(内部的には共有メモリで実装)を初期化します。
  2. コンストラクタはworld_size(例: TP=8 ⇒ world_size=8)をループし、WorkerProc.make_worker_processを介して各ランクのデーモンプロセスをスポーンします。
  3. 各ワーカーについて、親はまずリーダーとライターのパイプを作成します。
  4. 新しいプロセスはWorkerProc.worker_mainを実行し、ワーカーをインスタンス化します(UniprocExecutorと同じ「デバイスの初期化」、「モデルのロード」などの手順を経ます)。
  5. 各ワーカーは、自分がドライバー(TPグループのランク0)か通常のワーカーかを判断します。すべてのワーカーは2つのキューを設定します:
    • 作業受信用のrpc_broadcast_mq(親と共有)。
    • 応答送信用のworker_response_mq。
  6. 初期化中、各子プロセスはパイプを介して親にworker_response_mqハンドルを送信します。すべて受信したら、親はブロック解除されます - これで調整が完了します。
  7. ワーカーはビジーループに入り、rpc_broadcast_mq.dequeueでブロックします。作業項目が到着すると、それを実行します(UniprocExecutorと同様ですが、TP/PP固有の分割作業があります)。結果はworker_response_mq.enqueueを介して送信されます。
  8. 実行時、リクエストが到着すると、MultiProcExecutorはそれをすべての子ワーカーのためにrpc_broadcast_mq(非ブロッキング)にエンキューします。その後、指定された出力ランクのworker_response_mq.dequeueでブロックして最終結果を収集します。

エンジンからは何も変わっていません - このマルチプロセッシングの複雑さはすべて、モデルエグゼキュータのexecute_modelへの呼び出しを通じて抽象化されています。

  • UniProcExecutorの場合:execute_modelは直接ワーカーのexecute_modelの呼び出しにつながります。
  • MultiProcExecutorの場合:execute_modelはrpc_broadcast_mqを介して間接的に各ワーカーのexecute_modelの呼び出しにつながります。

この時点で、同じエンジンインターフェースを使用して、リソースが許す限り大きなモデルを実行できます。

次のステップはスケールアウトです:データ並列処理(DP > 1)を有効にしてモデルをノード間でレプリケートし、軽量なDP調整レイヤーを導入し、レプリカ間のロードバランシングを導入し、その前に1つ以上のAPIサーバーを配置して着信トラフィックを処理します。

vLLMを提供する分散システム

サービングインフラストラクチャをセットアップする方法はたくさんありますが、具体的にするために、ここに1つの例を示します。2つのH100ノードがあり、それらに4つのvLLMエンジンを実行したいとします。

モデルがTP=4を必要とする場合、ノードを次のように構成できます。

[画像: server configuration with 2 8xH100 nodes]

サーバー構成(2つの8xH100ノード、1つのヘッドレス、1つのAPIサーバー)

最初のノードでは、以下の引数を使用して、ヘッドレスモード(APIサーバーなし)でエンジンを実行します:

vllm serve <model-name>
  --tensor-parallel-size 4
  --data-parallel-size 4
  --data-parallel-size-local 2
  --data-parallel-start-rank 0
  --data-parallel-address <master-ip>
  --data-parallel-rpc-port 13345
  --headless

そして、他のノードでも同じコマンドを少し変更して実行します:

  • --headlessなし
  • DP開始ランクを変更します。
vllm serve <model-name>
  --tensor-parallel-size 4
  --data-parallel-size 4
  --data-parallel-size-local 2
  --data-parallel-start-rank 2
  --data-parallel-address <master-ip>
  --data-parallel-rpc-port 13345

📝注記:

これは、すべてのノードが指定されたIPとポートに到達できるとネットワークが構成されていることを前提としています。

VLLMではこれがどのように機能するか?

ヘッドレスサーバーノード上

ヘッドレスノードでは、CoreEngineProcManagerが2つのプロセス(--data-parallel-size-localあたり)を起動し、それぞれがEngineCoreProc.run_engine_coreを実行します。これらの各関数はDPEngineCoreProc(エンジンコア)をインスタンス化し、その後ビジーループに入ります。

DPEngineCoreProcは親のEngineCoreProc(EngineCoreの子)を初期化します。これは以下を行います:

  1. input_queueとoutput_queue(queue.Queue)を作成します。
  2. DEALER ZMQソケット(非同期メッセージングライブラリ)を使用してフロントエンドとの初期ハンドシェイクを実行し、調整アドレス情報を受信します。
  3. DPグループ(例: NCCLバックエンドを使用)を初期化します。
  4. EngineCoreをMultiProcExecutor(前述のように4つのGPUでTP=4)で初期化します。
  5. ready_event(threading.Event)を作成します。
  6. 入力デーモンスレッド(threading.Thread)を起動し、process_input_sockets(…, ready_event)を実行します。同様に出力スレッドも起動します。
  7. メインスレッドでは、ready_eventでブロックし、すべての4つのプロセス(2つのノードにまたがる)からのすべての入力スレッドが調整ハンドシェイクを完了し、最終的にready_event.set()を実行するまで待ちます。
  8. ブロック解除されると、メタデータ(例: ページドKVキャッシュメモリで利用可能なnum_gpu_blocks)とともに「ready」メッセージをフロントエンドに送信します。
  9. メイン、入力、出力スレッドは、それぞれのビジーループに入ります。

TL;DR:4つの子プロセス(DPレプリカあたり1つ)が得られ、それぞれがメイン、入力、出力スレッドを実行します。それらはDPコーディネーターとフロントエンドとの調整ハンドシェイクを完了し、その後プロセスごとの3つのスレッドすべてが定常ビジーループで実行されます。

[画像: distributed system with 4 DPEngineCoreProc]

4つのDPレプリカを実行する4つのDPEngineCoreProc

現在の定常状態:

  • 入力スレッド - 入力ソケットでブロックし、APIサーバーからリクエストがルーティングされるまで待ちます。受信すると、ペイロードをデコードし、メインスレッドのためにinput_queue.put_nowait(...)に作業項目をエンキューします。

  • メインスレッド - input_queue.get(...)でウェイクアップし、リクエストをエンジンにフィードします。MultiProcExecutorはフォワードパスを実行し、停止条件が満たされるまで結果をoutput_queueにエンキューします。

    リマインダー:step()はスケジューラ、モデルエグゼキュータ(これはさらにMultiProcExecutorになる可能性があります!)などを呼び出します。これらはすでに確認済みです!

    • 出力スレッド - output_queue.get(...)でウェイクアップし、結果をAPIサーバーに送り返し、その後ブロックを再開します。

追加のメカニズム:

  • DPウェーブカウンター - システムは「ウェーブ」を追跡します。すべてのエンジンがアイドルになると、それらは静止し、新しい作業が到着するとカウンターが増加します(調整/メトリクスに便利)。
  • 制御メッセージ - APIサーバーは推論リクエスト以上のものを送信できます(例: 中止やユーティリティ/制御RPC)。
  • ダミーステップによるロックステップ - いずれかのDPレプリカに作業がある場合、すべてのレプリカはフォワードステップを実行します。リクエストのないレプリカは、必要な同期ポイントに参加するためにダミーステップを実行します(アクティブなレプリカのブロックを回避します)。

ロックステップの明確化:これは実際には、エキスパートレイヤーがEPまたはTPグループを形成し、アテンションレイヤーがまだDPであるMoEモデルにのみ必要です。現在、DPでは常に実行されます。これは、複数の独立したvLLMを実行して通常の方式でそれらの間でロードバランシングできるため、「組み込み」非MoE DPの用途が限られているためです。

次に、APIサーバーノードで何が起こるかです。

APIサーバーノード上

AsyncLLMオブジェクト(LLMエンジンの非同期ラッパー)をインスタンス化します。内部的にはDPLBAsyncMPClient(データ並列、ロードバランシング、非同期、マルチプロセッシングクライアント)を作成します。

MPClientの親クラス内では、launch_core_engines関数が実行され、以下を行います:

  1. 起動ハンドシェイクに使用されるZMQアドレスを作成します(ヘッドレスノードで見られたもの)。
  2. DPCoordinatorプロセスをスポーンします。
  3. CoreEngineProcManager(ヘッドレスノードと同じ)を作成します。

AsyncMPClient内(MPClientの子)では、以下を行います:

  1. outputs_queue(asyncio.Queue)を作成します。
  2. process_outputs_socketという非同期タスクを作成します。これは、4つのDPEngineCoreProcすべての出力スレッドと通信し(出力ソケットを介して)、outputs_queueに書き込みます。
  3. その後、さらに1つの非同期タスクoutput_handlerがAsyncLLMからこのキューを読み取り、最終的にcreate_completion関数に情報を送信します。

DPAsyncMPClient内では、run_engine_stats_update_taskという非同期タスクを作成し、DPコーディネーターと通信します。

DPコーディネーターは、フロントエンド(APIサーバー)とバックエンド(エンジンコア)の間を仲介します。以下を行います:

  • 定期的にロードバランシング情報(キューサイズ、待機中/実行中のリクエスト)をフロントエンドのrun_engine_stats_update_taskに送信します。
  • フロントエンドからのSCALE_ELASTIC_EPコマンドを処理し、エンジンの数を動的に変更します(Rayバックエンドでのみ機能します)。
  • フロントエンドによってトリガーされたときにバックエンドにSTART_DP_WAVEイベントを送信し、ウェーブ状態の更新をバックエンドに報告します。

要約すると、フロントエンド(AsyncLLM)は複数の非同期タスク(並列ではなく、並行であることを覚えておいてください)を実行します:

  • タスクのクラスは、generateパスを通じて入力リクエストを処理します(各新しいクライアントリクエストは新しい非同期タスクを生成します)。
  • 2つのタスク(process_outputs_socket、output_handler)は、基盤となるエンジンの出力メッセージを処理します。
  • 1つのタスク(run_engine_stats_update_task)は、DPコーディネーターとの通信を維持します:ウェーブトリガーの送信、LB状態のポーリング、動的スケーリングリクエストの処理。

最後に、メインサーバープロセスはFastAPIアプリケーションを作成し、OpenAIServingCompletionやOpenAIServingChatなどのエンドポイントをマウントします。これらは/completion、/chat/completionなどを公開します。その後、スタックはUvicornを介して提供されます。

したがって、すべてをまとめると、ここに完全なリクエストライフサイクルがあります!

ターミナルから以下を送信します:

curl -X POST http://localhost:8000/v1/completions -H "Content-Type: application/json" -d '{
  "model": "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
  "prompt": "The capital of France is",
  "max_tokens": 50,
  "temperature": 0.7
}'

次に何が起こるか:

  1. リクエストはAPIサーバー上のOpenAIServingCompletionのcreate_completionルートにヒットします。

  2. 関数はプロンプトを非同期にトークン化し、メタデータ(リクエストID、サンプリングパラメータ、タイムスタンプなど)を準備します。

  3. 次にAsyncLLM.generateを呼び出します。これは同期エンジンのフローと同じように動作し、最終的にDPAsyncMPClient.add_request_asyncを呼び出します。

  4. これはさらにget_core_engine_for_requestを呼び出します。これはDPコーディネーターの状態に基づいてエンジン間でロードバランシングを行います(最もスコアが低い/負荷が低いエンジンを選択します:score = len(waiting) * 4 + len(running))。

  5. ADDリクエストは、選択されたエンジンのinput_socketに送信されます。

  6. そのエンジンで:

    • 入力スレッド - ブロック解除され、入力ソケットからデータをデコードし、メインスレッドのためにinput_queueに作業項目を配置します。
    • メインスレッド - input_queueでブロック解除され、リクエストをエンジンに追加し、停止条件が満たされるまで繰り返しengine_core.step()を呼び出し、中間結果をoutput_queueにエンキューします。

    リマインダー:step()はスケジューラ、モデルエグゼキュータ(これはさらにMultiProcExecutorになる可能性があります!)などを呼び出します。これらはすでに確認済みです!

    • 出力スレッド - output_queueでブロック解除され、結果をアウトプットソケット経由で送り返します。
  7. これらの結果は、AsyncLLMの出力非同期タスク(process_outputs_socketおよびoutput_handler)をトリガーし、それらはトークンをFastAPIのcreate_completionルートに伝播させます。

  8. FastAPIはメタデータ(終了理由、ログプロブ、使用状況情報など)をアタッチし、Uvicornを介してターミナルにJSONResponseを返します!

そして、完了が返されました - 単純なcurlコマンドの背後にある分散機械全体です! :) とても楽しいです!!!

📝追加注記:

  • APIサーバーをさらに追加する場合、ロードバランシングはOS/ソケットレベルで処理されます。アプリケーションの観点からは、何も大幅には変わりません - 複雑さは隠されています。
  • RayをDPバックエンドとして使用する場合、/scale_elastic_epというURLエンドポイントを公開して、エンジンレプリカ数の自動スケーリングを有効にできます。

ベンチマークと自動チューニング - レイテンシ対スループット

これまでは「ガス粒子」- リクエストがエンジン/システムを流れる仕組みの内部を分析してきました。今度はズームアウトしてシステム全体を見て、「推論システムのパフォーマンスをどのように測定するか?」と問いかけます。

最高レベルでは、2つの競合するメトリクスがあります:

  1. レイテンシ - リクエストが送信されてからトークンが返されるまでの時間。
  2. スループット - システムが秒あたりに生成/処理できるトークン/リクエスト数。

レイテンシは、ユーザーが応答を待っているインタラクティブなアプリケーションで最も重要です。

スループットは、事前/事後トレーニング実行の合成データ生成、データクリーニング/処理、および一般的に - あらゆる種類のオフラインバッチ推論ジョブなどのオフラインワークロードで重要です。

レイテンシとスループットが競合する理由を説明する前に、いくつかの一般的な推論メトリクスを定義しましょう:

メトリック定義
TTFT (Time To First Token)リクエスト送信から最初の出力トークン受信までの時間
ITL (Inter-Token Latency)連続する2つのトークン間の時間(例: トークン i-1 からトークン i まで)
TPOT (Time Per Output Token)リクエストのすべての出力トークンにわたる平均ITL
Latency / E2E (End-to-End Latency)リクエストを処理する総時間、つまりTTFT + すべてのITLの合計、または同等にリクエスト送信と最後の出力トークン受信の間の時間
Throughput秒あたりの総処理トークン数(入力、出力、または両方)、または代替としてリクエスト数
Goodputサービスレベル目標(SLO)、例えば最大TTFT、TPOT、またはe2eレイテンシを満たすスループット。例えば、これらのSLOを満たすリクエストからのトークンのみがカウントされます

[画像: ttft, itl, e2e latency]

ttft、itl、e2eレイテンシ

これらの2つのメトリクスが競合する理由を説明する単純化されたモデルを以下に示します。

仮定:重みI/OがKVキャッシュI/Oよりも支配的であると仮定します。つまり、短いシーケンスを扱っています。

バッチサイズBが単一のデコードステップにどのように影響するかを見ると、トレードオフが明らかになります。B ↓が1に向かって減少すると、ITLは低下します:ステップあたりの作業量が少なくなり、トークンは他のトークンと「競合」しません。B ↑が無限大に向かって増加すると、ITLは上昇します。なぜなら、ステップあたりのFLOP数が増加するからです - しかし、スループットは向上します(ピークパフォーマンスに達するまで)。なぜなら、重みI/Oはより多くのトークンに償却されるからです。

ルーフラインモデルは、ここで理解するのに役立ちます:飽和バッチB_sat以下では、ステップ時間はHBM帯域幅(レイヤーごとにオンチップメモリに重みをストリーミングする)によって支配されるため、ステップレイテンシはほぼ一定です - 1トークンまたは10トークンを計算するのにかかる時間はほぼ同じです。B_satを超えると、カーネルは計算バウンドになり、ステップ時間はBにほぼ比例して増加します。追加の各トークンはITLを増加させます。

[画像: roofline perf model]

ルーフラインパフォーマンスモデル

📝注記:

より厳密な扱いのためには、カーネル自動チューニングを考慮する必要があります:Bが増加すると、ランタイムは形状に応じてより効率的なカーネルに切り替える可能性があり、達成されるパフォーマンスP_kernelが変化します。ステップレイテンシはt = FLOPs_step / P_kernelであり、ここでFLOPs_stepはステップ内の作業量です。P_kernelがP_peakに達すると、ステップあたりの計算量が増加するとレイテンシが直接増加することがわかります。

vLLMでのベンチマーク方法

vLLMは、vllm / benchmarks / {server,latency,throughput}.pyをラップするvllm bench {serve,latency,throughput} CLIを提供します。

スクリプトが行うことは以下の通りです:

  • latency - 短い入力(デフォルト32トークン)を使用し、小さいバッチ(デフォルト8)で128トークンをサンプリングします。数回のイテレーションを実行し、バッチのE2Eレイテンシを報告します。
  • throughput - 固定セットのプロンプト(デフォルト: 1000 ShareGPTサンプル)をすべて一度に送信します(いわゆるQPS=Infモード)。実行全体での入力/出力/総トークン数とリクエスト数を報告します。
  • serve - vLLMサーバーを起動し、リクエストの到着間隔をポアソン(またはより一般的にはガンマ)分布からサンプリングすることで、実際のワークロードをシミュレートします。指定された時間ウィンドウでリクエストを送信し、議論したすべてのメトリクスを測定し、オプションでサーバー側最大同時実行数(セマフォを介して、例えばサーバーを64同時リクエストに制限する)を強制できます。

レイテンシスクリプトの実行方法の例を以下に示します:

vllm bench latency
  --model <model-name>
  --input-tokens 32
  --output-tokens 128
  --batch-size 8

CIで使用されるベンチマーク構成は、.buildkite/nightly-benchmarks/testsの下にあります。

ターゲットSLOを満たす引数設定を見つけるためにサーブベンチマークを駆動する自動チューニングスクリプトもあります(例: 「p99 e2e < 500 msを維持しながらスループットを最大化する」)。推奨される構成を返します。

エピローグ

基本的なエンジンコア(UniprocExecutor)から始め、推論的デコーディングやプレフィックスキャッシングなどの高度な機能を追加し、MultiProcExecutor(TP/PP > 1付き)にスケールアップし、最終的に非同期エンジンと分散サービングスタックにすべてをラップしてスケールアウトしました。そして、システムパフォーマンスの測定方法で締めくくりました。

vLLMには、省略した特殊な処理も含まれています。例:

  • 多様なハードウェアバックエンド:TPU、AWS Neuron(Trainium/Inferentia)など。
  • アーキテクチャ/技術:MLA、MoE、エンコーダー・デコーダー(例: Whisper)、プーリング/埋め込みモデル、EPLB、m-RoPE、LoRA、ALiBi、アテンションフリーバリアント、スライディングウィンドウアテンション、マルチモーダルLM、状態空間モデル(例: Mamba/Mamba-2、Jamba)。
  • TP/PP/SP
  • ハイブリッドKVキャッシュロジック(Jenga)、ビームサンプリングのようなより複雑なサンプリング方法、その他多数。
  • 実験的:非同期スケジューリング。

良い点は、これらのほとんどがメインフローとは直交していることです。実際には(もちろん、ある程度の結合はありますが)「プラグイン」のように扱うことができます。

システムを理解するのが好きです。そうは言っても、この高度からの解像度は確かに低下しました。次の投稿では、特定のサブシステムにズームインし、詳細に踏み込みます。

💡連絡先:

投稿に誤りを見つけた場合は、DMしてください。お気軽にXまたはLinkedIn、または匿名フィードバックでメッセージをドロップしてください。

謝辞

過去1年間、実験のためにH100を提供してくれたHyperstackに心から感謝します!

Nick Hill(vLLMコアコントリビューター、RedHat)、Mark Saroufim(PyTorch)、Kyle Krannen(NVIDIA、Dynamo)、およびAshish Vaswaniに、このブログ投稿のプレリリース版を読んでフィードバックを提供してくれたことに感謝します!

新しい投稿を公開したら通知を受け取ります。

参考文献

  1. vLLM https://github.com/vllm-project/vllm
  2. "Attention Is All You Need", https://arxiv.org/abs/1706.03762
  3. "Efficient Memory Management for Large Language Model Serving with PagedAttention", https://arxiv.org/abs/2309.06180
  4. "DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model", https://arxiv.org/abs/2405.04434
  5. "Jenga: Effective Memory Management for Serving LLM with Heterogeneity", https://arxiv.org/abs/2503.18292
  6. "Orca: A Distributed Serving System for Transformer-Based Generative Models", https://www.usenix.org/conference/osdi22/presentation/yu
  7. "XGrammar: Flexible and Efficient Structured Generation Engine for Large Language Models", https://arxiv.org/abs/2411.15100
  8. "Accelerating Large Language Model Decoding with Speculative Sampling", https://arxiv.org/abs/2302.01318
  9. "EAGLE: Speculative Sampling Requires Rethinking Feature Uncertainty", https://arxiv.org/abs/2401.15077
  10. "Medusa: Simple LLM Inference Acceleration Framework with Multiple Decoding Heads", https://arxiv.org/abs/2401.10774
  11. LMCache, https://github.com/LMCache/LMCache