Container Service for Kubernetes:Ossfs 2.0 クライアントストレステストのパフォーマンス

テストコマンド

FIO を使用して、file-100G という名前の単一スレッドテストタスクを実行し、1 MB のパートサイズで 100 GB のデータを /mnt/oss/fio_direct_write ディレクトリに直接書き込み、テスト結果を出力します。

fio --name=file-100G --ioengine=libaio --rw=write --bs=1M --size=100G --numjobs=1 --direct=1 --directory=/mnt/oss/fio_direct_write --group_reporting

テスト結果

テストコマンド

ページキャッシュをクリアした後、FIO を使用して、/mnt/oss/fio_direct_write ディレクトリから 1 MB のパートサイズで 100 GB のデータを単一スレッドを使用して順番に読み取り、テスト結果を出力します。

echo 1 > /proc/sys/vm/drop_caches
fio --name=file-100G --ioengine=libaio --direct=1 --rw=read --bs=1M --directory=/mnt/oss/fio_direct_write --group_reporting --numjobs=1

テスト結果

テストファイルの生成

/mnt/oss/fio マウントディレクトリに、それぞれ 100 GB の 4 つのファイルを作成します。

fio --name=file-100g --ioengine=libaio --direct=1 --iodepth=1 --numjobs=4 --nrfiles=1 --rw=write --bs=1M  --size=100G --group_reporting --thread --directory=/mnt/oss/fio

テストコマンド

ページキャッシュをクリアした後、FIO を使用して、/mnt/oss/fio ディレクトリにある作成された 4 つのファイルを、4 つのスレッドを使用して 30 秒間で 1 MB のパートサイズで同時に読み取り、結果を出力します。

echo 1 > /proc/sys/vm/drop_caches
fio --name=file-100g --ioengine=libaio --direct=1 --iodepth=1 --numjobs=4 --nrfiles=1 --rw=read --bs=1M  --size=100G --group_reporting --thread --directory=/mnt/oss/fio --time_based --runtime=30

テスト結果

テスト手順

