HN 日本語サマリー

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

Goにおけるゼロコピー:sendfile、splice、そしてio.Copyのコスト

Zero-copy in Go: sendfile, splice, and the cost of io.Copy (segflow.github.io)

57 pointsby mrngm10 コメント

要約

Go言語でファイルサーバーを運用する際、`io.Copy`の内部実装がカーネルレベルのゼロコピー最適化(`sendfile`や`splice`)をどのように利用するか、また、どのような場合にその最適化が失われるかについて解説しています。`*os.File`を直接渡す場合は最適化が適用されますが、`io.Reader`でラップするとカーネルとユーザー空間間のデータコピーが発生し、CPU使用率とレイテンシが増加するコストについて具体例を挙げて説明しています。

全文翻訳

Goにおけるゼロコピー: sendfile, splice、そしてio.Copyのコスト

ある日、私の小さなファイルサービングサービスが、無害なミドルウェアの変更後にパフォーマンスの低下に見舞われました。サーバーのCPU使用率は倍増し、スループットは約半分になりました。変更点は1行だけでした。io.Copyに*os.Fileを渡す代わりに、誰かがバイト数をカウントするためにそれを小さなロギングリーダーでラップしたのです。

その1つのラップが、静かにsendfile(2)を無効にしてしまいました。

この記事では、その高速パスについて説明します。Goが無料で提供してくれるもの、それが実際に機能していることを確認する方法、そしてそれを失う驚くほど簡単な方法についてです。

セットアップ

  • Linux 6.6 / Ubuntu 24.04 (WSL2), AMD Ryzen 5 9600X, 16 GiB RAM
  • Go 1.22.12
  • 512 MiBのランダムバイトファイル、ページキャッシュウォーム

以下の各ベンチマークでは、同じbig.binファイルを、同じマシン上のGoクライアントにプレーンTCPで提供します。サーバーはCPU 0に、クライアントはCPU 1にピン留めし、サーバー側で/usr/bin/timeを読み取って、リンゴとリンゴを比較できるようにします。システムコールのカウントは、バニラのstrace -c -e trace=read,write,sendfile,spliceから取得します。

sendfileの実際の動作

通常の「このファイルを送信する」処理は以下のようになります。

disk -> page cache -> user bufferへのread() -> socket bufferへのwrite() -> NIC
                          ^ copy 1                 ^ copy 2

sendfile(2)は、これらの2つのコピーを1つのカーネル内転送に集約します。

disk -> page cache --(sendfile)--> socket buffer -> NIC
                       ^ userspaceへの往復なし

readもwriteもなく、32 KiBのバッファがアドレス空間を往復することもありません。カーネルはページキャッシュのページをソケットの送信キューに直接スプライスするだけです。ソケット間転送の場合は、同等の機能がsplice(2)であり、これはユーザーメモリに具体化することなくカーネルパイプを介してバイトを移動します。

Goでは、これらのいずれかを直接呼び出すことはありません。標準ライブラリが、可能な場合にそれを行ってくれます。

高速パス

Goランタイムは*net.TCPConnにReadFromメソッドを提供します。あなたが以下のように書くと、

io.Copy(conn, f)

io.Copyは、宛先がio.ReaderFromを実装しているかを確認します。*net.TCPConnは実装しているので、呼び出しはそのReadFromメソッドにディスパッチされます。そのメソッドの最初の仕事は、ソースを見ることです。それは*os.Fileですか?それは*os.Fileをラップした*io.LimitedReaderですか?もしそうなら、internal/poll.SendFileが呼び出され、ファイルがなくなるまでsendfile(2)をループします。

この検出チェーン全体は、net/sendfile_linux.goとos/zero_copy_linux.goの2つのファイルに存在します。おおよそ以下のようになります。

// (簡略化、net/sendfile_linux.go内)
lr, ok := r.(*io.LimitedReader)
if ok { remain, r = lr.N, lr.R }
f, ok := r.(*os.File)
if !ok { return 0, nil, false } // フォールバック
// ... sendfileループ ...

2つの型アサーションと1つのシステムコールループです。

3つのハンドラー、1つのファイル

