Async Debugging - A Practical Guide to survive !

Async Debugging - A Practical
Guide to survive !
@MircoVanini
www.proxsoft.it
Mirco Vanini
Microsoft MVP Windows Developer

• Sync To Async Code
• Async state machine
• Async logical call stack (chain of continuations)
• Debug
• Parallel Stacks for Tasks and Theads
• Tasks Window
• Threads Window
• Parallel Watch
• Rethrown Exceptions
• Snapshot on Exception (IntelliTrace -> Historical Debugger)
• Async Guidance
• Q&A
Agenda

Start plain and simple
public double GetTotalOderedByCustomer(string customer)
{
double total = 0;
foreach (var order in GetOrdersByCustomer(customer))
{
var details = order.GetOrderDetails();
total += details.Sum(d => d.Quantity * d.UnitPrice);
}
return total;
}
Everythings is frozen and we
are doomed !
…How about adding some
async/await ?

Compiler generated code
public async Task<double> GetTotalOderedByCustomerAsync(string customer)
{
double total = 0;
foreach (var order in await GetOrdersByCustomerAsync(customer))
{
var details = await order.GetOrderDetailsAsync();
}
return total;
}
[AsyncStateMachine(typeof(<GetTotalOderedByCustomerAsync>d__0))]
[DebuggerStepThrough]
public Task<double> GetTotalOderedByCustomerAsync(string customer)
{
<GetTotalOderedByCustomerAsync>d__0 stateMachine = new
<GetTotalOderedByCustomerAsync>d__0();
stateMachine.<>t__builder = AsyncTaskMethodBuilder<double>.Create();
stateMachine.<>4__this = this;
stateMachine.customer = customer;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}