1. rw-bench.go という名前の Go プログラムを作成します。

   このプログラムには、次の主要な機能があります。1. 宛先ファイルディレクトリに同じサイズの複数のファイルを同時に作成できます。 2. 宛先ファイルディレクトリ内のすべてのファイルを同時に読み取り、n 個のスレッドにファイルを読み取り用に割り当て、帯域幅データを記録できます。

   サンプルコード

   package main
   
   import (
   	"flag"
   	"fmt"
   	"io"
   	"log"
   	"os"
   	"path/filepath"
   	"sync"
   	"time"
   )
   
   var dir = flag.String("dir", "", "作業ディレクトリ") // 作業ディレクトリ
   var threads = flag.Int("threads", 128, "同時実行スレッド数") // 同時実行スレッド数
   var isWrite = flag.Bool("write", false, "書き込みファイルのテスト") // 書き込みファイルのテスト
   var fileSize = flag.Int64("file-size-KB", 128, "ファイルサイズ (KB)") // ファイルサイズ (KB)
   var fileCount = flag.Int("file-count", 0, "ファイル数") // ファイル数
   
   type fileInfo struct {
   	Name string
   	Size int64
   }
   
   func getFileList(dir string, isWrite bool) []fileInfo {
   	var files []fileInfo
   
   	if isWrite {
   		for i := 0; i < *fileCount; i++ {
   			files = append(files, fileInfo{
   				Name: fmt.Sprintf("%v/%v.dat", dir, i),
   				Size: *fileSize * 1024,
   			})
   		}
   	} else {
   		err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
   			if err != nil {
   				return err
   			}
   			if !info.IsDir() {
   				files = append(files, fileInfo{
   					Name: path,
   					Size: info.Size(),
   				})
   			}
   			return nil
   		})
   
   		if err != nil {
   			log.Fatalf("パス %v のウォーキングエラー: %v\n", dir, err)
   		}
   	}
   
   	return files
   }
   
   func worker(taskChan <-chan fileInfo, wg *sync.WaitGroup, bytesChan chan<- int64, isWrite bool) {
   	defer wg.Done()
   	buffer := make([]byte, 1024*1024)
   
   	for fInfo := range taskChan {
   		var fd *os.File
   		var err error
   		if isWrite {
   			fd, err = os.OpenFile(fInfo.Name, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
   			if err != nil {
   				fmt.Printf("%v の作成/オープンに失敗しました: %v\n", fInfo.Name, err)
   				continue
   			}
   		} else {
   			fd, err = os.OpenFile(fInfo.Name, os.O_RDONLY, 0)
   			if err != nil {
   				fmt.Printf("%v のオープンに失敗しました: %v\n", fInfo.Name, err)
   				continue
   			}
   		}
   
   		offset := int64(0)
   		var totalBytes int64
   		for offset < fInfo.Size {
   			var n int
   
   			if offset+int64(len(buffer)) > fInfo.Size {
   				buffer = buffer[:fInfo.Size-offset]
   			}
   
   			if isWrite {
   				n, err = fd.WriteAt(buffer, offset)
   				if err != nil {
   					fmt.Printf("%v への書き込みに失敗しました (オフセット %v): %v\n", fInfo.Name, offset, err)
   					break
   				}
   			} else {
   				n, err = fd.ReadAt(buffer, offset)
   				if err != nil && err != io.EOF {
   					fmt.Printf("%v からの読み取りに失敗しました (オフセット %v): %v\n", fInfo.Name, offset, err)
   					break
   				}
   			}
   
   			totalBytes += int64(n)
   			offset += int64(n)
   		}
   
   		fd.Close()
   		bytesChan <- totalBytes
   	}
   }
   
   func doBench(dir string, isWrite bool) {
   	files := getFileList(dir, isWrite)
   	var wg sync.WaitGroup
   
   	if isWrite {
   		fmt.Printf("%v ファイルで書き込みベンチマークを開始します\n", len(files))
   	} else {
   		fmt.Printf("%v ファイルで読み取りベンチマークを開始します\n", len(files))
   	}
   
   	taskChan := make(chan fileInfo, 1024)
   
   	go func(taskChan chan<- fileInfo) {
   		for _, fInfo := range files {
   			taskChan <- fInfo
   		}
   		close(taskChan)
   	}(taskChan)
   
   	bytesChan := make(chan int64, 1024)
   	for i := 0; i < *threads; i++ {
   		wg.Add(1)
   		go worker(taskChan, &wg, bytesChan, isWrite)
   	}
   
   	st := time.Now()
   	go func() {
   		wg.Wait()
   		close(bytesChan)
   	}()
   
   	var totalBytes int64
   	for bytes := range bytesChan {
   		totalBytes += bytes
   	}
   
   	ed := time.Now()
   	duration := ed.Sub(st)
   	throughput := float64(totalBytes) / (float64(duration.Nanoseconds()) / 1e9)
   
   	fmt.Printf("合計時間: %v\n", duration)
   	if isWrite {
   		fmt.Printf("書き込みスループット: %.2f MB/s\n", throughput/1000/1000)
   	} else {
   		fmt.Printf("読み取りスループット: %.2f MB/s\n", throughput/1000/1000)
   	}
   }
   
   func main() {
   	flag.Parse()
   
   	workdir := *dir
   	if workdir == "" {
   		flag.Usage()
   		os.Exit(1)
   	}
   
   	if _, err := os.Stat(workdir); err != nil {
   		fmt.Printf("%v へのアクセスに失敗しました: %v\n", workdir, err)
   		os.Exit(1)
   	}
   
   	doBench(workdir, *isWrite)
   }
   

2. rw-bench.go プログラムファイルをコンパイルします。

   go build rw-bench.go

3. ローカルファイルシステムにマウントされた OSS バケットディレクトリに、それぞれ 128 KB の 100,000 ファイルを作成します。

   mkdir -p <マウントされたテストファイルのパス> && ./rw-bench --dir <マウントされたテストファイルのパス> --file-size-KB 128 --file-count 100000 --write

4. ページキャッシュをクリアしてプログラムを実行します。 サーバーのレイテンシが安定したテストから取得したテストデータを使用して、テストを 5 回連続して実行した後。

   echo 1 > /proc/sys/vm/drop_caches
   ./rw-bench --dir <マウントされたテストファイルのパス> --threads 128

テスト結果