129 lines
2.6 KiB
Go
129 lines
2.6 KiB
Go
//go:build ignore
|
|
|
|
// Read lots files with lots of simultaneous seeking to stress test the seek code
|
|
package main
|
|
|
|
import (
|
|
"flag"
|
|
"io"
|
|
"log"
|
|
"math/rand"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
var (
|
|
// Flags
|
|
iterations = flag.Int("n", 1e6, "Iterations to try")
|
|
maxBlockSize = flag.Int("b", 1024*1024, "Max block size to read")
|
|
simultaneous = flag.Int("transfers", 16, "Number of simultaneous files to open")
|
|
seeksPerFile = flag.Int("seeks", 8, "Seeks per file")
|
|
mask = flag.Int64("mask", 0, "mask for seek, e.g. 0x7fff")
|
|
)
|
|
|
|
func init() {
|
|
rand.Seed(time.Now().UnixNano())
|
|
}
|
|
|
|
func seekTest(n int, file string) {
|
|
in, err := os.Open(file)
|
|
if err != nil {
|
|
log.Fatalf("Couldn't open %q: %v", file, err)
|
|
}
|
|
fi, err := in.Stat()
|
|
if err != nil {
|
|
log.Fatalf("Couldn't stat %q: %v", file, err)
|
|
}
|
|
size := fi.Size()
|
|
|
|
// FIXME make sure we try start and end
|
|
|
|
maxBlockSize := *maxBlockSize
|
|
if int64(maxBlockSize) > size {
|
|
maxBlockSize = int(size)
|
|
}
|
|
for i := 0; i < n; i++ {
|
|
start := rand.Int63n(size)
|
|
if *mask != 0 {
|
|
start &^= *mask
|
|
}
|
|
blockSize := rand.Intn(maxBlockSize)
|
|
beyondEnd := false
|
|
switch rand.Intn(10) {
|
|
case 0:
|
|
start = 0
|
|
case 1:
|
|
start = size - int64(blockSize)
|
|
case 2:
|
|
// seek beyond the end
|
|
start = size + int64(blockSize)
|
|
beyondEnd = true
|
|
default:
|
|
}
|
|
if !beyondEnd && int64(blockSize) > size-start {
|
|
blockSize = int(size - start)
|
|
}
|
|
log.Printf("%s: Reading %d from %d", file, blockSize, start)
|
|
|
|
_, err = in.Seek(start, io.SeekStart)
|
|
if err != nil {
|
|
log.Fatalf("Seek failed on %q: %v", file, err)
|
|
}
|
|
|
|
buf := make([]byte, blockSize)
|
|
n, err := io.ReadFull(in, buf)
|
|
if beyondEnd && err == io.EOF {
|
|
// OK
|
|
} else if err != nil {
|
|
log.Fatalf("Read failed on %q: %v (%d)", file, err, n)
|
|
}
|
|
}
|
|
|
|
err = in.Close()
|
|
if err != nil {
|
|
log.Fatalf("Error closing %q: %v", file, err)
|
|
}
|
|
}
|
|
|
|
// Find all the files in dir
|
|
func findFiles(dir string) (files []string) {
|
|
filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
|
|
if info.Mode().IsRegular() && info.Size() > 0 {
|
|
files = append(files, path)
|
|
}
|
|
return nil
|
|
})
|
|
sort.Strings(files)
|
|
return files
|
|
}
|
|
|
|
func main() {
|
|
flag.Parse()
|
|
args := flag.Args()
|
|
if len(args) != 1 {
|
|
log.Fatalf("Require a directory as argument")
|
|
}
|
|
dir := args[0]
|
|
files := findFiles(dir)
|
|
jobs := make(chan string, *simultaneous)
|
|
var wg sync.WaitGroup
|
|
wg.Add(*simultaneous)
|
|
for i := 0; i < *simultaneous; i++ {
|
|
go func() {
|
|
defer wg.Done()
|
|
for file := range jobs {
|
|
seekTest(*seeksPerFile, file)
|
|
}
|
|
}()
|
|
}
|
|
for i := 0; i < *iterations; i++ {
|
|
i := rand.Intn(len(files))
|
|
jobs <- files[i]
|
|
//jobs <- files[i]
|
|
}
|
|
close(jobs)
|
|
wg.Wait()
|
|
}
|