.Net (C#) Async x Parallel Performance

Question

.Net is very helpful to program asynchronous and parallel. There are some good articles about that like this

But what is the best and in which context? I have just created a simple console application to try to figure out. It looks like async and await is faster, but it consumes more memory. This was the average result repeating the test three times in the same machine (CPU = AMD FX 8120 Eight-Core Processor 3,1GHz and RAM = 16GB):

---

Asynchronous Elapsed Time(s) = 23,0841498667 | Memory (MB) = 62154

---

Parallel Elapsed Time(s) = 107,9682892667 | Memory (MB) = 27828

---

The code is in GitHub and it is very simple.

The code requests webpages 250 times.

The Asynchronous test is that:

    public async static Task AsynchronousTest()
    {
        List<Task<string>> taskList = new List<Task<string>>();

        for (int i = 0; i < TOTAL_REQUEST; i++)
        {
            Task<string> taskGetHtmlAsync = GetHtmlAsync(i);
            taskList.Add(taskGetHtmlAsync);
        }

        await Task.WhenAll(taskList);

        //Trying to free memory
        taskList.ForEach(t => t.Dispose());
        taskList.Clear();
        taskList = null;
        GC.Collect();
    }

    public async static Task<string> GetHtmlAsync(int i)
    {
        string url = GetUrl(i);

        using (HttpClient client = new HttpClient())
        {
            string html;

            html = await client.GetStringAsync(url);

            Trace.WriteLine(string.Format("{0} - OK (Html Length {1})", i + 1, html.Length));
            return html;
        }
    }

And the parallel test is this:

    public static void ParallelTest()
    {
        Parallel.For(0, TOTAL_REQUEST, i =>
        {
            string html = GetHtml(i);
        });
    }

    public static string GetHtml(int i)
    {
        string html = null;

        string url = GetUrl(i);

        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);

        using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
        {
            using (Stream receiveStream = response.GetResponseStream())
            {
                using (StreamReader readStream = new StreamReader(receiveStream, Encoding.UTF8))
                {
                    html = readStream.ReadToEnd();
                }
            }
        }

        Trace.WriteLine(string.Format("{0} - OK (Html Length {1})", i + 1, html.Length));

        return html;
    }

So, is there any way to improve the memory performance of the async/await method?

Answer 1

It's using more memory because you're keeping the tasks and results in memory, while in the parallel test, you're not.

To be more equivalent, the parallel test might look like this:

public static void ParallelTest()
{
    List<string> results = new List<string>();
    Parallel.For(0, TOTAL_REQUEST, i =>
    {
        string html = GetHtml(i);
        lock(results)
            results.Add(html);
    });
}

I would expect the parallel test to still consume less memory, but not by as much as you currently have.

If you want to download the results, and process them only after all requests have completed, then there isn't much you can do to speed it up.

However, if you're able to immediately process results, you're in a much better position. Take this for example:

public async static Task AsynchronousTest()
{
    for (int i = 0; i < TOTAL_REQUEST; i++)
    {
        var result = await GetHtmlAsync(i);
        File.WriteAllText($"SomeFile {i}.txt", result);
    }
}

Your memory consumption will be drastically reduced, as you're not keep all the requests in memory any more; you're processing them and discarding them as you go.

Of course, the parallel equivalent might be:

public static void ParallelTest()
{
    Parallel.For(0, TOTAL_REQUEST, i =>
    {
        string html = GetHtml(i);
        File.WriteAllText($"SomeFile {i}.txt", html);
    });
}

Onto the reported times you're seeing. I find it very surprising that async is much faster than a threaded approach. Turns out, it's because of caching. Let's turn that off:

GetHtmlAsync

using (HttpClient client = new HttpClient(new WebRequestHandler { CachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.BypassCache) }))

GetHtml

HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
request.CachePolicy = new RequestCachePolicy(RequestCacheLevel.BypassCache);

Threading is 2-3x faster (for 10 items). Sounds a bit more reasonable. The thing is, async is typically used to run processes in the background so as to not block the UI thread. Parallel.For, however, is smarter about the threads is spins up, and is typically the number of cores on your computer (+- other factors).

In conclusion:

Threading is probably the better approach here. It's the better tool for the job (where you know you're mainly limited by Net/IO, rather than CPU). You're seeing a higher memory count because of the async overhead as well as storing the results, which I mentioned above.

Answer 2

I have found this link showing that the short lived object HttpClient will leave the memory Leak, so that is the problem with HttpClient using inside a for loop.

I have also improved the test to use a local Asp.net 5 webapi async method to answer the request(In that way the test is not impacted for the web servers, for any reason):

[Route("api/[controller]")]
public class ValuesController : Controller
{
    [HttpGet]
    public async Task<IEnumerable<string>> Get()
    {
        await Task.Delay(1000);

        return new string[] { "value1", "value2" };
    }
}

I have run the test in some different context and the results are on this table:

+--------------------------------------+------------+------------------+------------------+ | | Request | 100 | 500 | +---------------------------------------+------------+------------------+------------------+ | synchronous | Elapsed(s) | 101,5830302 | 507,6880514 | | | Memory(MB) | 15390,6666666667 | 18693,3333333333 | | | Threads | 6 | 6,6666666667 | | asynchronous (WebRequest) | Elapsed(s) | 9,0738118667 | 25,3127221 | | | Memory(MB) | 18530,6666666667 | 20276 | | | Threads | 27 | 42,6666666667 | | asynchronous (Httpclient) | Elapsed(s) | 1,2210176 | 1,6143776333 | | | Memory(MB) | 20880 | 30293,3333333333 | | | Threads | 28 | 29 | | asynchronous (Httpclient Memory Leak) | Elapsed(s) | 1,4515700667 | 1,4114106 | | | Memory(MB) | 21334,6666666667 | 32070,6666666667 | | | Threads | 28,3333333333 | 29 | | parallel (WebRequest) | Elapsed(s) | 12,1617405333 | 31,6620354333 | | | Memory(MB) | 18441,3333333333 | 20004 | | | Threads | 25 | 37 | | parallel (HttpClient) | Elapsed(s) | 15,9617157667 | 31,8756134 | | | Memory(MB) | 19612 | 14834,6666666667 | | | Threads | 36,3333333333 | 41,6666666667 | +---------------------------------------+------------+------------------+------------------+

The fastest result was using asynchronous and HttpClient. The good performance with good memory was using parallel and HttpClient.