List of Join [text.Baldanders.info]

【改訂版】文字列連結はどれが速い？

2019-10-13T08:15:36+00:00

今回も小ネタでお送りしております。

2015年に「文字列連結はどれが速い？」という記事を書いた。あれから文字連結に関してどう変わったのか。特に Go 1.10 で strings.Builder が追加されているので，その辺も含めて再検証してみる。

今回検証するコードは以下の通り。

package join

import (
    "bytes"
    "strings"
)

var sz8k = 8 * 1024

func JoinStringPlus(ss []string) {
    var str string
    for _, s := range ss {
        str += s + "\n"
    }
}

func JoinStringJoin(ss []string) {
    strings.Join(ss, "\n")
}

func JoinStringByteAppend(ss []string) {
    b := []byte{}
    for _, s := range ss {
        b = append(b, s...)
        b = append(b, "\n"...)
    }
}

func JoinStringByteAppend8K(ss []string) {
    b := make([]byte, 0, sz8k)
    for _, s := range ss {
        b = append(b, s...)
        b = append(b, "\n"...)
    }
}

func JoinStringBuilder(ss []string) {
    b := &strings.Builder{}
    for _, s := range ss {
        b.WriteString(s)
        b.WriteString("\n")
    }
}

func JoinStringBuilder8K(ss []string) {
    b := &strings.Builder{}
    b.Grow(sz8k)
    for _, s := range ss {
        b.WriteString(s)
        b.WriteString("\n")
    }
}

func JoinStringBuffer(ss []string) {
    b := &bytes.Buffer{}
    for _, s := range ss {
        b.WriteString(s)
        b.WriteString("\n")
    }
}

func JoinStringBuffer8K(ss []string) {
    b := bytes.NewBuffer(make([]byte, 0, sz8k))
    for _, s := range ss {
        b.WriteString(s)
        b.WriteString("\n")
    }
}

各関数の内容は以下の通り。

関数名	内容
`JoinStringPlus`	`+` 演算子で連結する
`JoinStringJoin`	`strings.Join` 関数で連結する
`JoinStringByteAppend`	`[]byte` 配列に追記する
`JoinStringByteAppend8K`	`[]byte` 配列に追記する（8KB アロケーション）
`JoinStringBuilder`	`strings.Builder` に追記する
`JoinStringBuilder8K`	`strings.Builder` に追記する（8KB アロケーション）
`JoinStringBuffer`	`bytes.Buffer` に追記する
`JoinStringBuffer8K`	`bytes.Buffer` に追記する（8KB アロケーション）

使うメソッドによって出力する型が異なるが（string or []byte），今回は無視することにした¹。

ベンチマーク用のコードは以下の通り。

package join

import (
    "bufio"
    "os"
    "testing"
)

