レイテンシとスループット — 台数を増やしたら遅くなった

レイテンシとスループット。ストップウォッチと処理カードを運ぶコンベヤー、性能メーター。

※本記事はアフィリエイト広告(PR)を含みます。

台数を増やしたのに遅くなることがあります。レイテンシとスループットを分けて考えます。

前回: 設計の進め方と容量見積もり — 図ではなく数から始める

これは【深掘り】の記事です。本線の順路ではありません。 読まなくても先へ進めます。 本線の ボトルネックは動く — 負荷分散とキャッシュの設計 の続きとして、そこで「ボトルネックを見つける」と一言で書いた部分だけを、実際に測って分解する回です。

この記事のコマンドは、すべて VM の中(Ubuntu Server)で打ちます。 Windows の PowerShell では打ちません。 前提: Node.js が入っていること(node -v が返ること)。本線の APIの正体はJSONを返すHTTP — Node.jsで作る を終えていれば入っています。 この記事はサーバーをわざと限界まで殴ります。 殴るのは自分の VM の中で自分が立てたプロセスだけです。他人のサーバーに負荷をかけてはいけません。

対象レベル: 中級〜上級 / 区分: 発展

目次

台数を増やしたら、遅くなった

「画面が遅い」と言われました。やったことはこれです。

API のプロセスを1個から3個に増やした。

変わりませんでした。 それどころか、しばらくして前より遅くなりました。

このとき私が見ていた数字は、こうでした。

リクエスト1本の時間: 直す前 250ms → 直したあと 260ms

増やしたのに、悪くなっています。 意味が分からなくて、さらに1台増やしました。もっと悪くなりました。

原因は、あとから測って分かりました。

私が直そうとしていたのは「1本が終わるまでの時間」。 台数を増やして直るのは「1秒に何本終わるか」。 別の量を、同じ「遅い」という言葉で呼んでいました。

しかも、増やした3個は同じ VM の中で1コアを取り合っていました。仕事は増えていないのに、切り替えの手間だけが増えたわけです。さらに分割したぶん、プロセス間の通信が新しく生まれました。「遅い」に効く手を1つも打っていないのに、余計な仕事だけを足していたことになります。

本線の 速くする前に必ず測る — パフォーマンス改善とEXPLAIN で「測ってから直す」はやりました。あれは「どこが遅いか」を測る回でした。 この記事は、その手前です。

「何が遅いのか」を、2つの量に分けるところから始めます。

この記事でわかること

  • レイテンシとスループットは別の量であること。片方を良くすると、もう片方が悪くなることがある
  • 並列度を上げるとスループットは上がるが、レイテンシは悪化すること。同時に良くはならない
  • スループットが頭打ちになったあと、レイテンシだけが伸び続ける点があること。そこが「限界」で、それ以上の負荷は待ち行列に積まれているだけ
  • 平均は嘘をつくこと。平均が良くても p99 が悪ければ、100人に1人は待たされている
  • p95 まで見ても見逃す遅さがあること。テールレイテンシという言葉
  • 同時数 = スループット × レイテンシ(リトルの法則)が、自分の実測でもちゃんと合うこと
  • 利用率が80%を超えると、待ち時間が急に伸びること。だから余裕をゼロにしてはいけない
  • 打てる手は「レイテンシを縮める」「並列を増やす」「仕事を減らす」の3つしかないこと。症状によって正解が違う
  • 1台を大きくするほうが速いことがあること。分けると通信が生まれ、まとめると通信が消える

この記事でやること

  1. わざと「1本25ミリ秒」のサーバーを立てる。中身が分かっているものを測る
  2. ab で同時接続数を 1 / 10 / 50 / 200 と変えて、スループットと平均レイテンシと p95 を表にする
  3. 同じデータから中央値・p95・p99 を出し、平均が良いのに一部だけ極端に遅い状態を作る
  4. リトルの法則に実測を当てはめて、式が合うことを確かめる
  5. 同時数を細かく上げて、利用率と待ち時間の曲線を測る。80%を超えた先を見る
  6. プロセスを2つにして、レイテンシが1ミリ秒も縮まないことを確認する
  7. 全部消す

先に知る言葉

この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。

