vLLMを超えた新たな王座：SGLangがLLM推論の勢力図を変える5つの理由

[リクエストA] System Prompt(500 tokens) + User Query A(50 tokens)
[リクエストB] System Prompt(500 tokens) + User Query B(80 tokens)
[リクエストC] System Prompt(500 tokens) + User Query C(30 tokens)

RadixAttention KVキャッシュツリー構造
=================================

                          [ROOT]
                            |
                +-----------+-----------+
                |                       |
        [System Prompt]           [Few-shot Prefix]
        "You are a helpful       "Translate the following
         AI assistant..."         examples..."
         (KV: 500 tokens)         (KV: 800 tokens)
                |                       |
        +-------+-------+        +-----+-----+
        |               |        |           |
   [User A]        [User B]  [Example 1]  [Example 2]
   "What is       "Explain   "Hello->     "Good->
    Docker?"      K8s pods"   こんにちは"   良い"
   (KV: 50 tok)  (KV: 80 tok) (KV: 30 tok) (KV: 25 tok)
        |               |
   [Turn 2-A]     [Turn 2-B]
   "How to       "What about
    install?"     services?"
   (KV: 40 tok)  (KV: 60 tok)
        |
   [Turn 3-A]
   "Configure
    networking"
   (KV: 45 tok)

新リクエスト："You are a helpful AI assistant... What is Kubernetes?"

Radix Tree探索:
  [ROOT] → [System Prompt] マッチ！(500 tokens再利用)
                 → [User A: "What is Docker?"] 不一致
                 → [User B: "Explain K8s pods"] 不一致
                 → 新しいブランチ作成が必要

結果：500 tokensのKVキャッシュを再利用、残りの50 tokensのみ新規計算

LRU退去プロセス:
=================
メモリ不足発生！

1. リーフノードの中で最も長くアクセスされていないノードを選択
   → [Turn 3-A]（最終アクセス：30分前）

2. そのノードのKVキャッシュを解放（45 tokens回収）

3. 親ノード検査：[Turn 2-A]に他の子があるか？
   → なし：親も退去候補に昇格
   → あり：親を維持

4. メモリ十分？ → でなければ次のLRUリーフノードで繰り返し

エージェント実行フロー（10ステップ推論）:
================================
[Step 1] System + Tools + Query               → 1000 tokens（新規計算）
[Step 2] System + Tools + Query + Obs1         → 1000 再利用 + 200 新規計算
[Step 3] System + Tools + Query + Obs1 + Obs2  → 1200 再利用 + 200 新規計算
...
[Step 10] System + Tools + Query + Obs1~Obs9   → 2800 再利用 + 200 新規計算

RadixAttention：総新規演算 = 1000 + 200*9 = 2,800 tokens
PagedAttention：総新規演算 = 1000 + 1200 + 1400 + ... + 2800 = 19,000 tokens

削減率：約85%

Cache-Aware Load Balancing:

リクエスト："System Prompt A + User Query X"

Instance 1: Radix Treeに"System Prompt A"キャッシュ存在 ← ここにルーティング！
Instance 2: Radix Treeに"System Prompt B"キャッシュ存在
Instance 3: Radix Treeに"System Prompt A"キャッシュなし

結果：キャッシュヒット率最大化 → 1.9倍スループット向上、3.8倍キャッシュヒット率向上

vLLM Architecture (Simplified):
================================
[Request] → [Scheduler] → [Executor Interface]
                              ↓
                    [Backend Abstraction Layer]
                              ↓
                    [Attention Backend Plugin]
                              ↓
                    [FlashInfer / FlashAttention / ...]
                              ↓
                          [GPU Kernel]

SGLang Architecture (Simplified):
=================================
[Request] → [Zero-Overhead Scheduler]
                    ↓
            [Direct FlashInfer Integration]
                    ↓
            [TMA-Optimized GPU Kernel]
                    ↓
                [GPU HBM]

