为什么goroutines不使用WriteAt并行编写？

I'm experimenting a bit with reading and writing from a file. To write to a file concurrently I created the following function:

func write(f *os.File, b []byte, off int64, c chan int) {
    var _, err = f.WriteAt(b, off)
    check(err)
    c <- 0
}

I then create a file and 100000 goroutines to perform the write operations. They each write an array of 16384 bytes to the hard disk:

func main() {
    path := "E:/test"
    f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0666)
    check(err)

    size := int64(16384)
    ones := make([]byte, size)

    n := int64(100000)
    c := make(chan int, n)

    for i := int64(0); i < size; i++ {
        ones[i] = 1
    }

    // Start timing
    start := time.Now()

    for i := int64(0); i < n; i++ {
        go write(f, ones, size*i, c)
    }

    for i := int64(0); i < n; i++ {
        <-c
    }

    // Check elapsed time
    fmt.Println(time.Now().Sub(start))

    err = f.Sync()
    check(err)
    err = f.Close()

    check(err)
}

In this case about 1.6 GB is written where each goroutine writes to a non-overlapping byte range. The documentation for the io package states that Clients of WriteAt can execute parallel WriteAt calls on the same destination if the ranges do not overlap. So what I expect to see, is that when I use go write(f, ones, 0, c), it would take much longer since all write operations would be on the same byterange.

However after testing this my results are quite unexpected:

Using go write(f, ones, size*i, c) took an average of about 3s

But using go write(f, ones, 0, c) only took an average of about 480ms

Do I use the WriteAt function in the wrong way? How could i achieve concurrent writing to non-overlapping byteranges?