7000 Concurrent Connections With Asynchronous WCF

It’s rare that a web service has some intensive processor bound computation to execute. Far more common for business applications, is a web service that executes one or more IO intensive operations. Typically our web service would access a database over the network, read and write files, or maybe call another web service. If we execute these operations synchronously, the thread that processes the web service request will spend most of its time waiting on IO. By executing IO operations asynchronously we can free the thread processing the request to process other requests while waiting for the IO operation to complete.

In my experiments with a simple self-hosted WCF service, I’ve been able to demonstrate up to 7000 concurrent connections handled by just 12 threads.

Before I show you how to write an asynchronous WCF service, I want to clear up the commonly held misconception (yes, by me too until a year or so ago), that asynchronous IO operations spawn threads. Many of the APIs in the .NET BCL (Base Class Library) provide asynchronous versions of their methods. So, for example, HttpWebRequest has a BeginGetResponse / EndGetResponse method pair alongside the synchronous method GetResponse. This pattern is called the Asynchronous Programming Model (APM). When the APM supports IO operations, they are implemented using an operating system service called IO Completion Ports (IOCP). IOCP provides a queue where IO operations can be parked while the OS waits for them to complete, and provides a thread pool to handle the completed operations. This means that in-progress IO operations do not consume threads.

The WCF infrastructure allows you to define your operation contracts using APM. Here’s a contract for a GetCustomer operation:

[ServiceContract(SessionMode = SessionMode.NotAllowed)]
public interface ICustomerService
{
    [OperationContract(AsyncPattern = true)]
    IAsyncResult BeginGetCustomerDetails(int customerId, AsyncCallback callback, object state);
    Customer EndGetCustomerDetails(IAsyncResult asyncResult);
}

Essentially ‘GetCustomerDetails’ takes a customerId and returns a Customer. In order to create an asynchronous version of the contract I’ve simply followed the APM pattern and created a BeginGetCustomerDetails and an EndGetCustomerDetails. You tell WCF that you are implementing APM by setting AsyncPattern to true on the operation contract.

The IAsyncResult that’s returned from the ‘begin’ method and passed as an argument to the ‘end’ method links the two together. Here’s a simple implementation of IAsyncResult that I’ve used for these experiments, you should be able to use it for any asynchronous WCF service:

public class SimpleAsyncResult<T> : IAsyncResult
{
    private readonly object accessLock = new object();
    private bool isCompleted = false;
    private T result;

    public SimpleAsyncResult(object asyncState)
    {
        AsyncState = asyncState;
    }

    public T Result
    {
        get
        {
            lock (accessLock)
            {
                return result;
            }
        }
        set
        {
            lock (accessLock)
            {
                result = value;
            }
        }
    }

    public bool IsCompleted
    {
        get
        {
            lock (accessLock)
            {
                return isCompleted;
            }
        }
        set
        {
            lock (accessLock)
            {
                isCompleted = value;
            }
        }
    }

    // WCF seems to use the async callback rather than checking the wait handle
    // so we can safely return null here.
    public WaitHandle AsyncWaitHandle { get { return null; } }

    // We will always be doing an async operation so completed synchronously should always
    // be false.
    public bool CompletedSynchronously { get { return false; } }

    public object AsyncState { get; private set; }
}

Now we’ve got an AsyncResult we can implement our APM based service by implementing ICustomerService:

[ServiceBehavior(
    InstanceContextMode = InstanceContextMode.PerCall,
    ConcurrencyMode = ConcurrencyMode.Multiple)]
public class CustomerService : ICustomerService
{
    public const int DelayMilliseconds = 10000;

    public IAsyncResult BeginGetCustomerDetails(int customerId, AsyncCallback callback, object state)
    {
        var asyncResult = new SimpleAsyncResult<Customer>(state);

        // mimic a long running operation
        var timer = new System.Timers.Timer(DelayMilliseconds);
        timer.Elapsed += (_, args) =>
        {
            asyncResult.Result = GetCustomer(customerId);
            asyncResult.IsCompleted = true;
            callback(asyncResult);
            timer.Enabled = false;
            timer.Close();
        };
        timer.Enabled = true;
        return asyncResult;
    }

    public Customer EndGetCustomerDetails(IAsyncResult asyncResult)
    {
        return ((SimpleAsyncResult<Customer>) asyncResult).Result;
    }

    private static Customer GetCustomer(int customerId)
    {
        return new Customer(customerId, "Mike_" + customerId);
    }
}

We’re mimicking a long running IO operation by using a timer. I believe that the Timer also uses an IO completion port, but don’t quote me on that. When WCF invokes BeginGetCustomerDetails we first create a new SimpleAsyncResult with WCF’s state object. WCF will pass the AsyncResult to the EndGetCustomerDetails method when the timer completes, so we can use it to pass any response state. In our case this is an instance of Customer.

Next we set up a Timer and attach a closure to the Elapsed event. When the timer’s Elapsed event fires we create a customer instance, pass it to our AsyncResult and then pass the AsyncResult to WCF’s callback function.

After the BeginGetCustomerDetails method completes, WCF returns its thread back to the WCF thread pool so that it can service other requests. Ten seconds later, the operating system posts an item on to the IOCP queue, a thread from the pool picks up the item and executes the continuation. This in turn calls WCF’s callback which in turn executes EndGetCustomerDetails. WCF then packages up the Customer as a SOAP response and returns it to the client.

Only a tiny fraction of that 10 seconds has actually occupied a thread, so we should be able to make thousands of concurrent calls to this service.

In my tests, this service has been able to handle a little over 7000 concurrent connections.

The code is here: https://github.com/mikehadlow/Mike.AsyncWcf

Just follow the README instructions to run the tests and try it out for yourself.