func ReadAll(path string) []string {
    file, err := os.Open(path) //maybe file path
    if err != nil {
        return nil
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    list := []string{}
    for scanner.Scan() {
        list = append(list, scanner.Text())
    }
    if err := scanner.Err(); err != nil {
        return nil
    }
    return list
}

var content = ReadAll("CollisionsForHashFunctions.txt")

func BenchmarkJoinStringPlus(b *testing.B) {
    for i := 0; i < b.N; i++ {
        JoinStringPlus(content)
    }
}

func BenchmarkJoinStringJoin(b *testing.B) {
    for i := 0; i < b.N; i++ {
        JoinStringJoin(content)
    }
}

func BenchmarkJoinStringByteAppend(b *testing.B) {
    for i := 0; i < b.N; i++ {
        JoinStringByteAppend(content)
    }
}

func BenchmarkJoinStringByteAppend8K(b *testing.B) {
    for i := 0; i < b.N; i++ {
        JoinStringByteAppend8K(content)
    }
}

func BenchmarkJoinStringBuilder(b *testing.B) {
    for i := 0; i < b.N; i++ {
        JoinStringBuilder(content)
    }
}

func BenchmarkJoinStringBuilder8K(b *testing.B) {
    for i := 0; i < b.N; i++ {
        JoinStringBuilder8K(content)
    }
}

func BenchmarkJoinStringBuffer(b *testing.B) {
    for i := 0; i < b.N; i++ {
        JoinStringBuffer(content)
    }
}

func BenchmarkJoinStringBuffer8K(b *testing.B) {
    for i := 0; i < b.N; i++ {
        JoinStringBuffer8K(content)
    }
}

入力テキストは前回と同じ CollisionsForHashFunctions.txt を使用した。 8KB ほどのサイズがある。つまりコピー先バッファに 8KB の容量があれば追加のアロケーションは発生しないことになる。

では，さっそく実行してみる。

$ go test -bench JoinString -benchmem
goos: linux
goarch: amd64
pkg: join
BenchmarkJoinStringPlus-4                  19484         65256 ns/op      272160 B/op          69 allocs/op
BenchmarkJoinStringJoin-4                 371649          3087 ns/op        8192 B/op           1 allocs/op
BenchmarkJoinStringByteAppend-4           151417          8339 ns/op       35376 B/op          12 allocs/op
BenchmarkJoinStringByteAppend8K-4         502942          2544 ns/op        8192 B/op           1 allocs/op
BenchmarkJoinStringBuilder-4              130408          8434 ns/op       35376 B/op          12 allocs/op
BenchmarkJoinStringBuilder8K-4            418900          2781 ns/op        8192 B/op           1 allocs/op
BenchmarkJoinStringBuffer-4               133052          9545 ns/op       32240 B/op           8 allocs/op
BenchmarkJoinStringBuffer8K-4             351681          3526 ns/op        8192 B/op           1 allocs/op
PASS
ok      join    12.695s

結果を表にまとめておこう。

関数名	実行時間	Alloc サイズ	Alloc 回数
`JoinStringPlus`	65,256 ns	2,702,160 bytes	69
`JoinStringJoin`	3,087 ns	8,192 bytes	1
`JoinStringByteAppend`	8,339 ns	35,376 bytes	12
`JoinStringByteAppend8K`	2,544 ns	8192 bytes	1
`JoinStringBuilder`	8,434 ns	35,376 bytes	12
`JoinStringBuilder8K`	2,781 ns	8,192 bytes	1
`JoinStringBuffer`	9,545 ns	32,240 bytes	8
`JoinStringBuffer8K`	3,526 ns	8192 bytes	1

まず strings.Join() 関数を使った連結がめっさ速くなってアロケーション回数も1回のみになっていることにビックリした。ソースコードを見てみたら，やっぱり strings.Join() 関数内部で strings.Builder を使っていた。

// Join concatenates the elements of a to create a single string. The separator string
// sep is placed between elements in the resulting string.
func Join(a []string, sep string) string {
    switch len(a) {
    case 0:
        return ""
    case 1:
        return a[0]
    }
    n := len(sep) * (len(a) - 1)
    for i := 0; i < len(a); i++ {
        n += len(a[i])
    }

    var b Builder
    b.Grow(n)
    b.WriteString(a[0])
    for _, s := range a[1:] {
        b.WriteString(sep)
        b.WriteString(s)
    }
    return b.String()
}

ちなみに strings.Builder への追記処理は以下のようになっている。

// WriteString appends the contents of s to b's buffer.
// It returns the length of s and a nil error.
func (b *Builder) WriteString(s string) (int, error) {
    b.copyCheck()
    b.buf = append(b.buf, s...)
    return len(s), nil
}

つまり []byte 配列への append() と strings.Builder への追記と strings.Join() は実質的に同じ処理で，それぞれの前処理分だけ差が出ているということになる。

今回の検証では

やっぱり + 演算子による連結はダメダメ²
よほどの最適化が要求されない限り []byte 配列への append() は strings.Builder へ代替可能³
strings.Join() 関数のパフォーマンスは十分なので気軽に使ってよい
文字列連結に限るなら，もはや bytes.Buffer は有利とは言えない

といったところだろうか。

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

[Comment] 著者のひとりは（あの「バイブル」とも呼ばれる）通称 “K&R” の K のほうである。この本は Go 言語の教科書と言ってもいいだろう。と思ったら絶版状態らしい（2025-01 現在）。復刊を望む！

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

string 型は不変オブジェクトなので，通常は []byte 型との相互変換の際にメモリ・アロケーションとデータ・コピーが発生する。ちなみに strings.Builder の String() メソッドでは unsafe パッケージを使って無理やりキャスティングしている。 ↩︎
リテラル文字列同士の連結はコンパイラが処理するので + 演算子で無問題。 ↩︎
内部で append() 関数を使っていることから分かる通り strings.Builder のインスタンスはコピーして使えないので注意が必要である（インスタンスのポインタを渡せばOK）。当然ながら goroutine-safe ではないので複数の goroutine 間で共有できない。 ↩︎

文字列連結はどれが速い？

2015-09-21T14:08:07+00:00

（初出： Golang の文字列連結はどちらが速い？ - Qiita）

前回につづき string の話題。 Go 言語で文字列の連結を行う際にどうやるのが一番速いか，という話。

【2019-10-13 追記】 改訂版を公開しました。

文字列連結を行う4つの方法

Go 言語で文字列の連結を行う際には概ね以下の4つの方法がある。

“+” 演算子で連結する
strings.Join で連結する
bytes.Buffer に追記する
[]byte に append する

string は「不変（immutable）」なので，最初の2つが高コストになるだろうことはすぐに想像がつく。

では残りの2つはどうなのかというと

Goの文字列結合のパフォーマンス - Qiita

によると最後のが一番速いらしい。ほんじゃまぁ，確かめてみるか。

サンプルコードを用意

以下のコード join.go を使って評価してみる。

package main

import (
    "bufio"
    "bytes"
    "io"
)

//Read content (text data) from buffer
func ContentText(inStream io.Reader) ([]string, error) {
    scanner := bufio.NewScanner(inStream)
    list := make([]string, 0)
    for scanner.Scan() {
        list = append(list, scanner.Text())
    }
    if err := scanner.Err(); err != nil {
        return nil, err
    }
    return list, nil
}

//Write content (text data) to buffer
func WriteBuffer1(lines []string) []byte {
    //write to byte buffer
    content := make([]byte, 0)
    recode := "\r\n"
    for _, line := range lines {
        content = append(content, line...)
        content = append(content, recode...)
    }
    return content
}

//Write content (text data) to buffer
func WriteBuffer1Cap128(lines []string) []byte {
    //write to byte buffer
    content := make([]byte, 0, 128) //128 bytes capacity
    recode := "\r\n"
    for _, line := range lines {
        content = append(content, line...)
        content = append(content, recode...)
    }
    return content
}

//Write content (text data) to buffer
func WriteBuffer1Cap1K(lines []string) []byte {
    //write to byte buffer
    content := make([]byte, 0, 1024) //1K bytes capacity
    recode := "\r\n"
    for _, line := range lines {
        content = append(content, line...)
        content = append(content, recode...)
    }
    return content
}

//Write content (text data) to buffer (buffered I/O)
func WriteBuffer2(lines []string) []byte {
    //write to byte buffer
    content := bytes.NewBuffer(make([]byte, 0))
    recode := "\r\n"
    for _, line := range lines {
        content.WriteString(line)
        content.WriteString(recode)
    }
    return content.Bytes()
}

//Write content (text data) to buffer (buffered I/O)
func WriteBuffer2Cap128(lines []string) []byte {
    //write to byte buffer
    content := bytes.NewBuffer(make([]byte, 0, 128)) //128 bytes capacity
    recode := "\r\n"
    for _, line := range lines {
        content.WriteString(line)
        content.WriteString(recode)
    }
    return content.Bytes()
}

//Write content (text data) to buffer (buffered I/O)
func WriteBuffer2Cap1K(lines []string) []byte {
    //write to byte buffer
    content := bytes.NewBuffer(make([]byte, 0, 1024)) //1K bytes capacity
    recode := "\r\n"
    for _, line := range lines {
        content.WriteString(line)
        content.WriteString(recode)
    }
    return content.Bytes()
}

テストコード join_test.go はこんな感じ。

package main

import (
    "os"
    "testing"
)

func readFile() []string {
    file, err := os.Open("CollisionsForHashFunctions.txt") //maybe file path
    if err != nil {
        panic(err)
    }
    defer file.Close()
    list, err := ContentText(file)
    if err != nil {
        panic(err)
    }
    return list
}

func BenchmarkWriteBuffer1(b *testing.B) {
    list := readFile()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        content := WriteBuffer1(list)
        _ = string(content)
    }
}

