Hey my app doesn't scale! ____ Framework sucks! Well, you can write a slow app in any language. This talk will show you why your app isn't scaling and gives you the DOs and the DON'Ts of making big apps do big things in ASP.NET Core.
What do we mean by “scale”? • Scale is a measure of user/request/connections per scale- unit (machine, container etc) • If you do nothing, you can scale it infinitely – Scott Hanselman
Types of scaling • Horizontal scale (scaling out) • Adding more units of scale (machines/VMs/containers etc) • Vertical scale (scaling up) • Adding more capable resources to an existing scale unit (CPU, memory, bandwidth)
What affects scale • CPU • Hot paths in your application • Contended locks • Memory • Memory leaks (work isn’t cleaning up properly when complete) • Inefficient memory usage (using more memory than expected for the work) • IO • Ephemeral port exhaustion • Running out of disk/storage space • Blocking • Bandwidth & latency
Async Programming • Doing async right can increase scalability • Doing async wrong can severely decrease scalability • .NET has lots of async traps • The number one rule is DON’T BLOCK
Load testing • Scale issues usually show up when it’s too late • It’s important to figure out how much load your application can handle • For a fixed RPS, monitor CPU usage and memory usage • Understand how much each scale unit in your deployment can handle (e.g. each VM can handle 1000 RPS)
ThreadPool • Sync over async • APIs that masquerade as synchronous but are actually blocking async methods • Uses 2 threads to complete a single operation • Blocking APIs are BAD • Avoid blocking APIs where possible e.g. Task.Wait, Task.Result, Thread.Sleep, GetAwaiter.GetResult() • Excessive blocking on thread pool threads can cause starvation • Thread injection rate beyond configured max is slow (2 per second)
Highly contended locks • Web applications are highly concurrent • Highly contended locks can be a death knell for scalable services • Lock contention is sometimes hard to look at in basic profilers • Visual Studio Concurrency Visualizer • dotTrace timeline view • Prefer concurrent data structures • Understand which operations take locks and which operations are lock free • Know what BCL APIs take locks on your behalf • String.Intern • System.Drawing (GDI)
GC issues • Allocating memory is very cheap, collecting it isn’t • Allocating lots of memory can lead to GC pauses • Allocating objects over 85KB in size ends up on the LOH (large object heap) • The LOH is collected with Gen2 but not compacted (by default)
TimerQueue • There’s a TimerQueue per CPU Core • Timers within a TimerQueue form a linked list • Timers are optimized for adding and removing • Timer callbacks are scheduled to the thread pool • Each TimerQueue is protected by a lock • Disposing the timer removes it from the queue
Future Enhancements • Improved documentation on how to scale web services • Improvements to the thread pool to better handle blocking workers • Analyzers to catch common mistakes with asynchronous programming • Tools to help better diagnose common issues • Async hangs • Thread pool starvation • More counters in .NET Core • Reduce the amount of .NET async traps • IAsyncDisposable • FileStream (sync over async)
davidfowl
yoshikikomoriya
microcms
doradora09
newrelic2023
daihiraoka
bnasslahsen
ryomaru0825
sinsoku
eiki
ryohatanmonolog
ymty
nenonaninu
pedronauck
lauravandoore
palkan
chrisshort
62gerente
ddemaree
quramy
jonrohan
marcelosomers
davidbonilla
jmmastey
tmm1