従来方式（Sequential）:
========================
Time →  [CPU: Batch N 準備] [GPU: Batch N 演算] [CPU: Batch N+1 準備] [GPU: Batch N+1 演算]
                                ↑ GPU idle                              ↑ GPU idle

SGLang Zero-Overhead (Pipelined):
==================================
Time →  [CPU: Batch N 準備] [CPU: Batch N+1 準備] [CPU: Batch N+2 準備] [CPU: Batch N+3 準備]
        [                 ] [GPU: Batch N 演算  ] [GPU: Batch N+1 演算] [GPU: Batch N+2 演算]
                             ↑ No GPU idle!        ↑ No GPU idle!       ↑ No GPU idle!

# SGLangスケジューラのコアループ（概念的疑似コード）
class ZeroOverheadScheduler:
    def run_event_loop(self):
        while True:
            # 1. GPUから前のバッチ結果を非同期受信（non-blocking）
            completed = self.recv_from_gpu(blocking=False)
            if completed:
                self.process_completed_tokens(completed)

            # 2. 次のバッチ構成（CPUで実行）
            next_batch = self.schedule_next_batch()

            # 3. Radix Treeでプレフィックスマッチング（CPUで実行）
            self.match_prefixes(next_batch)

            # 4. GPUメモリ割り当て（CPUで実行）
            self.allocate_kv_cache(next_batch)

            # 5. GPUにバッチ送信（non-blocking）
            self.send_to_gpu(next_batch)

            # GPUはこの全プロセスの間、前のバッチを処理中！

従来のStatic Batching:
=====================
Batch: [Req A(100 tok), Req B(50 tok), Req C(200 tok)]

Step 1-50:   A, B, C すべて処理
Step 51-100: A, C 処理（B完了、スロット浪費）
Step 101-200: Cのみ処理（Aも完了、2スロット浪費）

SGLang Iterative Scheduling:
============================
Step 1-50:   [A, B, C] 処理
Step 51:     B完了 → 即座に [A, C, D]（新リクエストD挿入）
Step 101:    A完了 → 即座に [C, D, E, F]（新リクエストE, F挿入）

→ GPU活用率最大化！

Micro-Batching Event Loop (PP=2):
==================================
GPU Stage 0: [Fwd mb0] [Fwd mb2] [Fwd mb4] ...
GPU Stage 1:           [Fwd mb0] [Fwd mb2] [Fwd mb4] ...
P2P Comm:      [Send mb0→S1] [Send mb2→S1] ...
CPU:         [Sched mb2] [Sched mb4] [Sched mb6] ...

mb = micro-batch, S = Stage, Fwd = Forward Pass
→ すべてのリソースが同時にアクティブ！

同一GPUでのタイムシェアリング処理:
========================
Time → [Prefill Req A] [Decode Batch 1-5] [Prefill Req B] [Decode Batch 1-8]
                          ↑                                   ↑
                   Decodeレイテンシ不規則            新しいPrefillが既存Decodeを妨害
                   （PrefillがGPUを占有）           （TPOTスパイク発生）

PD Disaggregation Architecture:
================================

   +-----------------------------------------------------+
   |                    Router / Gateway                  |
   |     （リクエスト受信とPrefillサーバーへの分配）        |
   +------------------+----------------------------------+
                      |
          +-----------+-----------+
          v                       v
   +--------------+      +--------------+
   |  Prefill GPU  |      |  Prefill GPU  |
   |   Group #1    |      |   Group #2    |
   |  (H100 x4)   |      |  (H100 x4)   |
   |              |      |              |
   | Compute-     |      | Compute-     |
   | Optimized    |      | Optimized    |
   +------+-------+      +------+-------+
          | NIXL/RDMA            | NIXL/RDMA
          | KV Cache Transfer    | KV Cache Transfer
          v                       v
   +--------------+      +--------------+
   |  Decode GPU   |      |  Decode GPU   |
   |   Group #1    |      |   Group #2    |
   |  (H100 x4)   |      |  (H100 x4)   |
   |              |      |              |
   | Bandwidth-   |      | Bandwidth-   |
   | Optimized    |      | Optimized    |
   +--------------+      +--------------+