func BenchmarkWriteBuffer1Cap128(b *testing.B) {
    list := readFile()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        content := WriteBuffer1Cap128(list)
        _ = string(content)
    }
}

func BenchmarkWriteBuffer1Cap1K(b *testing.B) {
    list := readFile()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        content := WriteBuffer1Cap1K(list)
        _ = string(content)
    }
}

func BenchmarkWriteBuffer2(b *testing.B) {
    list := readFile()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        content := WriteBuffer2(list)
        _ = string(content)
    }
}

func BenchmarkWriteBuffer2Cap128(b *testing.B) {
    list := readFile()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        content := WriteBuffer2Cap128(list)
        _ = string(content)
    }
}

func BenchmarkWriteBuffer2Cap1K(b *testing.B) {
    list := readFile()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        content := WriteBuffer2Cap1K(list)
        _ = string(content)
    }
}

Go 言語のテストについては以前紹介したが，同じ要領で Benchmark から始まる名前の関数を作るとベンチマーク用のコードとして認識される。引数には b *testing.B を指定する。

ベンチマークの内訳は以下のとおり。

ベンチマーク名	処理内容
`BenchmarkWriteBuffer1`	`[]byte` に `append` する
`BenchmarkWriteBuffer1Cap128`	`[]byte` に `append` する（ capacity 128B）
`BenchmarkWriteBuffer1Cap1K`	`[]byte` に `append` する（ capacity 1KB）
`BenchmarkWriteBuffer2`	`bytes.Buffer` に追記する
`BenchmarkWriteBuffer2Cap128`	`bytes.Buffer` に追記する（ capacity 128B）
`BenchmarkWriteBuffer2Cap1K`	`bytes.Buffer` に追記する（ capacity 1KB）