Compiler generated code
public async Task<double>
GetTotalOderedByCustomerAsync(string customer)
{
double total = 0;
foreach (var order in await
GetOrdersByCustomerAsync(customer))
{
total += details.Sum(d => d.Quantity *
d.UnitPrice);
}
return total;
}
[CompilerGenerated]
private sealed class <GetTotalOderedByCustomerAsync>d__0 : IAsyncStateMachine
{
public int <>1__state;
public AsyncTaskMethodBuilder<double> <>t__builder;
// local variables !
public string customer;
public DataService <>4__this;
private double <total>5__1;
...
// awaiters !
private TaskAwaiter<IEnumerable<Order>> <>u__1;
private TaskAwaiter<IEnumerable<OrderDetail>> <>u__2;
private void MoveNext()
{
int num = <>1__state;
double result;
try
{
TaskAwaiter<IEnumerable<Order>> awaiter;
if (num != 0)
{
if (num == 1)
{
goto IL_00c4;
}
<total>5__1 = 0.0;
awaiter = <>4__this.GetOrdersByCustomerAsync(customer).GetAwaiter();

Without Await
public Task<double> GetTotalOderedByCustomerWithoutAwait(string customer)
{
ConcurrentBag<double> totals = new ConcurrentBag<double>();
Task<IEnumerable<Order>> fetchOrders = Task.Run(() => GetOrdersByCustomer(customer));
Task matchOrders = fetchOrders.ContinueWith(t =>
{
List<Task> matchTasks = new();
foreach (var order in t.Result)
{
Task<IEnumerable<OrderDetail>> detailTask = Task.Run(() => order.GetOrderDetails());
Task matchDetail = detailTask.ContinueWith(t1 =>
{
totals.Add(t1.Result.Sum(d => d.Quantity * d.UnitPrice));
}, TaskContinuationOptions.AttachedToParent);
matchTasks.Add(matchDetail);
}
return Task.WhenAll(matchTasks);
});
return matchOrders.ContinueWith(_ => totals.Sum(p => p));
}

Async code – call stack
Debug > Windows > Call stack | Debug > Windows > Threads > main thread)

Async code – call stack
Debug > Windows > Parallel Stacks > Threads

Async logical call stack
The first thing used while debugging are «call stacks»
Call stack show caller -> callee relation !
We also need call stack fro async code – such as «async call stacks»
So how do we debug this ?

Async vs sync stacks
SYNC stacks ASYNC stacks
Code is currently running on a thread Code may not be running anywhere or
scheduled to run in the future
Hence – Physical stacks Virtual or logical stacks. Not tied to a single
(or any) thread.
Locals are allocated on stack memory Local are stashed in “state machines”
(internal compiler generated helper
structures)

Async call stacks
Task #1
GetOrderByCustomerAsync()
m_continuation
public async Task<double> GetTotalOderedByCustomerAsync(string customer)
{
double total = 0;
foreach (var order in await GetOrdersByCustomerAsync(customer))
{
}
return total;
}
Task #2
GetOrderDetailsAsync()
m_continuation
Here the await keyword adds the next line of GetTotalOrderedByCutomerAsync
as a continuation to GetOrdersByCustomerAsync.
The Task of GetOderDetailsAsync store a reference to the next line of
GetTotalOrderedByCutomerAsync to invoke when done.

Async call stacks
Task #1
m_continuation
Task #2
m_continuation
The debugger walks through this chain of references – to get a chain of
continuations
Async Logical Stacks
GetOrderDetailsAsync
GetOrderByCustomerAsync
The chian of continuations is what we call async call stack

Async call stacks
Task #1
m_continuation
Task #2
m_continuation
Async stack are a continuation stack
This may be quite different from the stack or context of where the task
was created – that is, the creation stack
Task #N
...
m_continuation

Creation Stack vs Continuation Stack
Note that TakeABreak is not part of the async call stack
Async Task
> Task.Delay(…)
DoSomething(…)
public Task TakeABreak()
{
return Task.Delay(1000);
}
public async Task DoSomething()
{
foreach (var order in orders)
{
Task pause = TakeABreak():
details = await order.GetOrderDetails();
await pause;
}
}
??? TakeABreak(…) ???

Creation Stack vs Continuation Stack
Sync call stack are also really just continuation stack: the creation (call) and
continuation are the same
In async, control goes to whoever awaits (or waits) the current async code,
which may be different from the scope or method in which it was called.
Keep that in mind while async debugging – especially while using
TaskCompletitionSource<T> [used for APM (Asynchronous Programming
Model) or EAP (Event-Based Asynchronous Pattern)].

Async call stacks
public async Task DoSomething()
{
List<Task> tasks = new List<Task>();
foreach (var order in orders)
{
tasks.Add(order.GetOrderDetailsAsync());
}
await Task.WhenAll(tasks);
}
Task #1
m_continuation
Task #2
m_continuation
Task #2
m_continuation
Task #1
DoSomething()
m_continuation

Parallel Stacks for Tasks and Theads

Tasks Window – Threads Window

Rethrown Exceptions / Snapshot on Exception

• Async void
• Prefer Task.FromResult over Task.Run for pre-computed or trivially computed data
• Avoid using Task.Run for long running work that blocks the thread
• Avoid using Task.Result and Task.Wait
• Prefer await over ContinueWith
• Always create TaskCompletionSource<T> with
TaskCreationOptions.RunContinuationsAsynchronously
• Always dispose CancellationTokenSource(s) used for timeouts
• Always flow CancellationToken(s) to APIs that take a CancellationToken
• Cancelling uncancellable operations
• Always call FlushAsync on StreamWriter(s) or Stream(s) before calling Dispose
• Prefer async/await over directly returning Task
• ConfigureAwait
Async Code Tips
The first debugging step is writing good code !
AsyncGuidance

Question Time
myContactInfo:
{
”e-mail”:“mirco.vanini@proxsoft.it”,
“web”: “www.proxsoft.it”,
“twitter”: “@MircoVanini”
}
Mirco Vanini
Microsoft MVP Windows Developer

Async Debugging - A Practical Guide to survive !

Recommended

More Related Content

What's hot (20)

Similar to Async Debugging - A Practical Guide to survive ! (20)

More from Mirco Vanini (20)

Recently uploaded (20)

Async Debugging - A Practical Guide to survive !