Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
awesome-dot-net-performance
A curated list of awesome .NET Performance books, courses, trainings, conference talks, blogs and most inspiring open source contributors. Inspired by awesome-... stuff.
https://github.com/adamsitnik/awesome-dot-net-performance
- Pro .NET Performance: Optimize Your C# Applications
- Pro .NET Memory Management: For Better Code, Performance, and Scalability
- Pro .NET Benchmarking: The Art of Performance Measurement
- CLR via C#
- Pro Asynchronous Programming with .NET
- Writing High-Performance .NET Code
- Advanced .NET Debugging
- Concurrent Programming on Windows
- .NET IL Assembler
- High-Performance Windows Store Apps
- Customizing the Microsoft® .NET Framework Common Language Runtime
- Under the Hood of .NET Memory Management
- Functional Concurrency in .NET
- Mastering .NET Performance Tuning
- Using Threads Effectively to Build Scalable, Responsive, and Fast .NET Applications and Components
- Making .NET Applications Faster
- Making .NET Applications Even Faster
- Measuring .NET Performance
- PerfView Tutorial
- Defrag Tools - Perf View
- High Performance Coding with .NET Core and C#
- part 1 - Tools/Defrag-Tools-34-CLR-GC-Part-2) [part 3](https://channel9.msdn.com/Shows/Defrag-Tools/Defrag-Tools-35-CLR-GC-Part-3) and [part 4](https://channel9.msdn.com/Shows/Defrag-Tools/Defrag-Tools-36-CLR-GC-Part-4) with Maoni Stephens
- .NET Async Expert
- .NET Memory Expert
- .NET Diagnostics Expert
- .NET Performance and Debugging Workshop
- .NET Performance
- Asynchronous Computing and Composing Asynchronous and Event-Based
- Parallel Programming with the TPL
- Solid Async in .NET
- Mastering .NET Performance Tuning
- Mastering .NET Threading
- Dotnetos - .NET Performance World - Two-day conference dedicated solely to .NET performance! (05-06 October 2021, Online)
- Background type preloading and MultiCoreJit in .NET 6
- Running .NET Core performance investigation on Linux
- What's so hard about pinning?
- The Art of Tracing
- Performance Improvements in .NET 5
- Beating CoreCLR's own C++ code with CoreCLR 3.0 intrinsics
- From ETW to EventPipe - Soulier (10.03.2020, DotNext)
- What the game industry taught me about performance
- Compiling and Running a PHP on .NET Core
- Ethereum performance in .NET Core
- To ORM or not to ORM
- Writing Allocation Free Code in C#
- Cliff diving into async in .NET Core and C# 8
- Performance Testing
- How Entity Framework translates LINQ all the way to SQL
- .NET Intrinsics in CoreCLR 3.0
- The .NET Garbage Collector
- .NET Performance Investigation
- Performance in the .NET Runtime
- Spanification
- Debugging asynchronous scenarios in .NET
- Building your own profiling and diagnosis tools with Event Tracing for Windows
- JIT and AOT in the CLR - Chin Tsai (30.07.2019, JVM Language Summit)
- Powerful benchmarking in .NET
- What’s new for performance in .NET Core and ASP.NET Core 3.0
- Ref struct, ref readonly struct, ref returning, ref everything!
- Building responsive and scalable applications
- Make your custom .NET GC — "whys" and "hows"
- Extend the new WinDbg to build your own dream debugging tool
- Tuning a Runtime for Both Productivity and Performance - Chin Tsai (26.02.2019, QCon)
- Efficient Buffer Manipulation using C# 7.2's Span
- Building your own debugging toolbox with ClrMD
- Scratched metal
- PerfView: The Ultimate .NET Performance Tool
- Advanced .NET debugging techniques from a real world investigation
- Patterns for high-performance C#
- What's new for performance in .NET Core 2.0
- State of the .NET Performance
- Look Mommy, No GC!
- Squeezing the Hardware to Make Performance Juice
- Performance tuning Stack Overflow tags
- Multithreading Deep Dive
- Stack Overflow — It's all about performance!
- ETW — Monitor Anything, Anytime, Anywhere
- Exceptional Exceptions in .NET
- PerfView: Measure and Improve Your App's Performance For Free
- The C++ and CLR Memory Models
- Safe Systems Programming in C# and .NET
- ASP.NET Core Kestrel: Adventures in building a fast web server
- Performance and How to Measure It
- Performance Optimizations in the Wild
- The Vector in Your CPU: Exploiting SIMD for Superscalar Performance
- Lessons in Extreme .NET Performance
- Making .NET applications faster
- The zen of async: Best practices for best performance
- Maoni Stephens
- Stephen Toub
- Matt Warren
- Andrey Akinshin
- Dan Shechter
- Egor Bogatov
- Oren Eini aka Ayende
- Alexandre Mutel aka xoofx
- Vladimir Sadov
- Adam Sitnik
- Konrad Kokosa
- Kunal Pathak
- Ben Adams
- Jan Kotas
- Stephen Toub
- Kunal Pathak
- mikedn
- Tanner Gooding
- Vladimir Sadov
- Dan Shechter
- Egor Bogatov
- Federico Andres Lois
- Konrad Kokosa
- nietras
- BenchmarkDotNet - Powerful .NET library for benchmarking.
- NBench - Cross-platform performance benchmarking and testing framework for .NET applications.
- CsCheck Faster - Random data range, multithreaded, cross-platform/machine, unit testing integrated, relative performance testing.
- Prefix - Free lightweight profiler for ASP.NET apps shows everything your code is doing across 30+ common libraries
- MiniProfiler - Free profiling tool for .NET applications with Entity Framework and ASP.Net integration (Core supported for both versions)
- dotTrace - Paid profiler for .NET applications from the JetBrains team, included in the Resharper Ultimate package
- Unchase.FluentPerformanceMeter - Free open-source and cross-platform .Net Standard 2.0 library that is designed for the method’s performance measurement
- codetrack - Free .NET performance profiler and execution analyzer
- App Metrics - App Metrics is an open-source and cross-platform .NET library used to record and report metrics within an application and reports it's health. See the docs for [more](https://alhardy.github.io/app-metrics-docs/getting-started/intro.html) details.
- Clr Heap Allocation Analyzer
- NBomber
- JMeter DLS
- Microbenchmark Design Guidelines
- The Art of Benchmarking
- Adventures in Benchmarking - Memory Allocations
- Micro-Benchmarking Done Wrong, And For The Wrong Reasons
- On ‘stackalloc’ Performance and The Large Object Heap
- Micro-Benchmarking Considered Harmful
- On Measuring Performance
- Stopwatch under the hood
- DateTime under the hood
- Benchmarking made easy
- Simple microbenchmarking in C#
- Acquiring high-resolution time stamps
- Performance exercise: Minimum
- Performance exercise: Division
- Measuring Performance Improvements in .NET Core with BenchmarkDotNet (Part 1)
- AWS Lambda — Container Image .NET Benchmark
- Performance Counters Hell
- Replace .NET performance counters by CLR event tracing
- Grab ETW Session, Providers and Events
- Monitor Finalizers, contention and threads in your application
- In-process CLR event listeners with .NET Core 2.2
- Spying on .NET Garbage Collector with TraceEvent
- High-performance .NET by example: Filtering bot traffic
- RyuJIT and the never-ending ThreadAbortException
- 9 posts about how to build your own toolbox with ClrMD
- .NET Threadpool starvation, and how queuing makes it worse
- Get-process-name challenge on a Friday afternoon
- In managed code we trust, our recent battles with the .NET Garbage Collector
- Tuning performance on Azure websites using remote profiling
- All .NET Debugging Demos: Hang, Crash, memory, and CPU
- Reader email: Need help troubleshooting perf/memory issues
- Debugging a classic ReaderWriterLock deadlock with SOSex.dll
- New commands in SOS for .NET 4.0 Part 1
- High CPU in .NET app using a static Generic.Dictionary
- .NET Hang Case study: The danger of locking on strings
- First step in troubleshooting complex issues: Define and scope your issue properly
- Show me the memory: Tool for visualizing virtual memory usage and GC heap usage.
- .NET Memory Leak reader email: Are you really “leaking” .net memory
- .NET Memory Leak: To dispose or not to dispose, that’s the 1 GB question
- Loop alignment in .NET
- RyuJIT Tutorial
- JIT Optimizations
- JIT Optimizations, Inlining, and Interface Method Dispatching (Part 1 of N)
- JIT Optimizations, Inlining, and Interface Method Dispatching (Part 2 of N)
- Performance differences between debug and release builds
- Aggressive Inlining in the CLR 4.5 JIT
- Jit Optimizations: Inlining (I)
- Jit Optimizations: Inlining (II)
- More on inlining…
- To Inline or not to Inline: That is the question
- Some Notes on Using Machine Learning to Develop Inlining Heuristics
- The JIT does dead-code elimination in Debuggable code
- Does the JIT take advantage of my CPU?
- Unrolling of small loops in different JIT versions
- RyuJIT CTP5 and loop unrolling
- RyuJIT RC and constant folding
- A story about JIT-x86 inlining and starg
- LegacyJIT-x86 and first method call
- Do PDB Files Affect Performance?
- What does the optimize switch do?
- Hoisting in .NET Explained (part 1)
- Hoisting in .NET Examples (part 2)
- ref returns are not pointers
- managed pointers
- Local variables cannot be returned by reference
- Safe to return rules for ref returns
- Why ref locals allow only a single binding?
- ref returns and locals
- An Introduction to System.Threading.Channels
- ConfigureAwait FAQ
- Threading in C#
- .NET Memory Performance Analysis
- GC Perf Infrastructure – Part 1
- GC Perf Infrastructure – Part 0
- The history of the GC configs
- Finalization implementation details
- A portable way to get GC events in process and no admin privilege with 10 lines of code (and ability to dynamically enable/disable events)
- Making CPU configuration better for GC on machines with > 64 CPUs
- Running with Server GC in a Small Container Scenario Part 1 – Hard Limit for the GC Heap
- Running with Server GC in a Small Container Scenario Part 0
- You Should Never See This Callstack in Production
- Middle Ground between Server and Workstation GC
- Pooling large arrays with ArrayPool
- Value Types vs Reference Types
- Span
- Vectorization using .NET APIs
- Hardware Intrinsics in .NET Core
- Exploring .NET Core platform intrinsics: Part 1 - Accelerating SHA-256 on ARMv8
- Exploring .NET Core platform intrinsics: Part 2 - Accelerating AES encryption on ARMv8
- Exploring .NET Core platform intrinsics: Part 3 - Viewing the code generated by the JIT
- Exploring .NET Core platform intrinsics: Part 4 - Alignment and pipelining
- .NET Core 3.0 Intrinsics in Real Life - 1/3
- .NET Core 3.0 Intrinsics in Real Life - 2/3
- .NET Core 3.0 Intrinsics in Real Life - 3/3
- Decimating Array.Sort with AVX2 - 1/∞
- Decimating Array.Sort with AVX2 - 2/∞
- Decimating Array.Sort with AVX2 - 3/∞
- Performance Improvements in .NET 8
- Performance Improvements in .NET 7
- Performance Improvements in .NET 6
- Regex Performance Improvements in .NET 5
- Performance Improvements in .NET 5
- Performance Improvements in .NET Core 3.0
- Performance Improvements in .NET Core 2.1
- Performance Improvements in .NET Core
- Arm64 Hardware Intrinsics APIs in .NET - Part 6
- Arm64 Hardware Intrinsics APIs in .NET - Part 5
- Arm64 Hardware Intrinsics APIs in .NET - Part 4
- Arm64 Hardware Intrinsics APIs in .NET - Part 3
- Arm64 Hardware Intrinsics APIs in .NET - Part 2
- Arm64 Hardware Intrinsics APIs in .NET - Part 1
- Peephole optimizations in .NET
- Memory barriers in ARM64
- ARM64 performance of .Net Core 5
Keywords
dotnet
3
performance
3
csharp
3
performance-testing
3
benchmark
2
garbage-collection
1
nbench
1
performance-test
1
causal-profiling
1
concurrency-testing
1
metamorphic-testing
1
model-based-testing
1
quickcheck
1
random
1
regression-testing
1
testing
1
benchmarking
1
dot-net
1
fsharp
1
integration-testing
1
load-testing
1
azure
1
jmeter
1
jmx
1