StreamWriter: (Write+Flush)Async seem much slower then synchronous variants

Question

I was trying to find an IO bottleneck in my class and surprisingly noticed that sw.Write("m"); sw.Flush() can be 20000 faster then await sw.WriteAsync("m"); Await sw.FlushAsync(); when writing 1000000 messages to a file. Does, by any chance, anyone know why? My bet is StreamWriter's constructor taking a String does not parametrize a stream for async usage.

The code below can be launched from C# interactive. Yes, it's not the best place to measure the speed but it will show the matter at hand anyway:

var sr = new StreamWriter("G:\\file.file");
var N = 1000;
var sw = new Stopwatch();
sw.Start();

for (var i = 0; i < N; ++i)
{
    sr.Write("m"); // or await sr.WriteAsync("m");
    sr.Flush(); // or await sr.FlushAsync("m");
}

sw.Stop();
Console.WriteLine("Completed " + N
    + " iterations in " + sw.ElapsedMilliseconds + " milliseconds.");

sr.Close();

Launched on my home PC from C# Interactive the output is

Completed 1000 iterations in 1 milliseconds.

for synchronous code and

Completed 1000 iterations in 43383 milliseconds.

for asynchronous.

Update: Also I've noticed that the program slows down inside FlushAsync. WriteAsync works nearly at the same speed as the synchronous version.

All comments are welcome.

Update 2*: As @Cory Nelson mentioned in comments to his answer, FileStream.FlushAsync is a fake async that is implemented with Task.Factory.StartNew, so it adds nothing useful but overhead. When working with short messages the overhead becomes large enough compared to the work being done, thus slowing the execution.

Possibly see [this answer](http://stackoverflow.com/a/18335900/4372746). Also, surely you could have just waited the two hours to form a complete post? — Glorin Oakenfoot, Jan 31 '17 at 17:46
@Glorin Oakenfoot thanks for the link. Yeap, my bad, but I was worried that I can probably forget it :-( — Sergey.quixoticaxis.Ivanov, Jan 31 '17 at 17:52
I don't know why anybody would use an Async Write method. There is very little difference between Sync Write and Async Write. The Sync Write occurs so quickly it doesn't pay to go to Async. — jdweng, Jan 31 '17 at 18:09
@jdweng yeap, I'm already thinking about moving to synchronous writes if I don't crack this problem. — Sergey.quixoticaxis.Ivanov, Jan 31 '17 at 18:54
@Sergey.quixoticaxis.Ivanov you are already performing synchronous writes. If you are blocking until an asynchronous operation result returns, how can you think it would not perform worse than the more streamlined synchronous version? — Paul Childs, Mar 09 '22 at 02:06
@PaulChilds the question is super old, but AFAIR I was not expecting it not to be slower. I was expecting it to be slower, but fast enough to still be usable in most cases, which it is not. — Sergey.quixoticaxis.Ivanov, Mar 10 '22 at 15:36

score 8 · Accepted Answer · answered Jan 31 '17 at 19:08

8

StreamWriter, when given a file path, does not open its underlying stream in async mode. This is likely contributing to performance loss. If you're going to use it for async, you should be opening your own Stream:

Stream s = new FileStream("G:\\file.file", FileMode.Create, FileAccess.Write,
                          FileShare.None, 4096,
                          FileOptions.Asynchronous | FileOptions.SequentialScan);
StreamWriter sr = new StreamWriter(s);

Something additional to note is that your benchmark doesn't seem to capture real-world usage. Are you really writing single-character strings and flushing after each one?

Async does have a certain fixed amount of memory and GC overhead, and with such short-lived operations -- especially as StreamWriter.WriteAsync is not currently optimized for small writes -- you are bound to see much more overhead than a more common usage.

answered Jan 31 '17 at 19:08

Cory Nelson

29,236
5
72
110

I've tried to create a `Stream` manually but it still is much slower then synchronous version. Nope, I'm not writing single character strings, but I'm writing a short log messages. Also memory/GC overhead is not that important for me because other constructs with async operations are called a few million times in a second and everything is fine. – Sergey.quixoticaxis.Ivanov Jan 31 '17 at 21:04
3

Also I've noticed that the real problem is inside `FlushAsync`. `WriteAsync` works nearly at the same speed as synchronous version. – Sergey.quixoticaxis.Ivanov Jan 31 '17 at 21:09
2

`FlushAsync` on a `FileStream` is implemented with fake async, unfortunately. I'd expect it to not perform very well. – Cory Nelson Jan 31 '17 at 21:14

StreamWriter: (Write+Flush)Async seem much slower then synchronous variants

1 Answers1