NIXL KV Cache Transfer Flow:
============================

1. Bootstrap: Decode → Prefillにbootstrap_room IDを伝達
2. Memory Alloc: DecodeがGPUメモリページを事前割り当て
3. Prefill Exec: Prefill Workerがプロンプト処理 → KV Cache生成
4. RDMA Write: PrefillがRDMAを通じてDecode GPUメモリに直接書き込み
                （CPU回避、Zero-Copy）
5. Completion: Decodeが転送完了をポーリング → 即座にDecode開始

NVLink転送帯域幅: ~900 GB/s (GB200 NVL72)
InfiniBand転送帯域幅: ~400 Gb/s (HDR)

トラフィックパターンに応じたスケーリング:

[シナリオ1：長いプロンプト、短い応答（文書要約）]
→ Prefill GPU: 8台  /  Decode GPU: 2台

[シナリオ2：短いプロンプト、長い応答（コード生成）]
→ Prefill GPU: 2台  /  Decode GPU: 8台

[シナリオ3：均等負荷（一般チャットボット）]
→ Prefill GPU: 4台  /  Decode GPU: 4台

JSONスキーマ例:
{
  "name": string,
  "age": integer,
  "city": string
}

通常FSM（トークン別遷移）:
========================
S0 →'{' → S1 →'"' → S2 →'n' → S3 →'a' → S4 →'m' → S5 →'e' → S6 →'"' → S7 →':' → S8

各遷移にGPU forward passが必要 → 8回のforward pass

Compressed FSM（ジャンプフォワード）:
=============================
S0 → '{"name":' → S8  (Singular transitions圧縮！)

検出：S0からS8まで各状態で可能な遷移がちょうど1つだけ
→ 1回のforward passで8トークン生成！

Jump-Forward Decodingプロセス:
===========================

1. FSM事前分析:
   - 各状態で可能な遷移数を計算
   - Singular path区間を識別・圧縮

2. デコーディング実行:
   State S0: 可能な遷移 = {'{'} (singular!)
   → Jump: '{"name":"' を直接挿入（forward pass不要）

   State S8: 可能な遷移 = {any string token} (multiple)
   → Normal decode: GPU forward passを実行 → "Alice"

   State S9: 可能な遷移 = {'","age":'} (singular!)
   → Jump: '","age":' を直接挿入

   State S10: 可能な遷移 = {0-9 tokens} (multiple)
   → Normal decode: GPU forward passを実行 → "30"

   State S11: 可能な遷移 = {'","city":"'} (singular!)
   → Jump: '","city":"' を直接挿入

   ...続く

import openai

client = openai.Client(base_url="http://127.0.0.1:30000/v1", api_key="EMPTY")

# JSON Schemaによる構造化出力
response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[
        {"role": "user", "content": "Generate a user profile for Alice who is 30 years old."}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "user_profile",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "age": {"type": "integer"},
                    "city": {"type": "string"},
                    "hobbies": {
                        "type": "array",
                        "items": {"type": "string"}
                    }
                },
                "required": ["name", "age", "city", "hobbies"]
            }
        }
    },
    max_tokens=256
)

print(response.choices[0].message.content)
# 出力: {"name": "Alice", "age": 30, "city": "San Francisco", "hobbies": ["reading", "hiking", "coding"]}

# Regexベース構造化生成
response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[
        {"role": "user", "content": "Generate a valid email address for John."}
    ],
    extra_body={"regex": r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"},
    max_tokens=64
)

# Python 3.9+必要、CUDA 12.x推奨
pip install --upgrade pip
pip install "sglang[all]"

# またはuvを使用した高速インストール
pip install uv
uv pip install "sglang[all]"

