HN 日本語サマリー

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

unsafe を使った Go の境界チェックの排除

Eliminating Go bounds checks with unsafe (blog.andr2i.com)

39 pointsby abnercoimbre18 コメント

要約

この記事では、Go のランタイム境界チェックを排除する方法について解説しています。境界チェックはコードの安全性を提供しますが、パフォーマンスのボトルネックになることがあります。特にホットパスでは、`unsafe` パッケージのポインタ演算を利用して、コンパイラが自動的に削除できない境界チェックをプログラム側で安全に排除する方法が紹介されています。これにより、コードの実行速度が向上し、CPUキャッシュの効率も改善される可能性があります。

全文翻訳

Goのunsafeによる境界チェックの排除

ホットパスの最適化:コンパイラが削除できない境界チェックをunsafeポインタ演算で排除する、ただしそれらが本当に不要であることを証明できる場合に限る。

2026年7月6日

最適化カタログシリーズの一部:

  1. 浮動小数点除算が整数除算に勝る場合
  2. 4バイトのパディングが配列クリアを49%高速化する方法
  3. Goの境界チェックをunsafeで排除する (この記事)

境界チェックの排除(BCE)は、Goの世界で最も堅牢で生産性の高い最適化手法の一つでしょう。これは、私がGoのホットパスの最適化を始める際に最初に試す手法です。なぜこれほど堅牢なのでしょうか?それは、ホットパスにおける命令数と分岐数を削減するからです。これだけでも、無駄なサイクルを削減できるという点で優れていますが、さらに利点があります。コードがすでにキャッシュ容量や競合ミスに悩まされている場合、命令数を減らすことはそれらを大幅に改善する可能性があります。L1命令キャッシュ、uopキャッシュ、そしておそらくフロントエンドの分岐予測キャッシュについて話しています。レジスタの圧力についても、BCEはそれに役立ちます。このように堅牢でありながら、境界チェックは検出しやすく、時には比較的簡単に排除できます。要するに、BCEは通常、最初に試す価値のある簡単な勝利です。しかし、時には従来の手段で境界チェックを排除するのが容易ではなく、そこでunsafe技術が登場します。そして、これがこの記事の主題です。

まず、境界チェックとは何でしょうか?Goは安全な言語であり、いくつかの保証を提供します。例えば、範囲外のスライス要素にアクセスできないという保証です。これを実現するために、コンパイラは、範囲外のインデックスがアクセスされた場合にランタイムがパニックを起こすようにするアセンブリコードを大量に追加します。この小さな例で簡単に説明しましょう:

func load(src []byte, i int) byte {
	return src[i]
}

境界チェックを無効にする-Bフラグでコンパイルすると、この簡潔なアセンブリが出力されます:

0x71d   MOVQ AX, 0x8(SP)	
0x722   MOVZX 0(AX)(DI*1), AX	
0x726   RET

-Bフラグを削除したアセンブリは、境界チェックによって引き起こされるオーバーヘッドを示しています:

+ 0x796   PUSHQ BP		
+ 0x797   MOVQ SP, BP	
  0x79a   MOVQ AX, 0x10(SP)	
+ 0x79f   CMPQ DI, BX	
+ 0x7a2   JAE 0x7aa	
  0x7a4   MOVZX 0(AX)(DI*1), AX	
+ 0x7a8   POPQ BP		
  0x7a9   RET		
+ 0x7aa   CALL 0x7af	[1:5]R_CALL:runtime.panicBounds
+ 0x7af   NOPL

もちろん、このアセンブリの差は誇張しすぎです。関数は非常に小さく、リーフ関数でしたが、BCを有効にするとCALLが発生し、PUSHQ/POPQ BPとMOVQ SP, BPが追加されました。CALLが発生する関数はリーフ関数でなくなり、境界チェックに関係なくこれらのプロローグ命令を取得します。しかし、それを無視しても、オーバーヘッドがあるという点は変わりません。しかし、実際にはどうでしょうか?考えてみると、誇張ではありません。もし小さな関数があり、BCEによってそれがリーフ関数になり、CALLのオーバーヘッドが削除されるなら、それは正当なBCE関連の最適化です。