比較したい3つのリーダーの形状を以下に示します。3つすべてが同じ512 MiBファイルをプレーンTCPで提供します。唯一の違いは、io.Copyに渡されるものです。

// raw: io.Copyに直接*os.Fileを渡す。
_, _ = io.Copy(conn, f)

// wrapped: *os.Fileを「単なるio.Reader」構造体の後ろに隠す。
type justReader struct{ r io.Reader }
func (j justReader) Read(p []byte) (int, error) { return j.r.Read(p) }
_, _ = io.Copy(conn, justReader{r: f})

// limit: *io.LimitedReaderでラップする。ランタイムが検出する唯一のラッパー。
_, _ = io.Copy(conn, io.LimitReader(f, fileSize))

justReaderは何もしません。これは、「バイト数をカウントしたいだけ」や「トレーススパンを注入したいだけ」といった、ファイルの前方にio.Readerを滑り込ませるための最小限のミドルウェアの例です。型システムに関しては、値はもはやio.Readerであり、それ以上ではありません。ランタイムの*os.Fileに対する型スイッチは失敗し、最適化は失われます。

io.LimitReaderも同様にラップしているように見えますが、ランタイムはギブアップする前に*io.LimitedReaderを明示的にチェックし、それをアンラップして続行します。したがって、高速パスを維持します。

straceでの監視

各ハンドラーをstrace -c -e trace=read,write,sendfile,spliceで実行し、512 MiBの転送を5回実行し、サマリーを確認します。

raw (io.Copy(conn, f)):

% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 99.79    0.231981          78      2958       860 sendfile
  0.15    0.000359          51         7         1 write
  0.05    0.000126          18         7           read
------ ----------- ----------- --------- --------- ----------------
100.00    0.232466          78      2972       861 total

2,958回のsendfile呼び出し、7回のread、7回のwrite。readとwriteはファイルデータではなく、受け入れ/セットアップのチャッターです。860の「エラー」は、ソケットバッファがいっぱいでランタイムポーラーがバックバウンスした際のEAGAINリターンであり、sendfile下では正常です。

wrapped (io.Copy(conn, justReader{f})):

% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 56.67    3.202339          48     65546         3 write
 43.33    2.448353          37     65547           read
------ ----------- ----------- --------- --------- ----------------
100.00    5.650692          43    131093         3 total

sendfileはゼロ。約13万回のreadとwriteシステムコールが組み合わされており、すべて32 KiBチャンクがデータをユーザー空間バッファにバウンスしています。この32 KiBという数値はio.copyBufferのデフォルト値です。システムコールで費やされた実時間は、高速パスの約24倍です。

負荷下でのラップされたハンドラーのCPUプロファイルは、呼び出しチェーンを明確にします。

[画像: CPU flamegraph: wrapped reader spending time in userspace copy]

実行中に収集された1,670のCPUサンプルのうち、1,362(約82%)はシステムコール内でした。ソケットへの書き込みでsyscall.Writeに761、ファイルから次の32 KiBをプルするsyscall.Readに522です。すべてのホットスタックの最上部にあるフレームシーケンスはio.Copy -> io.copyBuffer -> (*TCPConn).ReadFrom -> readFrom -> io.Copy -> io.copyBuffer -> ...です。このネストされたio.copyBufferがそのシグネチャです。*TCPConn.readFromはsendfileに渡す*os.Fileを見つけられなかったので、その作業をio.copyBufferに投げ返し、io.copyBufferが手動でバウンスを行っています。フレイムグラフは、そのバウンスの各サイクルの行き先を示しています。

limit (io.Copy(conn, io.LimitReader(f, n))):

% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 99.84    0.239191          82      2896       893 sendfile
  0.14    0.000330          47         7         1 write
  0.02    0.000047           6         7           read

rawと区別がつかない。2,896回のsendfile。LimitReaderのラップは無料です。なぜなら、ランタイムはその特定の型を認識しているからです。

コスト

ループバックスループットは誤解を招く数値です。レシーバーとTCPバッファが多くのものを吸収するため、壁時計時間はすべての3つのモードで似たように見えます(リクエストあたり1.5〜1.7 GiB/s)。より正直な測定値は、ファイルを送信するためのサーバー自身のCPU時間です。