git clone https://github.com/sgl-project/sglang.git
cd sglang
pip install -e "python[all]"

# 公式Dockerイメージ使用
docker run --gpus all \
  --shm-size 32g \
  -p 30000:30000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  --env "HF_TOKEN=${HF_TOKEN}" \
  --ipc=host \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path meta-llama/Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --port 30000

# docker-compose.yml
version: '3.8'
services:
  sglang:
    image: lmsysorg/sglang:latest
    ports:
      - '30000:30000'
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
    environment:
      - HF_TOKEN=${HF_TOKEN}
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    ipc: host
    shm_size: '32g'
    command: >
      python3 -m sglang.launch_server
      --model-path meta-llama/Llama-3.1-8B-Instruct
      --host 0.0.0.0
      --port 30000

docker compose up -d

# 基本サーバー起動（単一GPU）
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-8B-Instruct \
  --host 0.0.0.0 \
  --port 30000

# またはsglang serveコマンド使用
sglang serve meta-llama/Llama-3.1-8B-Instruct \
  --host 0.0.0.0 \
  --port 30000

# サーバーヘルスチェック
curl http://localhost:30000/health

# モデル情報確認
curl http://localhost:30000/v1/models

# サーバーメトリクス確認
curl http://localhost:30000/get_server_info

curl http://127.0.0.1:30000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer EMPTY" \
  -d '{
    "model": "meta-llama/Llama-3.1-8B-Instruct",
    "messages": [
      {"role": "system", "content": "You are a helpful AI assistant."},
      {"role": "user", "content": "KubernetesのPodとDeploymentの違いを説明してください。"}
    ],
    "max_tokens": 512,
    "temperature": 0.7,
    "top_p": 0.9
  }'

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:30000/v1",
    api_key="EMPTY"  # SGLangはデフォルトで認証不要
)

# 通常のChat Completion
response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[
        {"role": "system", "content": "あなたはクラウドネイティブの専門家です。"},
        {"role": "user", "content": "Helm chartとKustomizeの長所と短所を比較してください。"}
    ],
    max_tokens=1024,
    temperature=0.7
)

print(response.choices[0].message.content)

# ストリーミング応答
stream = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[
        {"role": "user", "content": "Pythonで簡単なWebサーバーを作成してください。"}
    ],
    max_tokens=1024,
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

curl http://127.0.0.1:30000/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta-llama/Llama-3.1-8B-Instruct",
    "prompt": "The capital of France is",
    "max_tokens": 32,
    "temperature": 0
  }'

import requests
import json

# ネイティブSGLangバッチエンドポイント
batch_requests = [
    {
        "text": "Translate to Korean: Hello, how are you?",
        "sampling_params": {"max_new_tokens": 64, "temperature": 0.3}
    },
    {
        "text": "Translate to Korean: The weather is nice today.",
        "sampling_params": {"max_new_tokens": 64, "temperature": 0.3}
    },
    {
        "text": "Translate to Korean: I love programming.",
        "sampling_params": {"max_new_tokens": 64, "temperature": 0.3}
    }
]

# 非同期リクエストでスループット最大化
import asyncio
import aiohttp

async def send_requests(requests_data):
    async with aiohttp.ClientSession() as session:
        tasks = []
        for req in requests_data:
            task = session.post(
                "http://localhost:30000/generate",
                json=req
            )
            tasks.append(task)
        responses = await asyncio.gather(*tasks)
        results = [await r.json() for r in responses]
        return results

results = asyncio.run(send_requests(batch_requests))
for r in results:
    print(r["text"])

import sglang as sgl

# SGLangフロントエンド関数定義
@sgl.function
def multi_turn_qa(s, question1, question2):
    s += sgl.system("You are a helpful AI assistant specialized in cloud computing.")
    s += sgl.user(question1)
    s += sgl.assistant(sgl.gen("answer1", max_tokens=256))
    s += sgl.user(question2)
    s += sgl.assistant(sgl.gen("answer2", max_tokens=256))