入力テキストだが，小さいファイルではテストにならない気がしたので，大昔に書いたテキスト CollisionsForHashFunctions.txt を使うことにした。サイズは70行，7KB ほど。

テスト結果

結果は以下のとおり。

C:>go test -bench WriteBuffer -benchmem
testing: warning: no tests to run
PASS
BenchmarkWriteBuffer1-8           100000         17831 ns/op       37056 B/op     12 allocs/op
BenchmarkWriteBuffer1Cap128-8     100000         20321 ns/op       36992 B/op     11 allocs/op
BenchmarkWriteBuffer1Cap1K-8      100000         19301 ns/op       36096 B/op      8 allocs/op
BenchmarkWriteBuffer2-8           100000         17300 ns/op       33760 B/op     10 allocs/op
BenchmarkWriteBuffer2Cap128-8     100000         19451 ns/op       34992 B/op      9 allocs/op
BenchmarkWriteBuffer2Cap1K-8      100000         15490 ns/op       25712 B/op      6 allocs/op
ok      join    12.659s

ありゃりゃ。 bytes.Buffer を使ったほうが速いみたい（capacity を大きくとれば）。

それなら，入力テキストを切り詰めて10行，0.3KB にしてやってみる。

C:>go test -bench WriteBuffer -benchmem
testing: warning: no tests to run
PASS
BenchmarkWriteBuffer1-8          2000000           859 ns/op        1312 B/op      5 allocs/op
BenchmarkWriteBuffer1Cap128-8    2000000           707 ns/op        1248 B/op      4 allocs/op
BenchmarkWriteBuffer1Cap1K-8     2000000           796 ns/op        1376 B/op      2 allocs/op
BenchmarkWriteBuffer2-8          1000000          1686 ns/op        1600 B/op      6 allocs/op
BenchmarkWriteBuffer2Cap128-8    1000000          1411 ns/op        1680 B/op      5 allocs/op
BenchmarkWriteBuffer2Cap1K-8     2000000           980 ns/op        1488 B/op      3 allocs/op
ok      join    13.589s

今度は []byte の方が速くなった。

まぁでも予想通りかな。データのサイズが大きくなればバッファ操作のほうが有利になるのは分かりやすいっちゃあ分かりやすい。

注目すべきは BenchmarkWriteBuffer1Cap128 と BenchmarkWriteBuffer1Cap1K で， capacity を 1KB 取ったほうが若干遅くなっている。この辺のチューニングをどうするか，というところなのだろう（実はこれ，環境によって微妙に順位が変わるんだよなぁ）。

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価