ちなみに、境界チェックを見つけるためにアセンブリを検索する必要は実際にはありません。コンパイラは、このコマンドで全ての境界チェックをリストアップできます:

go build -gcflags="-d=ssa/check_bce/debug=1" .

unsafeに切り替える前に、BCに対処する従来の方法を見てみましょう。Goコンパイラは、境界チェックが不要であることを「証明」できれば、しばしばそれを排除できます。範囲の残りをループする前に、上限/下限にアクセスすることで証明します。これは実際のコードベースからの例です:

 func matchLen(a, b []byte, limit int) int {
-		a = a[:limit]
-		b = b[:len(a)]
+	a = a[:limit]
+	b = b[:len(a)]
 	i := 0
-	for ; limit >= 8; limit -= 8 {
- 		xor := loadU64(a[i:]) ^ loadU64(b[i:])
-		if xor != 0 {
-			return i + bits.TrailingZeros64(xor)/8
-		}
-		i += 8
+	for ; i <= len(a)-8; i += 8 {
+		xor := loadU64(a[i:]) ^ loadU64(b[i:])
+		if xor != 0 {
+			return i + bits.TrailingZeros64(xor)/8
+		}
 	}

-	for ; limit > 0 && a[i] == b[i]; limit-- {
-		i++
+	for ; i < len(a) && a[i] == b[i]; i++ {
 	}

 	return i
 }

ループ条件でi <= len(a)-8を使用すると、コンパイラは全てのaアクセスが範囲内にあることを証明できるようになるため、境界チェックを排除します。b = b[:len(a)]は、ループ内のb関連の境界チェックを排除します。

Goの各バージョンで、コンパイラは境界チェックの排除に関してますます賢くなっています。BCEにヒントを与える良い方法はしばしば存在します(より一般的な例を探している場合は、この投稿を参照してください)が、時には従来の手段でBCを排除することが不可能(まだ、次のGoバージョンでは可能になるかもしれません)であり、そこでunsafeが登場します。

⚠️ ここで話しているのは、コンパイラが境界チェックが不要だと判断できないが、プログラマは判断できるケースです。もし境界チェックが不要であることを証明できないなら、それを排除しないでください。コンパイラは正当な理由でそれを挿入しています。これは明白だと思いますが、念のため注記しておきます。

さて、unsafeを使って境界チェックを排除しましょうか?私のbrotliライブラリで見つけられた最良の例を使用します。そこには、それ自体に必然的にBCを伴う、遍在する関数が1つあります。binary.LittleEndian.Uint32:

// Uint32 returns the uint32 representation of b[0:4].
func (littleEndian) Uint32(b []byte) uint32 {
	_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808
	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
}

この関数は、バイトスライスからリトルエンディアン順で4バイトを読み取り、ビットパックされたデータをバイトスライスに格納する場所で役立ちます。コードを見ると、コンパイラにヒントを与えることで境界チェックを排除しようとしていることがわかります:_ = b[3]はb[3]の境界チェックを1つ維持しますが、インデックス0〜2の境界チェックを排除します。しかし、1つの境界チェックが残り、ホットパスでは不要なコードは無駄です。以下は、全ての境界チェックを排除する(これによりロード関数がリーフ関数に変換され、CALLオーバーヘッドが削除される)unsafeの例です:

//go:build !purego && (amd64 || 386 || arm64 || loong64 || ppc64le || wasm)

package encoder

import "unsafe"

func loadU32LE(b []byte, i uint) uint32 {
               (4)         (3)          (2)             (1)
	return *(*uint32)(unsafe.Add(unsafe.Pointer(unsafe.SliceData(b)), i))
}

更新 · 2026-07-26

Hacker Newsのユーザーncrucesが重要な指摘をしました:

この記事では、go:build行について言及すべきです:

他の/全てのリトルエンディアンプラットフォームをそのgo:build行に追加しないことが重要です。

記事は正しいですが、このコードは非アラインアクセスを許可するプラットフォームでのみ有効です。

Goが非アラインアクセスに対して安全だと考えているプラットフォームの完全なリストは、unalignedOKでこちらで確認できます:https://go.dev/src/cmd/compile/internal/ssa/config.go

unalignedOKとリトルエンディアンの共通部分を探してください。

関数のシグネチャが変更されたことに注意してください。stdlibのバリアントはbinary.LittleEndian.Uint32(data[offset:])のように呼び出しますが、unsafeバリアントはloadU32LE(data, offset)のように呼び出します。これは重要です。もし(data[offset:])を維持すると、呼び出し側で1つの境界チェックが残り、data[offset]が範囲内にあることを確認します。また、go:build命令にも注意してください。このトリックは、リトルエンディアン順でメモリにデータを格納するマシンでのみ機能します。ちなみに、これらはどれも新しいものではありません。パフォーマンスが重要なライブラリであるklauspost/compressは、全く同じunsafeリトルエンディアンロードに依存しています。これは広く知られていないニッチなテクニックに過ぎません。

例を見てみましょう:

  1. unsafe.SliceData(b)は、&b[0]が返すものと全く同じ結果を返します。これはスライスの最初の要素へのポインタです。もしb[0]を使用すると、排除しようとしている境界チェックが発生します。&b[0]とは異なり、unsafe.SliceDataは空のスライスにも使用できるという利点があります。
  2. unsafe.Pointerは、unsafe.SliceDataから返された*byteを、unsafe.Addに必要なunsafe.Pointer型に変換します。
  3. unsafe.Add(ptr, i)は、&b[i]のunsafe.Pointer表現を返します。
  4. これは最終的に*uint32にキャストされ、逆参照されます。

1つの境界チェックを排除するために3つの関数呼び出しを導入したと言うかもしれませんが、アセンブリを確認すると、Goコンパイラが全ての境界チェックを排除し、全ての呼び出しをインライン化していることがわかります:

MOVQ AX, 0x8(SP)	
MOVL 0(AX)(DI*1), AX	
RET

では、stdlibのLEローダーと手作りのunsafeローダーのパフォーマンスの違いは何でしょうか?ベンチマークしてみましょう。

ベンチマークコードを表示

package bce

import (
	"encoding/binary"
	"testing"
	"unsafe"
)

func loadU32LE(b []byte, i uint) uint32 {
	return *(*uint32)(unsafe.Add(unsafe.Pointer(unsafe.SliceData(b)), i))
}

var sink uint32

func BenchmarkLoadU32LE(b *testing.B) {
	data := make([]byte, 4096)
	b.SetBytes(int64(len(data)))
	for b.Loop() {
		var acc uint32
		for i := uint(0); i+4 <= uint(len(data)); i += 4 {
			acc += loadU32LE(data, i)
		}
		sink = acc
	}
}

func BenchmarkStdUint32(b *testing.B) {
	data := make([]byte, 4096)
	b.SetBytes(int64(len(data)))
	for b.Loop() {
		var acc uint32
		for i := 0; i+4 <= len(data); i += 4 {
			acc += binary.LittleEndian.Uint32(data[i:])
		}
		sink = acc
	}
}
goos: linux
goarch: amd64
pkg: bcetest
cpu: 12th Gen Intel(R) Core(TM) i5-12500
BenchmarkLoadU32LE   22644585   273.7 ns/op   14966.04 MB/s
BenchmarkStdUint32    9922156   600.7 ns/op    6818.58 MB/s

unsafeバージョンは2倍以上高速です。マイクロベンチマークは信頼できないと言う人もいるかもしれませんが、実際のコードベースでベンチマークコードを囲むと状況は全く異なると言うでしょう。なるほど、それも一理あります。ここでは、実際の圧縮マッチファインダーが、stdlibのLEローダーをunsafeのものに置き換える前後で、本番環境に近いワークロードで実際の作業を行っているベンチマークの結果を示します:

pkg: github.com/andybalholm/brotli/matchfinder
     │  before.txt  │              after.txt               │
     │     B/s      │     B/s       vs base                │
Trio   90.39Mi ± 0%   99.99Mi ± 0%  +10.62% (p=0.000 n=30)

明白な欠点:それはunsafeであることです、当然です。コンパイラが挿入した全ての検証は、今やプログラマが本当に不要であることを証明する必要があります。既に不満を述べたように、Goにnoboundsコンパイラヒントがあればよかったのですが、そうではないため、残された唯一の実行可能な選択肢はunsafeポインタ演算を使用することです。

← 前へ 4バイトのパディングが配列クリアを49%高速化する方法