# ランタイムエンドポイント設定
sgl.set_default_backend(sgl.RuntimeEndpoint("http://localhost:30000"))

# 実行
state = multi_turn_qa.run(
    question1="KubernetesでHPAはどのように動作しますか？",
    question2="VPAとの違いは何ですか？"
)

print("Answer 1:", state["answer1"])
print("Answer 2:", state["answer2"])

@sgl.function
def parallel_analysis(s, topic):
    s += sgl.system("You are a technology analyst.")
    s += sgl.user(f"Analyze '{topic}' from three perspectives.")

    # Fork: 3つの分析を並列生成
    forks = s.fork(3)

    forks[0] += sgl.user("Technical perspective:")
    forks[0] += sgl.assistant(sgl.gen("technical", max_tokens=200))

    forks[1] += sgl.user("Business perspective:")
    forks[1] += sgl.assistant(sgl.gen("business", max_tokens=200))

    forks[2] += sgl.user("User experience perspective:")
    forks[2] += sgl.assistant(sgl.gen("ux", max_tokens=200))

    # Join: すべての結果を収集
    forks.join()

    # 総合
    s += sgl.user("Summarize the three analyses above:")
    s += sgl.assistant(sgl.gen("summary", max_tokens=300))

state = parallel_analysis.run(topic="SGLang inference engine")
print("Technical:", state["technical"])
print("Business:", state["business"])
print("UX:", state["ux"])
print("Summary:", state["summary"])

@sgl.function
def classify_sentiment(s, text):
    s += sgl.user(f"Classify the sentiment of the following text: '{text}'")
    s += sgl.assistant(
        "The sentiment is " + sgl.select("label", ["positive", "negative", "neutral"])
    )

state = classify_sentiment.run(text="SGLang is amazingly fast!")
print("Sentiment:", state["label"])  # "positive"

python -m sglang.launch_server \
  --model-path <model_name_or_path>    # HuggingFaceモデル名またはローカルパス
  --host 0.0.0.0                        # バインディングホスト
  --port 30000                          # サービスポート
  --tp-size 4                           # Tensor Parallelismサイズ
  --dp-size 2                           # Data Parallelismサイズ
  --pp-size 2                           # Pipeline Parallelismサイズ
  --mem-fraction-static 0.88            # GPUメモリ中KV Cache割合（デフォルト: 0.88）
  --max-running-requests 128            # 同時処理最大リクエスト数
  --max-total-tokens 131072             # 最大総トークン数
  --context-length 32768                # コンテキスト長
  --chunked-prefill-size 8192           # Chunked Prefillチャンクサイズ
  --schedule-policy lpm                 # スケジューリングポリシー（lpm / fcfs / random）
  --quantization fp8                    # 量子化方法（fp8 / int4 / awq / gptq）
  --dtype auto                          # データ型（auto / float16 / bfloat16）
  --trust-remote-code                   # リモートコード信頼許可
  --chat-template auto                  # チャットテンプレート（autoまたはカスタムパス）
  --log-level info                      # ログレベル
  --enable-metrics                      # Prometheusメトリクス有効化
  --api-key "your-secret-key"           # APIキー認証有効化

# GPUメモリの88%をKV Cacheに割り当て（デフォルト値）
--mem-fraction-static 0.88

# 大規模モデルでメモリ不足時に削減
--mem-fraction-static 0.80

# KV Cache最大トークン数を明示的に設定
--max-total-tokens 65536

# LPM（Longest Prefix Match）：RadixAttentionキャッシュヒット率最大化（デフォルト）
--schedule-policy lpm

# FCFS（First Come First Served）：単純先入先出
--schedule-policy fcfs

# Random：ランダム選択
--schedule-policy random

# FP8量子化（Hopper+ GPU必要）
--quantization fp8

# NVFP4量子化（Blackwell GPU必要）
--quantization fp4

# INT4 AWQ量子化
--quantization awq

