ReusableTasks 0.0.1

Introduction.

ReusableTasks provides three classes.

• ReusableTask - a zero allocation Task-like object which can be used in place of System.Threading.Tasks.Task when declaring async methods.
• ReusableTask<T> - a zero allocation Task-like object which can be used in place of System.Threading.Tasks.Task<T> when declaring async methods.
• ReusableTaskCompletionSource<T> - a zero allocation TaskCompletionSource-like object, built on top of ReusableTask<T<>, which can be used in place of System.Threading.Tasks.TaskCompletionSource<T> in scenarios where you would normally repeatedly instantiate new copies of TaskCompletionSource<T>.

Migration examples:

Change your async method declarations as follows:

async Task Old ()
{
    await Task.Delay (100); // Do Stuff
}

async ReusableTask New ()
{
    await Task.Delay (100); // Do Stuff
}

async Task<int> Old ()
{
    await Task.Delay (100); // Do Stuff
    return 5;
}

async ReusableTask<int> New ()
{
    await Task.Delay (100); // Do Stuff
    return 5;
}

Limitations

The caching strategy employed by ReusableTask means you cannot await a task twice. This kind of code would either deadlock or cause corruption of the ReusableTask cache:

public async ReusableTask<int> CalculateAge ()
{
    await Task.Delay (100); // Do Stuff
    return 42;
}

async void CorruptCache ()
{
    var task = CalculateAge  ();
    Task.Run (async () => await task);
    Task.Run (async () => await task);
}

ReusableTaskCompletionSource<int> has the same limitation, the returned task should not have multiple concurrent awaits:

public async void CorruptTCS ()
{
    var tcs = new ReusableTaskCompletionSource<int> ();
    
    Task.Run (async () => await tcs.Task);
    Task.Run (async () => await tcs.Task);

    tcs.SetResult (5);
}

async void SafelyReuseTCS ()
{
    var tcs = new ReusableTaskCompletionSource<int> ();

    async void SetResultEverySecond ()
    {
        for (int i = 0; i < 100; i ++) {
            await Task.Delay (1000);
            tcs.SetResult (i);
        }
    }

    SetResultEverySecond ();
    while (true) {
         Console.WriteLine ("Current iteration is: {0}", await tcs.Task);
    }
}

NOTE: In real code you should ensure that the await completes before you invoke SetResult, SetException or SetCanceled a second time. This ensures that you never have two concurrent await calls.

public async ReusableTask<int> CalculateAge ()
{
    return 42;
}

async void SafelyAwait ()
{
    var task = CalculateAge  ().AsTask ();
    await task;
    await task;
}

Real world benefits

MonoTorrent is currently testing a prototype of this approach and the benefits are pretty noticeable. More detailed profiling results are on the MonoTorrent pull request, but the latest results at the time of writing total allocations were reduced from 980MB to 210MB while downloading two 2GB torrents.