性能测试

测试命令

使用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目录下的100 GB文件进行单线程、块大小1 MB的顺序读测试并输出测试结果。

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下创建4个100 GB的文件用于多线程并发测试。

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工具通过4个并发线程对/mnt/oss/fio目录下的4个100 GB文件进行1 MB块大小的30秒读取测试，并输出测试结果。

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语言程序。

   此程序具备两项核心功能。其一，它能够并发地在目标文件目录下创建若干个大小相同的文件；其二，它可以并发读取目标文件目录下的所有文件，将这些文件分配给n个线程进行读取操作，并且记录最终的带宽数据。

   代码示例

   package main
   
   import (
   	"flag"
   	"fmt"
   	"io"
   	"log"
   	"os"
   	"path/filepath"
   	"sync"
   	"time"
   )
   
   var dir = flag.String("dir", "", "work dir")
   var threads = flag.Int("threads", 128, "concurrency threads count")
   var isWrite = flag.Bool("write", false, "test write files")
   var fileSize = flag.Int64("file-size-KB", 128, "file size in KBytes")
   var fileCount = flag.Int("file-count", 0, "file count")
   
   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("Error walking the path %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("Failed to create/open %v with %v\n", fInfo.Name, err)
   				continue
   			}
   		} else {
   			fd, err = os.OpenFile(fInfo.Name, os.O_RDONLY, 0)
   			if err != nil {
   				fmt.Printf("Failed to open %v with %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("Failed to write file %v at %v, with %v\n", fInfo.Name, offset, err)
   					break
   				}
   			} else {
   				n, err = fd.ReadAt(buffer, offset)
   				if err != nil && err != io.EOF {
   					fmt.Printf("Failed to read file %v at %v, with %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("start write bench with %v files\n", len(files))
   	} else {
   		fmt.Printf("start read bench with %v files\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("Total time: %v\n", duration)
   	if isWrite {
   		fmt.Printf("Write throughput: %.2f MBytes/s\n", throughput/1000/1000)
   	} else {
   		fmt.Printf("Read throughput: %.2f MBytes/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("Failed to access %v with %v\n", workdir, err)
   		os.Exit(1)
   	}
   
   	doBench(workdir, *isWrite)
   }
   

2. 编译rw-bench.go程序文件。

   go build rw-bench.go

3. 在已挂载到本地的OSSBucket目录中，创建100000个128 KB大小的文件。

   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

测试结果