# INT4 GPTQ量子化
--quantization gptq

# CUDAデバイス選択
export CUDA_VISIBLE_DEVICES=0,1,2,3

# HuggingFaceトークン（ゲートモデルアクセス）
export HF_TOKEN="hf_your_token_here"

# NCCL設定（マルチGPU）
export NCCL_P2P_DISABLE=0
export NCCL_IB_DISABLE=0

# SGLangログレベル
export SGLANG_LOG_LEVEL=info

# FlashInferワークスペースサイズ
export SGLANG_FLASHINFER_WORKSPACE_SIZE=2147483648  # 2GB

# Llama-3.1-8Bを単一GPUにデプロイ
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-8B-Instruct \
  --host 0.0.0.0 \
  --port 30000 \
  --mem-fraction-static 0.88

# 量子化を適用してより大きなモデルを単一GPUにデプロイ
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-70B-Instruct \
  --quantization awq \
  --host 0.0.0.0 \
  --port 30000

# 4-GPU Tensor Parallelism（70Bモデル）
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-70B-Instruct \
  --tp-size 4 \
  --host 0.0.0.0 \
  --port 30000

# 2-GPU TP + 2-GPU DP = 4 GPU（8Bモデル、スループット最大化）
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-8B-Instruct \
  --tp-size 2 \
  --dp-size 2 \
  --host 0.0.0.0 \
  --port 30000

# Node 0 (Master)
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-405B-Instruct \
  --tp-size 16 \
  --nnodes 2 \
  --node-rank 0 \
  --dist-init-addr node0-ip:5000 \
  --host 0.0.0.0 \
  --port 30000

# Node 1 (Worker)
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-405B-Instruct \
  --tp-size 16 \
  --nnodes 2 \
  --node-rank 1 \
  --dist-init-addr node0-ip:5000

# Prefillサーバー起動
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-70B-Instruct \
  --tp-size 4 \
  --disaggregation-mode prefill \
  --disaggregation-transfer-backend nixl \
  --host 0.0.0.0 \
  --port 30001

# Decodeサーバー起動
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-70B-Instruct \
  --tp-size 4 \
  --disaggregation-mode decode \
  --disaggregation-transfer-backend nixl \
  --host 0.0.0.0 \
  --port 30002

# sglang-skypilot.yaml
resources:
  cloud: aws # またはgcp, azure
  accelerators: A100:4
  memory: 128+

envs:
  HF_TOKEN: <your-hf-token>
  MODEL_NAME: meta-llama/Llama-3.1-70B-Instruct

setup: |
  pip install "sglang[all]"

run: |
  python -m sglang.launch_server \
    --model-path ${MODEL_NAME} \
    --tp-size 4 \
    --host 0.0.0.0 \
    --port 30000

# SkyPilotでクラスター作成とデプロイ
pip install skypilot-nightly
sky launch -c sglang-cluster --env HF_TOKEN sglang-skypilot.yaml

# ベースモデル + 複数LoRAアダプター同時サービング
python -m sglang.launch_server \
  --model-path meta-llama/Llama-3.1-8B-Instruct \
  --lora-paths \
    korean-chat=/path/to/korean-lora \
    code-gen=/path/to/code-lora \
    medical=/path/to/medical-lora \
  --max-loras-per-batch 4 \
  --host 0.0.0.0 \
  --port 30000

curl http://127.0.0.1:30000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "korean-chat",
    "messages": [{"role": "user", "content": "こんにちは！"}],
    "max_tokens": 128
  }'

推論コスト = GPU時間あたりコスト / スループット (tok/s)

H100基準:
  vLLM:  $3.50/hr / 12,553 tok/s = $0.000279 / 1K tokens
  SGLang: $3.50/hr / 16,215 tok/s = $0.000216 / 1K tokens

→ SGLangは同じGPUで22.6%コスト削減
→ エージェントシナリオ（キャッシュヒット率含む）：最大60-80%コスト削減