Question

I have a .NET 4.5 WCF client app that uses the async/await pattern to make volumes of calls. My development machine is dual-proc with 8gb RAM (production will be 5 CPU with 8gb RAM at Amazon AWS) . The remote WCF service called by my code uses out and ref parameters on a web method that I need. My code instances a proxy client each time, writes any results to a public ConcurrentDictionary, and then returns null.

I ran Perfmon, watching the thread count on the system, and it goes between 28-30. It takes hours for my client to complete the volumes of calls that are made. Yes, hours. The remote service is backed by a big company, they have many servers to receive my WCF calls, so the more calls I can throw at them, the better.

I think that things are actually still happening synchronously, even though the method that makes the WCF call is decorated with “async” because the proxy method cannot have “await”. Is that true?

My code looks like this:

   async private void CallMe()
    {
    Console.WriteLine( DateTime.Now );
    var workTasks = this.AnotherConcurrentDict.Select( oneB => GetData( etcetcetc ).Cast<Task>().ToList();
    await Task.WhenAll( workTasks );
    }


    private async Task<WorkingBits> GetData(etcetcetc)
    {
    var commClient = new RemoteClient();
    var cpResponse = new GetPackage();
    var responseInfo = commClient.GetData( name, password , ref (cpResponse.aproperty), filterid , out cpResponse.Identifiers);
    foreach (var onething in cpResponse.Identifiers)
    { 
        // add to the ConcurrentDictionary
    }
    return null; // I already wrote to the ConcurrentDictionary so no need to return anything

responseInfo is not awaitable beacuse the WCF call has ref and out parameters.

I was thinking that way to speed this up is not to put async/await in this method, but instead create a wrapper method where I can make things await/async, but I am not that is the smartest/safest way to work it.

What is a smart way to get more outbound calls to the service (expand IO completion thread pool, trick calls into running in the background so Task.WhenAll can complete quicker)?

Thanks for all ideas/samples/pointers. I am hitting a bottleneck somewhere.

Answer 1

1) Make sure you’re really calling it asynchronously, rather than just blocking on the calls. Code samples would help here.
2) You may need to do this:

ServicePointManager.DefaultConnectionLimit = 100;

By default it only allows 2 simultaneous connections to the same server.
3) Make sure you dispose the proxy object after the call is complete so you’re not tying up resources.

If you’re doing things asynchronously the threadpool size shouldn’t be a bottleneck. To get a better idea of what kind of problem you’re having, you can use Interlocked.Increment and Interlocked.Decrement to track the number of pending calls and see if it’s being limited somewhere.

You could also substitute your real call with a call to a very simple method that you know will not have any bottlenecks, to see if the problem is in the client or server.