func main() {
// Setup flag arguments.
f0 := flag.String("formats", defaultFormats(), "List of formats to benchmark")
f1 := flag.String("tests", defaultTests(), "List of different benchmark tests")
f2 := flag.String("codecs", defaultCodecs(), "List of codecs to benchmark")
f3 := flag.String("paths", defaultPaths(), "List of paths to search for test files")
f4 := flag.String("files", defaultFiles(), "List of input files to benchmark")
f5 := flag.String("levels", defaultLevels, "List of compression levels to benchmark")
f6 := flag.String("sizes", defaultSizes, "List of input sizes to benchmark")
flag.Parse()
// Parse the flag arguments.
var sep = regexp.MustCompile("[,:]")
var codecs, paths, files []string
var formats, tests, levels, sizes []int
codecs = sep.Split(*f2, -1)
paths = sep.Split(*f3, -1)
files = sep.Split(*f4, -1)
for _, s := range sep.Split(*f0, -1) {
if _, ok := fmtToEnum[s]; !ok {
panic("invalid format")
}
formats = append(formats, fmtToEnum[s])
}
for _, s := range sep.Split(*f1, -1) {
if _, ok := testToEnum[s]; !ok {
panic("invalid test")
}
tests = append(tests, testToEnum[s])
}
for _, s := range sep.Split(*f5, -1) {
lvl, err := strconv.ParsePrefix(s, strconv.AutoParse)
if err != nil {
panic("invalid level")
}
levels = append(levels, int(lvl))
}
for _, s := range sep.Split(*f6, -1) {
var size int
if nf, err := strconv.ParsePrefix(s, strconv.AutoParse); err == nil {
size = int(nf)
}
sizes = append(sizes, size)
}
ts := time.Now()
bench.Paths = paths
runBenchmarks(files, codecs, formats, tests, levels, sizes)
te := time.Now()
fmt.Printf("RUNTIME: %v\n", te.Sub(ts))
}
func ExampleParsePrefix() {
if s, err := strconv.ParsePrefix("2.99792458E8", strconv.AutoParse); err == nil {
fmt.Printf("Speed of light: %.0fm/s\n", s)
}
if s, err := strconv.ParsePrefix("616.379k", strconv.SI); err == nil {
fmt.Printf("Distance from LA to SF: %.0fm\n", s)
}
if s, err := strconv.ParsePrefix("32M", strconv.Base1024); err == nil {
fmt.Printf("Max FAT12 partition size: %.0fB\n", s)
}
if s, err := strconv.ParsePrefix("1Ti", strconv.IEC); err == nil {
fmt.Printf("Number of bytes in tebibyte: %.0fB\n", s)
}
// Output:
// Speed of light: 299792458m/s
// Distance from LA to SF: 616379m
// Max FAT12 partition size: 33554432B
// Number of bytes in tebibyte: 1099511627776B
}
func main() {
// Basic user configuration variables
force := pflag.BoolP("force", "f", false, "Force output to terminal.")
count := pflag.StringP("count", "n", "+Inf", "Number of random bytes to generate.")
procs := pflag.IntP("procs", "p", runtime.NumCPU(), "Maximum number of concurrent workers.")
pflag.Parse()
if !(*force) && terminal.IsTerminal(int(os.Stdout.Fd())) {
fmt.Fprintf(os.Stderr, "Random data not written to terminal.\n\n")
pflag.Usage()
os.Exit(1)
}
cnt, err := strconv.ParsePrefix(*count, strconv.AutoParse)
if err != nil || math.IsNaN(cnt) {
fmt.Fprintf(os.Stderr, "Number of bytes to generate is invalid.\n\n")
pflag.Usage()
os.Exit(1)
}
if (*procs) < 1 {
fmt.Fprintf(os.Stderr, "Number of workers must be positive.\n\n")
pflag.Usage()
os.Exit(1)
}
runtime.GOMAXPROCS(*procs)
rand.SetNumRoutines(*procs)
// Copy random data to stdout
if int64(cnt) < 0 || math.IsInf(cnt, 0) {
_, err = io.Copy(os.Stdout, rand.Reader)
} else {
_, err = io.CopyN(os.Stdout, rand.Reader, int64(cnt))
}
if perr, ok := err.(*os.PathError); ok && perr.Err == syscall.EPIPE {
err = nil // Expected error is for the sink to close the pipe
} else if err != nil {
panic(err)
}
}