言葉意味
レイテンシ1件が始まってから終わるまでの時間。 単位は秒やミリ秒。1人の待ち時間
スループット単位時間に終わる件数。 単位は 件/秒(rps)。全体のさばき量
同時数(並列度)その瞬間、処理の途中にある件数。 ab の -c で指定する数
rpsrequests per second。1秒あたりの処理件数。 スループットの単位
パーセンタイル速い順に並べて、下から何%目か。 p95 は「95%はこれより速い」という時間
中央値(p50)ちょうど真ん中の値。 平均とは違う。半分の人はこれより速い
テールレイテンシ分布の尻尾。 p99 や p99.9 の、ごく一部だけ極端に遅い部分
リトルの法則同時数 = スループット × レイテンシ。待ち行列の一番基本の式
利用率能力のうち、実際に使っている割合。 0.8 なら能力の8割を使っている
待ち行列順番待ちの列。 処理中でも完了でもなく、まだ始まっていない件の集まり
abApache Bench。同時接続数を指定してリクエストを浴びせる測定ツール
スケールアップ / スケールアウト1台を大きくする / 台数を増やす。効く場所が違う

「レイテンシとスループットは別の量」。この一行が、この記事の全部です。

1. レイテンシとスループットは別の量

言葉で並べると、こうです。

レイテンシスループット
何を測るか1件が終わるまでの時間単位時間に終わる件数
単位ミリ秒・秒件/秒(rps)
誰が困るか目の前の1人。「押してから出るまで長い」全体。「混むと落ちる」
良い方向小さいほど良い大きいほど良い
増やして直るか直らない。台数は1件の時間を縮めない直る。これが台数の効くところ
並列度を上げると悪化する上がる(限界まで)

特に最後の行です。

並列度を上げると、スループットは上がるが、レイテンシは悪くなる。

高速道路で考えると分かりやすいです。車を増やせば1時間に通る台数(スループット)は増えます。 でも増やしすぎると渋滞して、1台が端から端まで走る時間(レイテンシ)は伸びます。 そしてある台数から先は、いくら流し込んでも1時間に通る台数は増えません。 増えるのは渋滞の長さだけです。

「遅い」と言われたときに最初にやることは、どっちの話かを確かめることです。

  • 1人が押して待つ時間が長い → レイテンシの問題。台数は効かない
  • 人が増えると急に全員が遅くなる → スループットの問題。台数が効く

私は前者を後者だと思って台数を増やしました。それがこの記事の出発点です。

では、実際に両方が動くのを見ます。

2. 中身の分かっているサーバーを立てる

測り方を覚えるときに、中身の分からないものを測ってはいけません。 数字が出ても、それが正しいのか分からないからです。

だから「1本あたり何をするか」を自分で決めたサーバーを立てます。

bash
$ mkdir -p ~/latency-demo
$ cd ~/latency-demo
$ nano server.js
const http = require('http');

// CPU を ms ミリ秒ぶん使い切る(暗号化やJSONの組み立てのつもり)
function burnCpu(ms) {
  const end = Date.now() + ms;
  while (Date.now() < end) {}
}