modeserver user+sys CPU (10 x 512 MiB)per-GiB CPU
raw0.27 s~54 ms
wrapped0.92 s~184 ms
limit0.30 s~60 ms

ラップされたパスは、バイトあたりのCPUコストが約3.4倍になります。ローカルホストではこれは吸収されますが、実際のネットワークや同時負荷下ではコアを占有し、テールレイテンシを低下させます。同じ2.5 GiBを移動するために、131,093回のシステムコールではなく2,972回のシステムコールであることは、「io.Readerが欲しいだけ」と言うことのコストです。

同じデータを、消費されたサーバーCPUの1秒あたりのペイロード出荷MiBとして逆に見ると、ギャップが際立ちます。

[画像: Throughput: raw sendfile vs wrapped vs manual copy (higher is better)]

ソケット間転送のためのsplice

sendfileはファイルからソケットへの転送です。対称的なケースはソケットからソケットへの転送であり、プロキシが一日中行っていることです。そこでは、ランタイムは代わりにsplice(2)を使用します。30行のTCPプロキシ:

ln, _ := net.Listen("tcp", ":9100")
for {
    c, _ := ln.Accept()
    go func(client net.Conn) {
        defer client.Close()
        server, _ := net.Dial("tcp", upstream)
        defer server.Close()
        go io.Copy(server, client)
        io.Copy(client, server)
    }(c)
}

2回のio.Copy呼び出し、どちらも*net.TCPConn間です。プロキシを介した1回の転送をstraceで確認してください。

% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 99.98    0.754999          70     10677       481 splice
  0.01    0.000109          13         8           read
  0.01    0.000065          65         1           write

10,677回のsplice呼び出し。データパスでのreadまたはwriteはゼロ。プロキシはバイトに一切触れません。(*TCPConn).readFromはソースを見て、別の*TCPConnを見て、spliceFromにディスパッチします。同じ脆弱性のルールが適用されます。どちらかの側を独自のio.Readerまたはio.Writerでラップすると、32 KiBのバウンスにフォールバックします。

実践的なルール

この騒動の原因となったファイルサーバーから得たいくつかの教訓です。

避けられるならラップしない。 ファイルと接続の間にio.Readerのレイヤーが1つ増えるごとに、型アサーションによって高速パスから外れる可能性があります。ランタイムは*os.File、*io.LimitedReader、および少数の*net.TCPConn形状の型しか認識しません。それ以外は不透明です。

ラップする必要がある場合は、オプションインターフェースを保持する。 (ソースをラップする場合に)io.WriterToまたは(宛先をラップする場合に)io.ReaderFromを実装し、フォワードするラッパーは、io.Copyが最後までディスパッチし続けることができます。正しく実装するのは少し手間がかかりますが、標準ライブラリはそれを日常的に行っています。

io.LimitReaderは無料、それ以外はそうではない。 範囲指定されたレスポンスの場合、これは手を伸ばすべきラップです。これはhttp.ServeContentがRangeリクエストに対してsendfileをアクティブに保つ方法です。

strace -cを信頼し、直感を信じない。 2回のsendfileカウントとゼロ回のwriteは、高速パスに乗っていることを意味します。数十万回のread+writeペアは、そうではないことを意味します。中間はありません。

sendfileが常に到達可能であると仮定しない。 別の記事で紹介する驚き:テキストブックのio.Copy(w, f)でさえ、http.ResponseWriterに対して、あなたのコードとは関係のない理由でsendfileを迂回する可能性があります。原則は同じですが、トリガーはハンドラーではなく、フレームワークに隠されています。

sendfileとspliceは古く、退屈なカーネルAPIであり、Goではほとんど手を出す必要がありません。ランタイムがほとんどの場合、無料でそれを行ってくれます。トリックは、それが真実であり続けるために何をそのままにしておくかを知ることです。straceがゼロコピーを期待していた場所でread/writeスパムを示す場合、原因はほとんどの場合、誰かが最善の理由で追加した無害なラッパーです。

そして、sendfileでさえ十分でない場合、ファイルをアドレス空間にマッピングしてカーネルがコピーする必要がないようにしたい場合、ユーザー空間に進みます。しかし、それは別の話です。