func run()

in benchmarks/write_locally/main.go [41:127]
63 lines of code
9 McCabe index (conditional complexity)

func run() (err error) {
	if *fDir == "" {
		err = errors.New("you must set --dir")
		return
	}

	// Create a temporary file.
	log.Printf("creating a temporary file in %s.", *fDir)

	f, err := os.CreateTemp(*fDir, "write_locally")
	if err != nil {
		err = fmt.Errorf("tempFile: %w", err)
		return
	}

	path := f.Name()

	// Make sure we clean it up later.
	defer func() {
		log.Printf("Truncating and closing %s.", path)
		_ = f.Truncate(0)
		_ = f.Close()

		log.Printf("Deleting %s.", path)
		_ = os.Remove(path)
	}()

	// Extend to the initial size.
	log.Printf("Truncating to %d bytes.", *fFileSize)

	err = f.Truncate(*fFileSize)
	if err != nil {
		err = fmt.Errorf("truncate: %w", err)
		return
	}

	// Repeatedly overwrite the file with zeroes.
	log.Println("Measuring...")

	var bytesWritten int64
	var writeCount int64

	buf := make([]byte, *fWriteSize)
	start := time.Now()

	for time.Since(start) < *fDuration {
		// Seek to the beginning.
		_, err = f.Seek(0, 0)
		if err != nil {
			err = fmt.Errorf("seek: %w", err)
			return
		}

		// Overwrite.
		var n int64
		for n < *fFileSize && time.Since(start) < *fDuration {
			var tmp int
			tmp, err = f.Write(buf)
			if err != nil {
				err = fmt.Errorf("write: %w", err)
				return
			}

			n += int64(tmp)
			bytesWritten += int64(tmp)
			writeCount++
		}
	}

	d := time.Since(start)

	// Report.
	seconds := float64(d) / float64(time.Second)
	writesPerSec := float64(writeCount) / seconds
	bytesPerSec := float64(bytesWritten) / seconds

	fmt.Printf(
		"Wrote %d times (%s) in %v (%.1f Hz, %s/s)\n",
		writeCount,
		format.Bytes(float64(bytesWritten)),
		d,
		writesPerSec,
		format.Bytes(bytesPerSec))

	fmt.Println()
	return
}