// Benchmark the read speed of the underlying block device for a given file. func main() { pathname := "/" if len(os.Args) == 2 { pathname = os.Args[1] } bytesPerSecond, blocksPerSecond, err := fsbench.GetReadSpeed(pathname) if err != nil { fmt.Fprintf(os.Stderr, "Error! %s\n", err) return } fmt.Printf("speed=%d MiB/s ", bytesPerSecond>>20) if blocksPerSecond > 0 { fmt.Printf("%d blocks/s\n", blocksPerSecond) } else { fmt.Println("I/O accounting not available") } }
func getCachedFsSpeed(workingRootDir string, cacheDirname string) (bytesPerSecond, blocksPerSecond uint64, computed, ok bool) { bytesPerSecond = 0 blocksPerSecond = 0 devnum, err := fsbench.GetDevnumForFile(workingRootDir) if err != nil { fmt.Fprintf(os.Stderr, "Unable to get device number for: %s\t%s\n", workingRootDir, err) return 0, 0, false, false } fsbenchDir := path.Join(cacheDirname, "fsbench") if !createDirectory(fsbenchDir) { return 0, 0, false, false } cacheFilename := path.Join(fsbenchDir, strconv.FormatUint(devnum, 16)) file, err := os.Open(cacheFilename) if err == nil { n, err := fmt.Fscanf(file, "%d %d", &bytesPerSecond, &blocksPerSecond) file.Close() if n == 2 || err == nil { return bytesPerSecond, blocksPerSecond, false, true } } bytesPerSecond, blocksPerSecond, err = fsbench.GetReadSpeed(workingRootDir) if err != nil { fmt.Fprintf(os.Stderr, "Unable to measure read speed\t%s\n", err) return 0, 0, true, false } file, err = os.Create(cacheFilename) if err != nil { fmt.Fprintf(os.Stderr, "Unable to open: %s for write\t%s\n", cacheFilename, err) return 0, 0, true, false } fmt.Fprintf(file, "%d %d\n", bytesPerSecond, blocksPerSecond) file.Close() return bytesPerSecond, blocksPerSecond, true, true }
// Benchmark the read speed of the underlying block device for a given file. func main() { pathname := "/" if len(os.Args) == 2 { pathname = os.Args[1] } bytesPerSecond, blocksPerSecond, err := fsbench.GetReadSpeed(pathname) if err != nil { fmt.Printf("Error! %s\n", err) return } ctx := fsrateio.NewReaderContext(bytesPerSecond, blocksPerSecond, 0) fmt.Println(ctx) var file *os.File file, err = os.Open(pathname) if err != nil { fmt.Printf("Error! %s\n", err) return } rd := bufio.NewReader(ctx.NewReader(file)) buffer := make([]byte, 65536) timeStart := time.Now() tread := 0 for { n := 0 n, err = rd.Read(buffer) if n < 1 && err == io.EOF { break } if err != nil { fmt.Printf("Error! %s\n", err) return } tread += n } bytesPerSecond = uint64(float64(tread) / time.Since(timeStart).Seconds()) fmt.Printf("%s/s\n", format.FormatBytes(bytesPerSecond)) }
func main() { flag.Parse() var err error bytesPerSecond, blocksPerSecond, err := fsbench.GetReadSpeed(*rootDir) if err != nil { fmt.Printf("Error! %s\n", err) return } var configuration scanner.Configuration configuration.ScanFilter, err = filter.NewFilter(nil) if err != nil { fmt.Printf("Unable to create empty filter\t%s\n", err) os.Exit(1) } configuration.FsScanContext = fsrateio.NewReaderContext(bytesPerSecond, blocksPerSecond, 0) if *scanSpeed != 0 { configuration.FsScanContext.GetContext().SetSpeedPercent(*scanSpeed) } fmt.Println(configuration.FsScanContext) syscall.Setpriority(syscall.PRIO_PROCESS, 0, 10) var prev_fs *scanner.FileSystem for iter := 0; *numScans < 0 || iter < *numScans; iter++ { timeStart := time.Now() fs, err := scanner.ScanFileSystem(*rootDir, *objectCache, &configuration) timeStop := time.Now() if iter > 0 { fmt.Println() } if err != nil { fmt.Printf("Error! %s\n", err) return } fmt.Print(fs) fmt.Printf("Total scanned: %s,\t", format.FormatBytes(fs.TotalDataBytes)) bytesPerSecond := uint64(float64(fs.TotalDataBytes) / timeStop.Sub(timeStart).Seconds()) fmt.Printf("%s/s\n", format.FormatBytes(bytesPerSecond)) if prev_fs != nil { if !scanner.CompareFileSystems(prev_fs, fs, os.Stdout) { fmt.Println("Scan results different from last run") } } runtime.GC() // Clean up before showing memory statistics. memstats.WriteMemoryStats(os.Stdout) if *debugFile != "" { file, err := os.Create(*debugFile) if err != nil { fmt.Printf("Error! %s\n", err) return } w := bufio.NewWriter(file) fs.DebugWrite(w, "") w.Flush() file.Close() } if *gobFile != "" { file, err := os.Create(*gobFile) if err != nil { fmt.Printf("Error creating: %s\t%s\n", *gobFile, err) os.Exit(1) } encoder := gob.NewEncoder(file) encoderStartTime := time.Now() encoder.Encode(fs) fmt.Printf("Encoder time: %s\n", time.Since(encoderStartTime)) file.Close() } prev_fs = fs time.Sleep(time.Duration(*interval) * time.Second) } }
func main() { flag.Parse() var err error bytesPerSecond, blocksPerSecond, err := fsbench.GetReadSpeed(*rootDir) if err != nil { fmt.Printf("Error! %s\n", err) return } ctx := fsrateio.NewContext(bytesPerSecond, blocksPerSecond) if *scanSpeed != 0 { ctx.SetSpeedPercent(*scanSpeed) } fmt.Println(ctx) syscall.Setpriority(syscall.PRIO_PROCESS, 0, 10) var prev_fs *scanner.FileSystem sleepDuration, _ := time.ParseDuration(fmt.Sprintf("%ds", *interval)) for iter := 0; *numScans < 0 || iter < *numScans; iter++ { timeStart := time.Now() fs, err := scanner.ScanFileSystem(*rootDir, *objectCache, ctx) timeStop := time.Now() if iter > 0 { fmt.Println() } if err != nil { fmt.Printf("Error! %s\n", err) return } fmt.Print(fs) fmt.Printf("Total scanned: %s,\t", fsrateio.FormatBytes(fs.TotalDataBytes)) bytesPerSecond := uint64(float64(fs.TotalDataBytes) / timeStop.Sub(timeStart).Seconds()) fmt.Printf("%s/s\n", fsrateio.FormatBytes(bytesPerSecond)) if prev_fs != nil { if !scanner.Compare(prev_fs, fs, os.Stdout) { fmt.Println("Scan results different from last run") } } runtime.GC() // Clean up before showing memory statistics. memstats.WriteMemoryStats(os.Stdout) if *debugFile != "" { file, err := os.Create(*debugFile) if err != nil { fmt.Printf("Error! %s\n", err) return } w := bufio.NewWriter(file) fs.DebugWrite(w, "") w.Flush() file.Close() } if *rpcFile != "" { file, err := os.Create(*rpcFile) if err != nil { fmt.Printf("Error creating: %s\t%s\n", *rpcFile, err) os.Exit(1) } encoder := gob.NewEncoder(file) encoder.Encode(fs) file.Close() } prev_fs = fs time.Sleep(sleepDuration) } }