// ms ミリ秒待つ(データベースや外部APIの返事を待っているつもり)
function wait(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

const server = http.createServer(async (req, res) => {
  if (req.url === '/api') {
    await wait(20);   // 待つだけ。CPU は使わない
    burnCpu(5);       // CPU を 5ms 使う
    res.end('ok\n');
    return;
  }

  if (req.url === '/tail') {
    if (Math.random() < 0.02) {
      await wait(900);  // 50回に1回だけ、うんと待たされる
    } else {
      await wait(20);
      burnCpu(5);
    }
    res.end('ok\n');
    return;
  }

  res.statusCode = 404;
  res.end('not found\n');
});

server.listen(3000, () => console.log('listening on 3000'));

この2種類の時間の違いが、あとで効いてきます。

部分中身同時に何本できるか
wait(20)待っているだけ。DB や外部APIの返事待ち何本でも同時に待てる。待つのに CPU は要らない
burnCpu(5)CPU を実際に使う1コアにつき1本ずつ。ここが順番待ちになる

つまり 1本のレイテンシは 25ms、1コアで処理できる上限は 1秒 ÷ 5ms = 200件/秒 のはずです。この2つの数字を、あとで実測と突き合わせます。

別のターミナル(VS Code のターミナルをもう1枚でも構いません)で起動します。

bash
$ cd ~/latency-demo
$ node server.js

動いているか、まず1本だけ叩いて確かめます。

bash
$ curl -w ' 実測: %{time_total}秒\n' http://127.0.0.1:3000/api
ok
 実測: 0.026391秒

約26ミリ秒。 設計どおりです。これがこのサーバーの「レイテンシ」で、いま同時数は1です。

node server.js は起動したままにします。 止めると以降の測定が全部失敗します。 止めたいときは、そのターミナルで Ctrl + C です。

3. 同時数を変えて、両方が動くのを見る

測定ツールを入れます。 apache2-utils に入っている ab を使います。Apache 本体は入りません。 測定コマンドだけのパッケージです。

bash
$ sudo apt update
$ sudo apt install -y apache2-utils

入ったか確かめます。

bash
$ ab -V | head -2
This is ApacheBench, Version 2.3 <$Revision: 1913912 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/

打ち方

bash
$ ab -n 1000 -c 10 http://127.0.0.1:3000/api
オプション意味
-n 1000合計1000本投げる
-c 10同時に10本を維持する。1本返ってきたら、すぐ次の1本を出す
URL の末尾パスまで必ず書く。http://127.0.0.1:3000 だけだと ab が拒否します

-c は「1秒に10本投げる」ではありません。 「常に10本を処理中にしておく」という意味です。この違いが、あとの利用率の話で効いてきます。

出力のうち、見るのはこの4行です。

Requests per second:    192.31 [#/sec] (mean)
Time per request:       52.00 [ms] (mean)
Time per request:       5.200 [ms] (mean, across all concurrent requests)
  95%     58
行何の数字か
Requests per secondスループット。1秒に何本終わったか
1つ目の Time per requestレイテンシ。1本が始まってから終わるまで
2つ目の Time per request1本出てくる間隔。1000 ÷ スループット と同じ。レイテンシではない
95%p95。95%のリクエストはこの時間以内に終わった

Time per request が2行あって、意味が違います。 ここを取り違えると全部おかしくなります。 1つ目が「1人の待ち時間」、2つ目が「行列の出口から1本出る間隔」です。

4回まとめて測る

1回ずつ打ってもいいのですが、間違えるのでまとめて回します。

bash
$ for c in 1 10 50 200; do
$   echo "=== 同時数 $c ==="
$   ab -q -n 2000 -c $c http://127.0.0.1:3000/api \
      | grep -E 'Requests per second|Time per request|Failed requests|^  95%'
$ done

-q は途中経過を出さないオプションです。-n 2000 は -c 200 より十分大きくします。 同時数より合計数が少ないと測定になりません。

=== 同時数 1 ===
Failed requests:        0
Requests per second:    40.02 [#/sec] (mean)
Time per request:       24.99 [ms] (mean)
Time per request:       24.988 [ms] (mean, across all concurrent requests)
  95%     26
=== 同時数 10 ===
Failed requests:        0
Requests per second:    192.11 [#/sec] (mean)
Time per request:       52.05 [ms] (mean)
Time per request:       5.205 [ms] (mean, across all concurrent requests)
  95%     58
=== 同時数 50 ===
Failed requests:        0
Requests per second:    198.24 [#/sec] (mean)
Time per request:       252.22 [ms] (mean)
Time per request:       5.044 [ms] (mean, across all concurrent requests)
  95%    271
=== 同時数 200 ===
Failed requests:        0
Requests per second:    199.05 [#/sec] (mean)
Time per request:       1004.77 [ms] (mean)
Time per request:       5.024 [ms] (mean, across all concurrent requests)
  95%   1062

[スクリーンショット: 01_ab_同時数4段階.png] 上の for ループを実行し、同時数 1 / 10 / 50 / 200 の4ブロックが並んで出ている画面を撮ってください。

表に直します。

同時数スループット(rps)平均レイテンシp95
140.025 ms26 ms
10192.152 ms58 ms
50198.2252 ms271 ms
200199.11005 ms1062 ms

数字はマシンによって変わります。 見るのは絶対値ではなく、列ごとの動き方です。

何が起きているか

スループットの列を上から見ます。

40 → 192 → 198 → 199

10 までは 5倍近く伸びました。 そのあとはほとんど動いていません。 200 まで増やしても 199 です。

レイテンシの列を上から見ます。

25ms → 52ms → 252ms → 1005ms

こちらは止まりません。 最後は最初の40倍です。

スループットが頭打ちになったあとも、レイテンシだけが伸び続ける。 この折れ曲がるところが「限界」です。

限界を超えたあとに増やした同時数は、1件も余計にさばいていません。 全部待ち行列に積まれているだけです。積まれたぶんだけ、1人あたりの待ち時間が長くなります。

さっきの設計と突き合わせます。

  • burnCpu(5) は 1コアで 5ms。上限は 200件/秒 → 実測 199 合っています
  • 同時数1のレイテンシは wait(20) + burnCpu(5) = 25ms → 実測 25 合っています

中身が分かっているものを測ると、こういう答え合わせができます。

「限界」より前で止めるのが運用

この表を見たとき、私は最初「200 rps 出るサーバーだ」と思いました。違います。

  • 同時数 200 のとき、確かに 199 rps 出ています。
  • でもそのとき、利用者は1秒待たされています。

「出る」と「使える」は別です。 さばけているが、誰も待てない状態を「限界まで使えている」とは言いません。

この表で言えば、実用になるのは同時数10のあたりまでです。そこで 192 rps 出ていて、レイテンシはまだ 52ms です。そこから先は、スループットがほとんど増えないのに待ち時間だけが増える取引になります。

4. 平均を信じない

さっきの表の「平均レイテンシ」は、全部を足して件数で割った数です。これがよく嘘をつきます。

用意しておいた /tail を叩きます。 50回に1回だけ 900ms かかる以外は、/api と同じサーバーです。同時数は1にして、行列の影響を消して測ります。

bash
$ ab -n 2000 -c 1 http://127.0.0.1:3000/tail

出力の後半、パーセンタイルの表まで全部読みます。

Requests per second:    23.41 [#/sec] (mean)
Time per request:       42.71 [ms] (mean)

Connection Times (ms)
              min  mean[+/-sd] median   max
Total:         24   42 149.6      25     912

Percentage of the requests served within a certain time (ms)
  50%     25
  66%     25
  75%     26
  80%     26
  90%     26
  95%     27
  98%    901
  99%    903
 100%    912 (longest request)

[スクリーンショット: 02_ab_パーセンタイル.png] ab -n 2000 -c 1 http://127.0.0.1:3000/tail を実行し、Percentage of the requests served within a certain time の表が全部写っている画面を撮ってください。

同じ1回の測定から出た数字を並べます。

指標値意味
平均42.7 ms全部を足して割った値
中央値(p50)25 msちょうど真ん中の人の待ち時間
p9527 ms95%はこれより速い
p99903 ms100人に1人は、ここまで待っている
最大912 ms一番運が悪かった1本

平均は「誰の体験でもない」

平均は 42.7ms でした。 でも、

  • 42.7ms くらいで返ってきた人は、ほとんどいません。 ほぼ全員が 25ms か 900ms のどちらかです
  • 中央値は 25ms。 半分の人は、平均よりずっと速い
  • p99 は 903ms。 100人に1人は、平均の20倍待っている

平均は、速い人と遅い人を混ぜて薄めた数字です。 「平均は良好です」という報告は、100人に1人が0.9秒待っていることを隠せます。

そして逆方向にも嘘をつきます。もし遅いのが5%あったら、平均は 68ms に跳ね上がります。 すると今度は「全体が遅い」と読めてしまいますが、95%の人は25msのままです。 どちらに転んでも、平均だけでは何が起きているか分かりません。

p95 まで見ても、見逃す

この測定の p95 は 27ms です。 これだけ見ると、何の問題も無いように見えます。

遅いのが全体の2%しかないからです。 2%の遅さは、下から95%目には届きません。 届くのは98%目からです。

「遅いのが何%あるか」より細かいところまで見ないと、テールは見えません。

遅いのが全体のp95に出るかp99に出るか
10%出る出る
5%ぎりぎり出る出る
2%出ない出る
0.5%出ない出ない(p99.9 が要る)

この尻尾の部分を「テールレイテンシ」と呼びます。

そして、テールは思っているより多くの人に当たります。 1画面を出すのに API を10本叩いていたら、そのうち1本でも遅ければ画面は遅いからです。1本あたり1%の確率なら、10本のうちどれかが遅い確率は約10%です。p99の遅さが、10人に1人の体験になります。

だからテールは「例外」ではなく、「普通に起きること」として扱います。

見る数字は、最低この3つです。

見るもの何が分かる
p50(中央値)普通の人の体験
p95混雑や重い処理が全体に効いているか
p99見捨てている人がいないか

平均は、この3つを見たあとに参考として見ます。最初に見る数字ではありません。

5. リトルの法則 — 実測が式に合う

さっきの表には、隠れた規則があります。

同時数 = スループット × レイテンシ

リトルの法則といいます。行列に並んでいる人数は、1秒に入る人数と、1人が並んでいる時間の掛け算になる、というだけの式です。当たり前に見えますが、これが必ず成り立ちます。

山場①の実測を、そのまま入れてみます。 レイテンシは秒に直します。

同時数スループットレイテンシ掛け算の結果
140.00.0251.00
10192.10.0529.99
50198.20.25249.9
200199.11.005200.1

左の列と、右の列が一致しました。

これが分かると、3つの数字のうち2つを測れば、残りが決まります。

分かっているもの出せるもの
スループットとレイテンシその瞬間、何本が処理の途中にあるか
同時数と目標レイテンシ必要なスループット。「200人が同時に使って、200ms以内に返す」なら 200 ÷ 0.2 = 1000 rps 要る
スループットの上限と目標レイテンシ受け付けてよい同時数。これを超えたぶんは待たせるだけ

「200人同時に使えるようにしたい」と言われたときに、じゃあ何 rps 必要なのかを出せる、というのが実務での使いどころです。そして式が合わないときは、どこかの測り方が間違っています。

注意: この式は落ち着いている間(入ってくる量と出ていく量が釣り合っている間)に成り立ちます。測り始めの数秒や、限界を超えて行列が伸び続けている最中は合いません。

6. 利用率が80%を超えると崩れる

山場①では 1 / 10 / 50 / 200 と大きく飛ばしました。 今度は1から10まで細かく上げて、折れ曲がる瞬間を見ます。

bash
$ for c in 1 2 3 4 5 6 8 10 20 50; do
$   printf '%4s ' "$c"
$   ab -q -n 1500 -c $c http://127.0.0.1:3000/api \
      | grep -E 'Requests per second|Time per request: .*\(mean\)$' \
      | tr -s ' ' | tr '\n' ' '
$   echo
$ done
   1 Requests per second: 40.01 [#/sec] (mean) Time per request: 24.99 [ms] (mean)
   2 Requests per second: 76.93 [#/sec] (mean) Time per request: 26.00 [ms] (mean)
   3 Requests per second: 115.02 [#/sec] (mean) Time per request: 26.08 [ms] (mean)
   4 Requests per second: 148.11 [#/sec] (mean) Time per request: 27.01 [ms] (mean)
   5 Requests per second: 172.30 [#/sec] (mean) Time per request: 29.02 [ms] (mean)
   6 Requests per second: 183.02 [#/sec] (mean) Time per request: 32.78 [ms] (mean)
   8 Requests per second: 190.11 [#/sec] (mean) Time per request: 42.08 [ms] (mean)
  10 Requests per second: 192.11 [#/sec] (mean) Time per request: 52.05 [ms] (mean)
  20 Requests per second: 198.02 [#/sec] (mean) Time per request: 101.00 [ms] (mean)
  50 Requests per second: 198.24 [#/sec] (mean) Time per request: 252.22 [ms] (mean)

利用率を出します。 このサーバーの上限は測って 200 rps でした。利用率 = そのときのスループット ÷ 200 です。 そして待ち時間 = 実測レイテンシ − 25ms(本来の仕事の時間)です。

同時数スループット利用率レイテンシ待ち時間
1400.2025 ms0 ms
2770.3826 ms1 ms
31150.5826 ms1 ms
41480.7427 ms2 ms
51720.8629 ms4 ms
61830.9233 ms8 ms
81900.9542 ms17 ms
101920.9652 ms27 ms
201980.99101 ms76 ms
501980.99252 ms227 ms

待ち時間の列だけを縦に見ます。

0 → 1 → 1 → 2 → 4 → 8 → 17 → 27 → 76 → 227

利用率が 0.74 までは、待ち時間はほぼ0です。 そこから先が違います。

利用率の区間待ち時間の伸び
0.20 → 0.740 → 2 ms。ほぼ増えない
0.74 → 0.862 → 4 ms。倍になる
0.86 → 0.954 → 17 ms。4倍
0.95 → 0.9917 → 76 ms。さらに4倍

利用率が上がるほど、待ち時間の増え方が急になります。 80%を超えたあたりから、グラフは壁のように立ち上がります。

理由は難しくありません。 利用率が 0.5 なら、リクエストが来たとき半分の確率で誰も使っていません。 利用率が 0.99 なら、ほぼ必ず誰かが使っていて、しかもその前にも並んでいます。 空きが出るまでの時間が、空きの少なさに反比例して伸びます。

だから、余裕をゼロにしない

CPU使用率 50% のサーバーを見て「半分も遊んでいる、もったいない」と思ったことがあります。 遊んでいません。それは待ち時間をゼロに保つための余裕です。

利用率を 50% から 95% に上げると、コストは半分になりますが、待ち時間は10倍以上になります。

そして、この曲線は「平均して80%」でも安全ではありません。 利用率は瞬間で動くからです。平均80%は、瞬間的に100%を何度も踏んでいることがあります。そのたびに行列ができ、テールが伸びます。

目安として、こう考えます。

平常時の利用率状態
〜50%安全。 急な倍増にも耐える
50〜70%通常運転。ここを狙う
70〜80%注意。 増設の準備を始める
80%〜待ち時間が急に伸びる領域。 ここに常駐させない

この曲線を知らないと、「まだ余裕がある」と思っていた状態から、何の前触れもなく全体が遅くなったように見えます。 前触れは出ていました。待ち時間のほうに出ていて、利用率のほうには出ていなかっただけです。

本線の 「遅い」の次は「どこが」 — 分散トレーシング入門 や Prometheusは取りに行く — 監視とログの入口 で監視の道具を入れました。 そこで p95 と p99 を必ずグラフにしておく理由が、これです。 平均だけを出しているダッシュボードは、この立ち上がりを最後まで隠します。

7. どこを直すか — 打てる手は3つしかない

測ったら、次は直します。打てる手は、突き詰めると3種類です。

手何をするか効くもの効かないもの
① レイテンシを縮める1本あたりの仕事を速くする。 索引を張る、無駄な往復を減らすレイテンシ。そして同時にスループットも上がる—
② 並列を増やすプロセス・コア・台数を増やすスループットレイテンシ。1本の時間は1ミリ秒も縮まない
③ 仕事を減らすそもそも処理しない。 結果を使い回す、返す量を減らす、断る両方—

症状から選びます。

症状測ったときの見え方打つ手
1人で使っても遅い同時数1でもレイテンシが大きい①だけ。 ②は完全に無駄
人が増えると全員遅い同時数を上げるとスループットが頭打ち②、または③
たまに遅い人がいるp50は良いが p99 が悪い①(遅い経路を探す)と③
全部が均等に遅いp50 も p99 も同じくらい悪い①。 全リクエストが通る共通部分が遅い
落ちるFailed requests が増える③(受ける量を制限する)が先。増設は間に合わない

①が最優先です。 理由は表の右上にあります。レイテンシを縮めると、スループットも一緒に上がるからです。

このサーバーで確かめられます。 burnCpu(5) を burnCpu(2) に書き換えれば、上限は 200 rps から 500 rps に上がります。1本の時間を縮めただけで、さばける量が2.5倍になりました。 ②では絶対にこうなりません。

「1本の仕事を軽くする」は、レイテンシとスループットの両方に効く唯一の手です。 台数を増やす前に、必ずこちらを先に試します。

そして③を忘れないことです。 一番速い処理は、やらない処理です。返すデータを減らす、1画面で10本叩いていた API を1本にする、要らない項目を返さない。どれもコードの難しさは増えません。

8. スケールアップとスケールアウト

②の「並列を増やす」には、2つのやり方があります。

スケールアップスケールアウト
やること1台を大きくする(コアを増やす・速いCPUにする)台数を増やす
上限ある。買える一番大きいマシンまで理屈の上では無い
アプリの改修要らないことが多い要ることが多い(状態の置き場所を外に出す)
1台壊れたら全部止まる残りで続く
通信増えない増える。ここが落とし穴

まず、増やしてもレイテンシは縮まないことを確認する

Node は1プロセス1コアです。 プロセスを2つにしてみます。ここから先は2コア以上の VM が前提です。 nproc で確かめてください(1コアだと、プロセスを2つにしても上限は増えません)。

bash
$ nano ~/latency-demo/cluster.js
const cluster = require('cluster');
const os = require('os');

if (cluster.isPrimary) {
  const n = Number(process.argv[2] || os.cpus().length);
  console.log(`ワーカーを ${n} 個起動します`);
  for (let i = 0; i < n; i++) cluster.fork();
} else {
  require('./server.js');
}

さっきの node server.js を Ctrl + C で止めてから、こちらを起動します。

bash
$ cd ~/latency-demo
$ node cluster.js 2
ワーカーを 2 個起動します
listening on 3000
listening on 3000

同じ 3000 番を2つが待ち受けています。 OS が来た接続を振り分けます。

bash
$ for c in 1 50; do
$   echo "=== 同時数 $c ==="
$   ab -q -n 2000 -c $c http://127.0.0.1:3000/api \
      | grep -E 'Requests per second|Time per request: .*\(mean\)$'
$ done
=== 同時数 1 ===
Requests per second:    39.96 [#/sec] (mean)
Time per request:       25.02 [ms] (mean)
=== 同時数 50 ===
Requests per second:    385.44 [#/sec] (mean)
Time per request:       129.72 [ms] (mean)

1つのときと並べます。

プロセス1つプロセス2つ
同時数1のレイテンシ25 ms25 ms(変わらない)
同時数50のスループット198 rps385 rps(ほぼ倍)
同時数50のレイテンシ252 ms130 ms(半分)

読み方を間違えないでください。

  • 同時数1のレイテンシは1ミリ秒も変わっていません。 並列を増やしても、1本の仕事は速くなりません
  • 同時数50でレイテンシが半分になったのは、行列が半分になったからです。 待ち時間が減っただけで、仕事の時間は 25ms のままです

並列を増やして縮むのは「待ち時間」だけ。「仕事の時間」は絶対に縮みません。

リトルの法則でも確認できます。 385 × 0.130 = 50.05。ちゃんと合います。

分けると通信が生まれる

では、2つのプロセスを2台の VM に分けたらどうなるか。 さばける量は同じですが、新しく通信が生まれます。

その通信がいくらかかるか、測れます。

bash
$ ping -c 5 127.0.0.1
5 packets transmitted, 5 received, 0% packet loss, time 4102ms
rtt min/avg/max/mdev = 0.028/0.041/0.055/0.010 ms

VM から、同じ LAN にいる別の機械(Windows 本体でも、ルーターでも構いません)へ。IPアドレスは自分の環境のものに置き換えてください。

bash
$ ip route | grep default
default via 192.168.1.1 dev ens33 proto static
bash
$ ping -c 5 192.168.1.1
5 packets transmitted, 5 received, 0% packet loss, time 4005ms
rtt min/avg/max/mdev = 0.412/0.588/0.844/0.152 ms
どこへ往復
同じ機械の中(127.0.0.1)0.04 ms
同じ LAN の別の機械0.59 ms

1回あたり 0.55ms の差です。小さく見えます。 ただし、

  • 1画面を出すのに内部で 20 回呼び合っていたら、+11ms
  • クラウドで別のゾーンに置いたら、1回 1〜2ms。20回で +20〜40ms
  • これは行列とは無関係に、常に乗ります。 空いていても乗ります

だから「1台を大きくするほうが速い」ことがあります。 まとめると、その通信が全部消えるからです。

私が最初にやった「プロセスを3つに増やした」も、これでした。 1コアの VM で3つに分けたので、さばける量は増えず、切り替えと通信だけが増えたわけです。測っていれば、増やす前に分かりました。

選び方の目安です。

状況選ぶもの
同時数1でも遅いどちらでもない。 ①(1本を速くする)へ戻る
コアがまだ余っているスケールアップ。プロセス数を増やすだけで済む
1台の上限に近いスケールアウト。ただし状態の置き場所を先に外へ出す
止まると困るスケールアウト。速さではなく壊れても続くため
内部の呼び合いが多い分けない。 分けた回数だけレイテンシが増える

本線の 障害対応は切り分けの順番がすべて — わざと壊して直す でやったとおり、「壊れても続く」ためのスケールアウトは速さの話とは別の目的です。 同じ「台数を増やす」でも、理由が違えば止め時も違います。

VPSで言えば、プランを上げてコア数やメモリを増やすのがスケールアップ、同じプランを台数分借りるのがスケールアウトです。さくらのVPSは512MB(1コア)から段階的にプランが並ぶ国産VPSで、2026年11月時点の公式表示では1GB(2コア・50GB)が月払い880〜990円、2GB(3コア・100GB)が1,738〜1,958円(税込、リージョンで異なる)なので、同時数を変えながらどちらが効くかを小さく試せます。

つまずいたところ

apr_socket_recv: Connection reset by peer (104)

同時数 200 で出ました。 測定が途中で止まります。

apr_socket_recv: Connection reset by peer (104)

サーバーが受け止めきれず、接続を切っています。 私は最初「200 rps が限界なんだな」と読みましたが、違います。 これは処理の限界ではなく、接続を待たせておく列の限界です。

server.listen(3000) の待ち受け列は既定で 511 件です。それを超えると切られます。測定のときは同時数を段階的に上げて、切られない範囲で測ります。 どうしても必要なら listen の第2引数で列を広げられますが、それは「限界の測り方」を変えているだけで、サーバーが速くなったわけではありません。

開いているファイルが足りない

同時数を大きくすると、こちらも出ます。

socket: Too many open files (24)

ab 側の上限です。 いま何本まで開けるかを見ます。

bash
$ ulimit -n
1024

そのターミナルの中だけなら、一時的に上げられます。

bash
$ ulimit -n 4096

恒久的に変えるなら /etc/security/limits.conf を触ることになりますが、この記事のためだけに触る必要はありません。 ターミナルを閉じれば元に戻る、いまの方法で十分です。

ab を同じ VM で動かしている

測定ツールも CPU を使います。 同じ VM でサーバーと ab を両方動かすと、測定ツールがサーバーの CPU を奪います。 つまり上限が実際より低く出ます。

この記事の数字も、その影響を受けています。 傾向を見るには十分ですが、「このサーバーは何 rps 出るか」を確定させる用途には使えません。 本番の数字が必要なときは、測定する側を別の機械に置きます。

1回目の測定だけ遅い

最初の1回は、たいてい他より遅く出ます。接続の確立や、実行の最適化が済んでいないからです。 1回捨てるか、-n を大きくして影響を薄めます。 私は「直したのに遅くなった」と何度か勘違いしました。

Time per request を取り違えた

冒頭で書いたとおり、2行あります。 私は最初、下の行(5.2ms)を見て「速い」と喜びました。 あれは1本の待ち時間ではなく、行列の出口から1本出てくる間隔です。利用者が待つのは上の行(52ms)のほうです。

hey を使いたいとき

ab は「常に N 本を処理中にする」やり方(クローズドループ)しかできません。 「1秒に N 本流し込む」(オープンループ)を試したいときは hey を使います。まず apt にあるか確かめます。

bash
$ apt-cache policy hey

候補が出れば sudo apt install -y hey で入ります。 無ければ配布元(下の参考リンク)から取ってくることになります。この記事の内容は ab だけで全部再現できるので、無理に入れる必要はありません。

後片づけ

サーバーを止めます。 起動しているターミナルで Ctrl + C です。別のターミナルからなら、こうします。

bash
$ pkill -f 'node cluster.js'
$ pkill -f 'node server.js'

止まったか確かめます。何も出なければ止まっています。

bash
$ pgrep -af 'node .*\.js'

3000番が空いたことも見ておきます。

bash
$ ss -ltnp | grep 3000

作ったファイルを消します。

bash
$ rm -rf ~/latency-demo

apache2-utils は残しておくことをおすすめします。 数十MBで、これから何かを直すたびに使います。消したいときは、こうです。

bash
$ sudo apt remove -y apache2-utils

まとめ

この記事で理解できたことを並べます。

  • 「遅い」には2つの意味がある。 1件が終わるまでの時間(レイテンシ)と、単位時間に終わる件数(スループット)は別の量
  • 並列度を上げるとスループットは上がるが、レイテンシは悪化する。 同時に良くはならない
  • 同時数を上げていくと、スループットが頭打ちになる点がある。 その先で増えるのは待ち時間だけで、1件も余計にさばいていない
  • 「出る」と「使える」は違う。 限界の手前で止めるのが運用
  • 平均は嘘をつく。 平均42msの裏で、100人に1人が903ms待っていた
  • p95まで見ても、2%の遅さは見つからない。 尻尾(テール)は p99 以降に出る
  • 同時数 = スループット × レイテンシ。 実測でもきっちり合った。2つ測れば3つ目が決まる
  • 利用率が80%を超えると、待ち時間の伸び方が急になる。 余裕は無駄ではなく、待ち時間を抑えるための設備
  • 打てる手は「1本を速くする」「並列を増やす」「仕事を減らす」の3つ。 1本を速くするのだけが、両方に効く
  • 並列を増やして縮むのは待ち時間だけ。 同時数1のレイテンシは1ミリ秒も変わらなかった
  • 分けると通信が生まれ、まとめると消える。 だから1台を大きくするほうが速いことがある

最初の失敗に戻ります。

「遅い」と言われて台数を増やした。測っていたのはレイテンシで、台数はスループットにしか効かなかった。

測る前に手を打つと、こうなります。 測っていれば、同時数1でも遅いことが1コマンドで分かりました。 そのときの正解は「1本の仕事を速くする」であって、台数ではありませんでした。

この記事で覚えるコマンドは、実質1本だけです。

bash
$ ab -n 1000 -c 1 http://127.0.0.1:3000/api

同時数1で測る。 それが遅ければ、台数の話は始まりません。

参考リンク


次に読む

この記事は 【深掘り】システム設計 の 2 / 17 本目です。

記事
← 前の記事設計の進め方と容量見積もり — 図ではなく数から始める
→ 次の記事ロードバランサと振り分け方式 — 3台なのに偏る

上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。

全体の順路は はじめに にあります。

roadmap.sh のどこをやっているか

System Design›System Design — Performance
  • レイテンシとスループットは別の量
  • p95 / p99 とリトルの法則

この記事は、上の項目を実際に手を動かして確かめる回です。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次