Async Task with WhenAll() performance is off.

Question

Can anyone explain to me why my TIMINGS for test #2 operation is so SCREWED up
370ms
310ms  <---  this one should not be this slow.
143ms
119ms
I have two methods...BOTH write the exact same byte array to a specified filename....(I've tried 5M & 10M file)
One is synchronous and uses stream.write()
using (FileStream strm = new FileStream(path, FileMode.Create, FileAccess.Write,
FileShare.None, 4096, useAsync: false))
strm.Write(text, 0, text.Length);
...the other is async and uses await stream.WriteAsync
public static async Task WriteBigFileAsync(string path,
byte[] text)
using (FileStream strm = new FileStream(path, FileMode.Create, FileAccess.Write,
FileShare.None, 4096, useAsync: true))
await strm.WriteAsync(text, 0, text.Length);
4 different test methods:
1 calls Synch method x times. (set at 25 right now)
for (int i = 0; i < numTimes; i++)
WriteBigFile(Path.Combine(dir,
Path.GetRandomFileName()), text);
Next calls Asynch x times....firing all of them concurrently (if poss)...and then waiting until all are complete
var tasks = new List<Task>();
for (int i = 0; i < numtimes; i++)
Task t = WriteBigFileAsync(Path.Combine(dir, Path.GetRandomFileName()), text);
tasks.Add(t);
await Task.WhenAll(tasks.ToArray());
3rd uses PLINQ to throw them out to the thread pool, but calls Synchronous method
Parallel.For(0, numTimes, (x) => WriteBigFile(Path.Combine(dir, Path.GetRandomFileName()), text));
4rd is the same but calls Asynchronous method.
Parallel.For(0, numTimes, async (x) => await WriteBigFile(Path.Combine(dir, Path.GetRandomFileName()), text));
I KNOW that the best practice method for I/O intensive operations is to use async await.
I KNOW that Parallel.For has the potential to gain great performance, but at the expense of a bunch of new threads which will just end up SITTING there while the file writes anyway.
But WHY is the performance for the Asynchronous call so poor?
And ideas would be appreciated.

Answer 1

>I KNOW that the best practice method for I/O intensive operations is to use async await.
But you need to understand _why_ it's a best practice.  Writing to a file using asynchronous IO is no faster than writing with synchronous IO.  The only difference is whether your thread blocks while waiting on the IO to complete.  Not blocking
threads can help make your middle tier application scale better, and it can help keep a UI responsive.  But it doesn't make the IO any faster.
All these methods are going to be gated by the throughput of your storage device, not your choice of API.
David
David http://blogs.msdn.com/b/dbrowne/