dotnet/performance

This system is a comprehensive performance benchmarking infrastructure for the .NET runtime and libraries, designed to measure and analyze performance across micro-benchmarks, real-world workloads, and garbage collection behaviors. It provides tooling for executing tests on diverse platforms including WebAssembly, mobile, and native environments, while offering detailed analysis capabilities for GC traces, CPU usage, and memory allocation. The system supports automated CI integration, cross-compilation, and AI-driven orchestration to track regressions and improvements in low-level runtime optimizations.

85 changes.

This period focused on establishing a robust, cross-platform performance testing infrastructure by integrating Arcade SDK build systems, Helix-based execution pipelines, and extensive Python tooling. It involved creating a vast suite of micro-benchmarks covering .NET runtime internals, core libraries, and real-world scenarios, alongside specialized tools for scenario measurement, result comparison, and reporting.

47 changes.

This period focused on rebuilding the GC benchmarking infrastructure in C\#, introducing a comprehensive analysis API, and expanding microbenchmark coverage across runtime, libraries, and real-world workloads. It also added specialized tools for Android scenario measurement and Linux tracing support to enhance performance profiling capabilities.

17 changes.

This period focused on significantly expanding the benchmarking suite with new F\# and SVE microbenchmarks, alongside detailed performance measurements for runtime optimizations like strength reduction and array deabstraction. The GC infrastructure was enhanced with a dynamic event schema, reliability testing frameworks, and an MCP server to enable AI-driven performance analysis. Supporting tooling was also introduced, including certificate management and pipeline utilities for ASP.NET Core performance builds.

A new micro-benchmark has been added to the runtime suite that implements a packet-tracer ray tracer optimized for AVX2 vector instructions. The implementation processes rays in packets of eight using a Structure-of-Arrays (SoA) layout to maximize SIMD throughput, featuring vectorized sphere and plane intersection tests, shadow ray calculations, and Phong shading with diffuse, specular, and reflection components. This allows users to benchmark the performance of hardware intrinsics for complex mathematical workloads on x64 and x86 architectures.

src/benchmarks/micro/runtime/PacketTracer · high confidence

A new command-line tool has been added to measure memory consumption for Android applications. The tool supports running test executables with configurable iterations, warmup, and setup/cleanup commands, and specifically uses an Android memory parser to collect and report metrics via JSON output.

src/tools/ScenarioMeasurement/MemoryConsumption · high confidence

The \eng/common\ directory now includes the full set of Arcade SDK build scripts (such as \build.sh\, \build.ps1\, \SetupNugetSources.ps1\, and \Get-GitHubAppToken.ps1\) and documentation. This change introduces the standard .NET Arcade build system, enabling automated CI builds, internal NuGet feed configuration, and secure GitHub App token generation for pipelines.

eng/common · high confidence

This change introduces the BYTEmark benchmark suite (originally from BYTE Magazine) to the .NET runtime micro-benchmarks. The implementation translates the classic C benchmarks to C\# and adapts them for BenchmarkDotNet, including specific variants that compare class versus struct implementations and jagged arrays versus multi-dimensional arrays. The added files cover tests for string sorting, Huffman compression, bitfield operations, floating-point emulation, Fourier transforms, and assignment algorithms, along with their corresponding command configuration files.

src/benchmarks/micro/runtime/Bytemark, src/benchmarks/real-world/ImageSharp · high confidence

Added a new set of micro-benchmarks in the BenchF category, including Adams, BenchMk2, BenchMrk, Bisect, DMath, FFT, InProd, InvMt, LLoops, Lorenz, MatInv4, NewtE, NewtR, Regula, Romber, Secant, Simpsn, SqMtx, and Trap. These benchmarks cover numerical methods such as matrix inversion, linear algebra, integration, and root-finding algorithms to evaluate runtime and JIT performance.

src/benchmarks/micro/runtime/Benchstones/BenchI · high confidence

Added a new benchmark suite under src/benchmarks/real-world/bepuphysics2 to measure the performance of the BepuPhysics 2 engine. The suite includes microbenchmarks for collision detection (batcher tasks, convex testers, gather/scatter operations), constraint solving (one-, two-, three-, and four-body constraints), and full simulation scenarios (ragdoll tube, shape pile). These benchmarks are designed to be run via CI jobs to track performance regressions in the physics library.

src/benchmarks/real-world/bepuphysics2 · high confidence

A new microbenchmark has been added to measure the performance of bilinear interpolation algorithms. The implementation includes both a standard scalar version and an optimized vectorized version that utilizes .NET's System.Numerics.Vector APIs to process multiple double values in parallel, providing a baseline for comparing scalar versus SIMD-accelerated interpolation performance.

src/benchmarks/micro/runtime/BilinearInterpol · high confidence

A new BlazorLocalized scenario has been added to the performance test suite to measure the behavior of Blazor WebAssembly applications under various cultural settings. This scenario includes a sample application that exercises locale-sensitive operations such as calendar keyword translations, date formatting, and string comparisons (indexing, prefix/suffix checks) across different character sets (Latin Basic, Latin Extended, Universal). The addition includes the necessary pre/post-command scripts to manage the Blazor WASM workload and build the localized sample project.

src/scenarios · high confidence

New microbenchmarks have been added to the Benchstones suite to evaluate the performance of multi-dimensional array operations. The \MDBenchI\ location introduces benchmarks for array addition (\MDAddArray2\), array copying (\MDArray2\, \MDGeneralArray\), logic operations (\MDLogicArray\), midpoint finding (\MDMidpoint\), matrix multiplication (\MDMulMatrix\), Dhrystone (\MDNDhrystone\), puzzle solving (\MDPuzzle\), and matrix transposition (\MDXposMatrix\). The \MDBenchF\ location adds benchmarks for matrix production (\MDInProd\), matrix inversion (\MDInvMt\), Livermore Loops (\MDLLoops\), Romberg integration (\MDRomber\), and square matrix multiplication (\MDSqMtx\). These additions provide targeted coverage for JIT and runtime performance characteristics related to multi-dimensional array handling.

src/benchmarks/micro/runtime/Benchstones/MDBenchI · high confidence

New C\# implementations of the JetStream Poker and Segmentation benchmarks have been added to the micro-benchmark suite. The Poker benchmark introduces logic for managing card decks, shuffling, and evaluating hand rankings (such as flushes, straights, and pairs) using regular expressions. The Segmentation benchmark adds statistical utilities, including t-distribution tables and functions for calculating confidence intervals and performing Welch's t-tests. A compatibility layer (Compat.cs) provides helper methods like list shifting, string slicing, and array joining to support these implementations.

src/benchmarks/micro/runtime/JetStream · high confidence

A new F\# microbenchmark project has been added to the \src/benchmarks/micro-fsharp\ directory, providing performance measurements for F\# standard library operations. The suite includes benchmarks for collection manipulation (insert, remove, update on lists, arrays, and sequences) and equality checks (distinct, countBy, groupBy, except) across various primitive types and custom structs. These benchmarks are configured to run via BenchmarkDotNet and are categorized under 'FSharpMicro' to allow targeted execution.

src/benchmarks/micro-fsharp · high confidence

The GC benchmark infrastructure now includes configuration files and data to support microbenchmarking. A new \MicrobenchmarkInvocationCounts.psv\ file provides pre-calculated invocation counts for specific benchmarks (such as \System.Tests.Perf\_GC\ and \System.Numerics.Tests.Perf\_BigInteger\) to ensure statistical significance. Additionally, \MicrobenchmarksToRun.txt\ defines the suite of benchmarks to execute, while \Microbenchmarks\_Server.yaml\ and \Microbenchmarks\_Workstation.yaml\ configure the benchmark runner for server and workstation GC modes respectively, specifying output metrics like GC count, pause time, and allocation size.

src/benchmarks/gc/GC.Infrastructure/Configurations/Microbenchmark · high confidence

This change introduces a new benchmark suite in \src/benchmarks/real-world/ILLink\ to measure the performance of the IL Linker. The suite includes \BasicBenchmark.cs\ for direct linker invocation and \MSBuildBenchmark.cs\ for measuring linker performance during MSBuild publish operations. It also adds a sample \HelloWorld\ project and utility classes to handle cross-platform runtime identification and temporary folder management for the benchmarks.

src/benchmarks/real-world/ILLink · high confidence

New micro-benchmarks have been added to the System.Linq benchmark suite to measure the performance of common LINQ operations (such as Select, Where, First, Last, Single, OrderBy, and Reverse) across various collection types (Array, List, IEnumerable, IList, ICollection, IOrderedEnumerable, and Range). The suite also includes benchmarks for ImmutableArrayExtensions.SequenceEqual and detailed OrderBy scenarios involving string, value type, and custom comparer sorting. These benchmarks utilize a shared test data structure and support memory randomization to ensure accurate performance profiling.

src/benchmarks/micro/libraries/System.Linq · high confidence

New command-line tools have been added to the GC Infrastructure benchmarks to support the Reliability Framework. The \RFAnalyzeCommand\ automates the analysis of memory dump files by invoking platform-specific debuggers (windbgx on Windows, lldb on Linux) to extract call stacks, while the \RFAggregateCommand\ processes these logs to identify and group attributed errors, outputting a summary table to a Markdown file. Additionally, the \RFCreateSuitesCommand\ generates executable test scripts and configurations for various GC modes (Datas, Server, Workstation) and run configurations, preparing the necessary assets for reliability testing.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure/Commands/ReliabilityFramework · high confidence

The GC Infrastructure now includes a new base suite for reliability testing, providing PowerShell and Bash scripts to orchestrate long-running stress tests (up to 24 hours) that generate GC logs and mini-dumps. This suite is supported by four XML configuration files (\finalization.config\, \loh.config\, \poh.config\, \non\_induced.config\) that define specific test assemblies and arguments for scenarios involving finalizable objects, Large Object Heap (LOH) pressure, Pinning Object Heap (POH) pressure, and non-induced stress tests.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure/Commands/RunCommand/BaseSuite/ReliabilityFramework · high confidence

A new micro-benchmark has been added to the SIMD runtime category that implements a ray tracer using System.Numerics.Vector3 for SIMD acceleration. The implementation includes supporting types for vectors, colors, rays, and scene objects (spheres and planes), along with an object pool for buffer reuse. The benchmark driver allows running the rendering loop sequentially or in parallel, providing a workload to measure JIT and runtime performance for vectorized math operations.

src/benchmarks/micro/runtime/SIMD/RayTracer · high confidence

New micro-benchmarks have been added to the Span benchmark suite to measure performance characteristics of Span\<T\> operations. The new Indexer.cs file benchmarks indexer access patterns, specifically focusing on in-loop bounds check elimination across various implementation styles (ref pointers, fixed pointers, and direct indexer usage). The Sorting.cs file introduces benchmarks comparing QuickSort and BubbleSort implementations on Span\<int\> versus traditional arrays, with configuration adjustments (increased invocations and warmup counts) to ensure accurate Tier-1 JIT compilation metrics.

src/benchmarks/micro/runtime/Span · high confidence

New benchmark files have been added to the System.Net.Security micro-benchmarks to measure SslStream handshake performance. These include benchmarks for default and mutual handshakes using SslStreamCertificateContext over IPv4 and IPv6, as well as handshakes using various certificate types (RSA 2048/4096, ECDSA 256/512) across supported TLS protocols (1.2 and 1.3).

src/benchmarks/micro/libraries/System.Net.Security · high confidence

New benchmark files have been added to the System.Drawing micro-benchmark suite to measure performance of color manipulation (FromArgb, GetBrightness, GetHue, GetSaturation), graphics drawing (DrawBezier, DrawBeziers), graphics transforms (TransformPoints), and image loading from streams (Bitmap and Image constructors with various formats). These benchmarks are restricted to Windows on .NET 5.0 and later, with graceful skipping on non-Windows platforms when libgdiplus is missing.

src/benchmarks/micro/libraries/System.Drawing · high confidence

Added new C\# benchmark implementations for the BinaryTrees and FannkuchRedux tasks from The Computer Language Benchmarks Game. The BinaryTrees benchmarks (versions 2, 5, and 6) include single-threaded and concurrent tree-generation algorithms, with version 5 and 6 marked to skip on WebAssembly. The FannkuchRedux benchmarks (versions 2, 5, and 9) provide single-threaded and multi-threaded permutation-flip algorithms, with version 9 using unsafe code for performance. A THIRD-PARTY-NOTICES.TXT file was also added to include the Revised BSD license for these external benchmarks.

src/benchmarks/micro/runtime/BenchmarksGame · high confidence

Added new micro benchmarks in the System.Net.Http library to measure the performance of HTTP requests using both SocketsHttpHandler and WinHttpHandler. These benchmarks allow users to evaluate throughput and header enumeration performance under various configurations, including SSL/TLS, chunked responses, and different response sizes.

src/benchmarks/micro/libraries/System.Net.Http · high confidence

New benchmark files have been added to the System.IO.Compression micro-benchmark suite to measure the performance of Brotli and Zstandard compression algorithms. The changes introduce \Brotli.cs\ and \Zstandard.cs\ benchmark classes, along with supporting infrastructure in \CompressionStreamPerfTestBase.cs\ and \CompressedFile.cs\, and include test data files such as \alice29.txt\ to facilitate these performance measurements.

src/benchmarks/micro/libraries/System.IO.Compression · high confidence

The \src/benchmarks/micro/Serializers\ directory now includes a comprehensive suite of micro-benchmarks comparing the performance of popular serialization libraries. The benchmarks cover JSON (Jil, JSON.NET, Utf8Json, DataContractJsonSerializer, and System.Text.Json with both reflection and source-generated metadata), XML (XmlSerializer, DataContractSerializer, and BinaryXml), and binary formats (protobuf-net and MessagePack). These benchmarks evaluate serialization and deserialization against streams and strings using realistic data contracts like LoginViewModel and Location, providing performance insights for developers choosing between these libraries.

src/benchmarks/micro/Serializers · high confidence

This change introduces a new suite of micro-benchmarks for the Microsoft.Extensions.DependencyInjection library, measuring performance across various scenarios including service resolution (GetService), ActivatorUtilities.CreateInstance, factory creation, and scope validation (both on build and runtime). It also adds benchmarks for Microsoft.Extensions.Http, including a fake HTTP message handler and logger provider to isolate and measure HTTP client performance overhead. These benchmarks allow developers to track performance regressions or improvements in dependency injection and HTTP client initialization.

src/benchmarks/micro/libraries/Microsoft.Extensions.DependencyInjection · high confidence

Added new performance benchmarks for AnonymousPipeStream and NamedPipeStream in the System.IO.Pipes library. These benchmarks measure read/write throughput and latency using synchronous and asynchronous operations, providing a baseline for future performance optimizations.

src/benchmarks/micro/libraries/System.IO.Pipes · high confidence

New micro-benchmark suites have been added to measure the performance of the System.Text.RegularExpressions library. These include general pattern matching tests (Perf\_Regex\_Common) covering common use cases like email, date, IP, and URI validation, as well as specific tests for regex cache behavior under single-threaded and multi-threaded workloads (Perf\_Regex\_Cache). Additionally, industry-standard benchmarks adapted from external sources (mariomka, cloudflare/sliceslice-rs, and rust-lang/regex) are now included to track performance against real-world patterns, with support for .NET 7+ NonBacktracking options where available.

src/benchmarks/micro/libraries/System.Security.Cryptography, src/benchmarks/micro/libraries/System.Text.RegularExpressions, src/benchmarks/micro/libraries/System.Threading.Channels · high confidence

Added a new set of micro-benchmarks in the \src/benchmarks/micro/libraries/System.Threading\ directory to measure the performance of core .NET threading APIs. The new files cover \CancellationToken\ operations (registration, cancellation, linked sources), \Interlocked\ operations (increment, decrement, add, exchange, compare-exchange), synchronization primitives (\Monitor\, \SpinLock\, \ReaderWriterLockSlim\, \SemaphoreSlim\), \EventWaitHandle\, \Thread\ (current thread, processor ID), \ThreadStatic\ access, and \Volatile\ read/write operations.

src/benchmarks/micro/libraries/System.Threading · high confidence

Added new micro-benchmarks in the StoreBlock directory to measure the performance of Unsafe.InitBlock and Unsafe.CopyBlock operations. The benchmarks cover block sizes of 8, 16, 32, 64, and 128 bytes, testing both initialization with all-zeros and all-ones patterns, as well as memory copying. The suite includes scenarios for both arbitrary memory locations and local struct addresses, with some benchmarks utilizing memory randomization to simulate realistic conditions.

src/benchmarks/micro/runtime/StoreBlock · high confidence

New benchmark files have been added to the \src/benchmarks/micro/runtime/perflab\ directory to measure the performance of various runtime operations. These include \BlockCopyPerf\ for buffer copying, \CastingPerf\ and \CastingPerf2\ for type casting scenarios, \DelegatePerf\ for delegate invocation and multicast combination, \DictionaryExpansion\ for generic dictionary lookups, \EnumPerf\ for enum comparisons and type checks, \LowLevelPerf\ for method calls and interface dispatch, \ReflectionPerf\ for reflection member access, and \StackWalk\ for stack walking overhead. Several benchmarks utilize the \MemoryRandomization\ attribute to ensure more realistic performance measurements.

src/benchmarks/micro/runtime/perflab · high confidence

New benchmark suites have been added to measure performance: a \Hashing\ benchmark in the System libraries area that measures \string.GetHashCode\ performance across varying string lengths, and V8 runtime benchmarks including a \Crypto\ suite (RSA encryption/decryption) and a \Richards\ suite (task scheduler simulation).

src/benchmarks/micro/libraries/System, src/benchmarks/micro/runtime/V8 · high confidence

Added new microbenchmarks for System.IO.FileSystem, covering directory operations (GetCurrentDirectory, CreateDirectory, Exists, RecursiveCreateDeleteDirectory, EnumerateFiles, MoveFolders, MoveFiles), file operations (Exists, Delete, WriteAllBytes, ReadAllBytes, ReadAllLines, AppendAllLines, AppendAllText, WriteAllText, CopyTo), FileInfo construction, FileStream operations (OpenClose, LockUnlock, SeekForward, SeekBackward, GetLength, ReadByte, WriteByte, Flush, Read, Write, CopyToFile, Append with both synchronous and asynchronous variants, including no-buffering modes), and RandomAccess I/O (Read, Write, ReadScatter, WriteGather, and their async counterparts, including no-buffering variants). These benchmarks measure performance across various file sizes and buffer configurations.

src/benchmarks/micro/libraries/System.IO.FileSystem · high confidence

A new PowerShell script, stage-bcs-nupkg-aspnetcore.ps1, has been added to the engineering pipelines to support the ASP.NET Core performance-build pipeline. This tool stages the Microsoft.AspNetCore.App runtime-pack NuGet package as a Build Cache Service (BCS) artifact for specific runtimes (Windows x64/x86/arm64, Linux x64, Linux arm64). It locates the shipping nupkg, verifies there is exactly one match per RID, and copies it to a version-independent staging path so that downstream tools like Crank can reliably resolve the artifact by SHA.

eng/pipelines/tools · high confidence

A new command-line tool has been added to measure Android power consumption during scenario testing. It supports running test executables with configurable iterations, warmup, and setup/cleanup steps, while collecting ETW traces and parsing them to generate JSON reports.

src/tools/ScenarioMeasurement/PowerConsumption · high confidence

The F\# real-world benchmarks now include the source code for the FsToolkit.ErrorHandling library (version 3.0.0), providing a comprehensive set of utilities for handling Result, Option, and Async types. This addition introduces modules for synchronous and asynchronous computation expressions, along with operators for mapping, binding, and applying functions across these types, allowing the benchmark suite to measure performance against this specific error-handling implementation.

src/benchmarks/real-world/FSharp · high confidence

Added new micro-benchmarks to measure the performance of array creation, including the standard new operator and the .NET 5+ GC.AllocateArray and GC.AllocateUninitializedArray APIs. These benchmarks are configured to run only on non-WASM platforms, as the allocation methods are not supported in that environment.

src/benchmarks/micro/runtime/GC · high confidence

A new PerfLab tool forwards .NET EventSource events to an LTTng tracepoint provider, enabling low-overhead tracing on Ubuntu 22.04. The solution includes a C\# startup hook that registers an event listener to capture specific events and a C library that emits corresponding LTTng tracepoints. This forwarding mechanism is gated by a runtime check to ensure it only activates on supported Ubuntu 22.04 environments.

src/tools/PerfLabGenericEventSourceForwarder · high confidence

The ScenarioMeasurement tool now supports tracing on Linux via a new \LinuxTraceSession\ implementation that uses \PerfCollect\ to capture kernel and CLR events, complementing the existing Windows ETW-based tracing. This change introduces a \TraceSessionManager\ that abstracts session creation across platforms and adds a \PerfLabGenericEventSourceLTTngProviderParser\ to parse specific PerfLab startup and main events from LTTng traces, enabling end-to-end scenario measurement on Linux environments.

src/tools/ScenarioMeasurement/Util/TraceEventParsers, src/tools/ScenarioMeasurement/Util/TraceSessions · high confidence

A new benchmark project has been introduced to measure the performance of the PowerShell engine, specifically targeting the compiler, parser, and scripting engine. The suite includes benchmarks for parsing 'using' statements, compiling script blocks, and invoking methods (including COM methods on Windows). These benchmarks are categorized for CI execution and can be run with partitioning and exclusion filters via the command line.

src/benchmarks/real-world/PowerShell.Benchmarks · high confidence

A new micro-benchmark suite for the Roslyn C\# compiler has been added to the runtime benchmarks. This includes benchmarks for C\# compilation performance (CscBench) and semantic data-flow analysis, allowing users to measure the impact of runtime changes on compiler internals.

src/benchmarks/micro/runtime/Roslyn · high confidence

A new micro-benchmark has been added to measure the performance impact of loop unrolling in SIMD byte-seek operations. The benchmark, located in \src/benchmarks/micro/runtime/SIMD/SeekUnroll\, implements a \FindByte\ method that utilizes \System.Numerics.Vector\ to process data in 64-bit chunks, applying bitwise operations to locate the first non-zero byte. It is configured to run only on native runtimes (excluding the interpreter and WasmCoreCLR) and includes memory randomization to ensure realistic performance measurements.

src/benchmarks/micro/runtime/SIMD/SeekUnroll · high confidence

New microbenchmarks have been added to the \System.Runtime.Intrinsics\ benchmark suite to measure the performance of \Vector128\ operations. The changes introduce \Perf\_Vector128.cs\ and \Perf\_Vector128OfT.cs\, which benchmark specific methods such as \Floor\, \Ceiling\, and various conversions, as well as generic arithmetic, bitwise, and comparison operators for \Vector128\<T\>\. These benchmarks are tagged with SIMD and JIT categories to facilitate targeted performance analysis.

src/benchmarks/micro/libraries/System.Runtime.Intrinsics · high confidence

Added strongly-typed resource classes and localization files (ResX and XLIFF for Czech, German, Spanish, French, Italian, Japanese, Korean, Polish, and Portuguese) to the micro-benchmarks library, providing the JSON sample data (such as basic objects, arrays, and large trees) required by the JsonDocument parsing and property enumeration benchmarks.

src/benchmarks/micro/libraries/System.Text.Json/Resources · high confidence

The GC.Infrastructure.Core library now includes a new App.config file that defines a default path for the performance repository, alongside a new Utilities class. This class provides static helper methods for file system operations, including recursively copying directories and files, creating directories safely, and copying individual files, which supports the underlying infrastructure for the new GC analysis APIs.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure.Core · high confidence

The micro benchmarks now include dedicated input data and helper classes for the k-nucleotide, regex-redux, and reverse-complement benchmarks. This change adds input files (knucleotide-input.txt, knucleotide-input-big.txt, regexdna-input25.txt, regexdna-input25000.txt, revcomp-input25.txt, revcomp-input25000.txt) and corresponding C\# helper classes (NucleotideHelpers, RegexReduxHelpers, ReverseComplementHelpers) that locate these files and define expected output values, ensuring the benchmarks have the necessary data to run correctly.

src/benchmarks/micro/runtime/BenchmarksGame/Inputs · high confidence

This change introduces a new suite of micro-benchmarks to the \src/benchmarks/micro\ directory, providing performance baselines for specific .NET runtime and library behaviors. The additions include benchmarks for \System.ComponentModel.TypeDescriptor\ (covering various type conversions), \System.Xml.XmlDocument\ (creation, loading, and node access), and several runtime-level optimizations: exception handling costs (software/hardware exceptions, reflection, and catch blocks), Just-In-Time (JIT) inlining behaviors (specifically regarding GC struct locals and throw-heavy methods), code layout strategies for search loops, and instruction replacement lowering. These benchmarks allow developers to track performance regressions or improvements in these low-level areas.

(repo-wide) · high confidence

Added a new benchmark suite for the System.Net.Sockets library that measures the performance of TCP and UDP socket operations. The benchmarks cover asynchronous connect/accept cycles, SendAsync/ReceiveAsync patterns using both Task-based and SocketAsyncEventArgs approaches, and UDP SendTo/ReceiveFrom operations, including .NET 8-specific SocketAddress variants.

src/benchmarks/micro/libraries/System.Net.Sockets · high confidence

New benchmark suites have been added to measure the performance of specific runtime behaviors. The System.Threading.Tasks benchmarks now include tests for empty async method invocations and single-yield scenarios, while the System.Threading.ThreadPool benchmarks introduce a throughput test for QueueUserWorkItem operations. These additions allow for more granular performance tracking of asynchronous execution and thread pool scheduling.

src/benchmarks/micro/libraries/System.Threading.Tasks, src/benchmarks/micro/libraries/System.Threading.ThreadPool · high confidence

The \eng/common/native\ directory now includes a suite of new scripts and configuration files to support native tool installation and environment setup. This includes \CommonLibrary.psm1\ and \common-library.sh\ for cross-platform download and extraction utilities, \init-compiler.sh\ and \LocateNativeCompiler.targets\ to detect and configure C/C++ compilers (clang/gcc) and linkers, \init-os-and-arch.sh\ and \init-distro-rid.sh\ for operating system and architecture detection, and specific installers for tools like CMake (\install-cmake.sh\, \install-tool.ps1\) and system dependencies (\install-dependencies.sh\).

eng/common/native · high confidence

A new PerfUtils helper class has been added to the CommonUtils benchmark library, providing methods to generate deterministic test strings. The CreateString method produces strings of a specified length with periodic path separators, while CreateRandomString generates reproducible alphanumeric strings using a seeded random number generator, supporting more consistent and varied string replacement benchmarks.

src/benchmarks/micro/libraries/CommonUtils · high confidence

A new CertHelper tool has been added to manage performance test certificates, enabling automatic rotation from Azure Key Vault and handling platform-specific storage differences. On Windows and Linux, it uses the standard X.509 store, while on macOS it switches to a file-backed PFX store to bypass Keychain export limitations. The tool also supports bootstrap authentication via a client.pem file when local certificates are missing or invalid, and exports the resulting certificates to stdout for downstream consumers.

src/tools/CertHelper · high confidence

The SVE microbenchmark directory now includes a broader set of performance tests for Arm64, adding benchmarks for complex dot products, complex multiplication, floating-point exponentiation, 64-bit overflow handling, fast division, gather loads, logarithms, and more. Each new file provides implementations for scalar, Vector128 (NEON), and SVE/SVE2 variants, allowing users to compare the performance of these specific algorithms across different instruction set levels.

src/benchmarks/micro/sve · high confidence

The micro-benchmark suite for System.Collections has been significantly expanded with new benchmarks measuring Add, TryAdd, Contains, ContainsKey, Count, IsEmpty, and concurrent Add/Remove operations across a wide range of collection types including List, Dictionary, HashSet, ConcurrentDictionary, Immutable collections, Frozen collections, and the new OrderedDictionary (NET9+). These benchmarks provide performance data for common collection usage patterns such as adding items to pre-sized collections, checking for key existence in dictionaries, and concurrent producer/consumer throughput.

src/benchmarks/micro/libraries/System.Collections · high confidence

The GC Infrastructure benchmarking tool now provides a structured command-line interface built on Spectre.Console.Cli, allowing users to execute various benchmarking and analysis workflows. The tool registers commands for running benchmarks (run, run-suite), creating test suites (createsuites, rf-createsuites), and analyzing results for specific scenarios including GC PerfSim (gcperfsim, gcperfsim-analyze, gcperfsim-compare, gcperfsim-functional), microbenchmarks (microbenchmarks, microbenchmarks-analyze), ASP.NET benchmarks (aspnetbenchmarks, aspnetbenchmarks-analyze), and the Reliability Framework (rf-analyze, rf-aggregate). On Windows, the tool automatically elevates privileges to administrator mode to modify Windows Error Reporting settings and restores them upon completion.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure · high confidence

The GCPerfSim presentation layer now generates structured output for performance comparisons. A new Json helper serializes comparison results into JSON files, while a new Markdown generator produces detailed reports that summarize key metrics (execution time, GC pause time, heap size) and categorize individual metrics into sections for large regressions/improvements (\>20%), moderate changes (5–20%), and stale changes (\<5%). These changes are supported by new ResultItem and ComparisonResult classes that extract and compare specific GC metrics between baseline and comparand runs.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure.Core/Presentation/GCPerfSim · high confidence

This change introduces the foundational structure for the GC Infrastructure benchmarks, adding the solution file (GC.Analysis.API.sln) that defines the project hierarchy including the core infrastructure, analysis API, and notebook-based test projects. It also provides the necessary configuration and documentation to run the suite, including a .gitignore file tailored for Visual Studio and Jupyter environments, a README detailing the workflow for GCPerfSim, microbenchmarks, and ASP.NET benchmarks, and an Install.cmd script to set up the required .NET interactive and Jupyter tooling.

src/benchmarks/gc/GC.Infrastructure · high confidence

This change adds a new Model Context Protocol (MCP) server that exposes the GC.Infrastructure performance testing toolkit to AI assistants. The server provides tools to execute and analyze GCPerfSim benchmarks, run microbenchmarks via BenchmarkDotNet, perform ASP.NET web performance testing, and build CoreCLR runtimes (including generating CoreRun executables). It also includes utilities for version control operations like Git branch switching and comprehensive test suite orchestration, allowing AI agents to automate complex .NET runtime performance testing workflows.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure.MCPServer · high confidence

The ResultsComparer tool is added to src/tools/ResultsComparer, providing a CLI for comparing BenchmarkDotNet JSON results. It supports two-input comparisons and a 'matrix' mode for multi-configuration analysis, featuring statistical significance testing (Mann-Whitney), noise filtering, glob-based benchmark name filtering, and modality detection (bimodal/multimodal). The tool also includes a decompression command to extract and normalize results from SharePoint-style zip archives.

src/tools/ResultsComparer · high confidence

Added a new benchmark suite in src/benchmarks/real-world/Roslyn that measures the performance of key Roslyn compiler stages, including parsing, binding, emitting, and analyzer execution. The suite introduces specific benchmarks for GetDiagnostics, GetDiagnosticsWithAnalyzers, CompileMethodsAndEmit, and SerializeMetadata, utilizing a repro project downloaded from the Roslyn releases to ensure realistic workload coverage.

src/benchmarks/real-world/Roslyn · high confidence

The new Startup tool in src/tools/ScenarioMeasurement/Startup enables measuring application startup times across various scenarios (such as WPF, Android, and inner-loop tests) and introduces the ability to set processor affinity masks for the measured processes on Windows and Linux, ensuring consistent execution environments for performance testing.

src/tools/ScenarioMeasurement/Startup · high confidence

The GC Analysis API now exposes a dynamic event system that allows users to access GC trace data through a flexible, schema-driven interface. This change adds a new \DynamicEvents\ extension method on \TraceGC\ that returns a dynamic index of events, automatically parsing and validating them against defined schemas. Two specific GC dynamic events are now supported out-of-the-box: \SizeAdaptationSample\, which provides metrics like GC pause times and heap sizes, and \SizeAdaptationTuning\, which exposes internal tuning decisions such as heap count adjustments and throughput costs. The implementation includes a schema compiler that validates field types and occurrence counts, ensuring that the dynamic objects returned to the user are consistent with the expected GC runtime behavior.

src/benchmarks/gc/GC.Infrastructure/GC.Analysis.API/DynamicEvents · high confidence

The \scripts\ directory now includes a suite of new Python tools for managing and executing .NET micro-benchmarks. \benchmarks\_local.py\ provides a local testing workflow that builds runtime dependencies and runs BenchmarkDotNet for various run types (CoreRun, Mono, WASM) on specific commits. \benchmarks\_ci.py\ serves as the consolidated CI entry point, wrapping the build, run, and upload logic for both local and lab environments. \benchmarks\_monthly.py\ simplifies manual monthly performance runs for preview releases, while \benchmarks\_monthly\_upload.py\ handles uploading results to the performance contribution service. A new \channel\_map.py\ centralizes .NET version-to-TFM mappings, and \build\_runtime\_payload.py\ assists in constructing Helix payloads from build artifacts.

scripts · high confidence

A new Reporting library has been added to src/tools/Reporting/Reporting, providing the core data models (Build, Os, Run, Test, Counter) and a Reporter class for serializing benchmark results. The Reporter class handles JSON serialization of test results and provides a text-based result table, while also supporting the extraction of build metadata from environment variables (such as PERFLAB\_REPO, PERFLAB\_BRANCH, and version info) when running in a lab environment.

src/tools/Reporting/Reporting · high confidence

The \scripts/performance\ directory now contains a new set of Python modules (\common.py\, \logger.py\, \tracer.py\, \constants.py\) that provide shared functionality for performance testing scripts. This includes robust logging with UTF-8 encoding and duplicate prevention, OpenTelemetry tracing and logging integration (with graceful fallback if the library is missing), and common utilities for directory management, architecture detection, and retry logic. These changes establish a standardized, reusable foundation for performance runs, enabling better observability and error handling across the performance testing pipeline.

scripts/performance · high confidence

Adds a new set of utility classes in src/tools/ScenarioMeasurement/Util to support scenario measurement workflows. This includes an IParser interface and ParserUtility for matching trace events to processes, a TraceSourceManager for handling Windows (ETW) and Linux (LTTng) kernel trace sources, and a PerfCollect class to manage trace collection via the perfcollect script. Process management is handled by ProcessHelper classes (RawProcessHelper and ManagedProcessHelper) which support environment variables, timeouts, and root access, while Logger provides structured console output and PerfLabValues defines constants for event sources.

src/tools/ScenarioMeasurement/Util · high confidence

The SizeOnDisk tool now parses .mstat files generated by NativeAOT to provide detailed breakdowns of assembly and blob sizes, rather than just counting the file as a whole. It also introduces new 'Synthetic Wire Size' counters for Blazor assets (specifically .br files) to estimate network transfer costs. Additionally, version numbers in file paths are normalized to 'VERSION' to reduce noise in reporting, and aggregate counters are added for file extensions.

src/tools/ScenarioMeasurement/SizeOnDisk · high confidence

Added new CLI commands to the GC Infrastructure for running and analyzing ASP.NET benchmarks. The \AspNetBenchmarksCommand\ orchestrates benchmark execution, including pre-flight checks for machine availability and scheduled host reboots, while the \AspNetBenchmarksAnalyzeCommand\ processes the resulting data to generate comparative reports on metrics like latency and memory usage.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure/Commands/ASPNetBenchmarks · high confidence

Added configuration files (CSV and YAML) for the ASP.NET benchmark suite within the GC Infrastructure. The CSV files define command-line arguments for various benchmark scenarios across Windows, Linux, and Linux Container environments, including database (EF, Dapper), JSON, plaintext, and platform-specific tests. The YAML file sets up the baseline and run environments, specifying .NET framework versions (net6.0, net8.0), GC server settings, and output formats. This enables the GC infrastructure to execute these specific ASP.NET benchmarks with standardized configurations.

src/benchmarks/gc/GC.Infrastructure/Configurations/ASPNetBenchmarks · high confidence

The GC Analysis API now includes a new CPU analysis subsystem that allows users to measure and visualize the CPU cost of specific methods across individual Garbage Collection (GC) cycles. This addition introduces a \CPUAnalyzer\ that processes trace logs to extract per-GC, per-thread, and per-method CPU metrics, including special handling for GC heap phases like plan, relocate, and compact. Users can now query the cost of specific methods (e.g., \gc\_heap::plan\_phase\) per GC number, view inclusive or exclusive counts, and generate Plotly charts to visualize these costs over time. The API also provides dataframes for summarizing CPU usage by GC phase and comparing baseline vs. other process runs, enabling deeper performance profiling of GC-related CPU activity.

src/benchmarks/gc/GC.Infrastructure/GC.Analysis.API/CPUAnalysis · high confidence

The GC.Analysis.API library is introduced to provide programmatic access for analyzing .NET Garbage Collection, CPU, and threading data within .NET Interactive notebooks. The API includes an Analyzer class that ingests trace files (including .nettrace and .zip archives) and exposes GC process data, alongside an AnalyzerManager for batch processing. It also provides utilities for statistical analysis (percentiles, standard deviation, outlier removal), charting helpers for Plotly layouts, and trace summarization that aggregates GC, CPU sample, and context-switch events into DataFrames for reporting.

src/benchmarks/gc/GC.Infrastructure/GC.Analysis.API · high confidence

This change introduces a new GC analysis API within the \GC.Analysis\ namespace, providing infrastructure for analyzing garbage collection performance. It adds the \GCProcessData\ class to aggregate process-level GC statistics (such as pause times, allocations, and promotion metrics) and exposes helper methods in \GCAnalysisExt\ to retrieve this data from an \Analyzer\. The API includes \GCSummarization\ for generating detailed data frames of GC metrics and \AffinitizedAnalysis\ to profile CPU affinity impacts on GC threads. Additionally, \Charting.cs\ provides Plotly-based visualization helpers for rendering GC data trends, while \JoinAnalysis\ tracks thread join and wake-up events to analyze synchronization overhead.

src/benchmarks/gc/GC.Infrastructure/GC.Analysis.API/GCAnalysis · high confidence

The GCPerfSim benchmarking tool now provides a structured command-line interface with four distinct commands: \GCPerfSim\ (orchestrates local or remote server runs), \GCPerfSimAnalyze\ (processes trace files to generate Markdown or JSON reports), \GCPerfSimCompare\ (compares two trace files against each other), and \GCPerfSimFunctional\ (executes a suite of predefined functional scenarios and reports pass/fail status). This replaces the previous ad-hoc execution model with a configurable, YAML-driven workflow that supports environment variable injection, dump collection, and structured output generation.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure/Commands/GCPerfSim · high confidence

The performance testing infrastructure in eng/performance has been restructured to use a new Helix SDK-based project system. This introduces dedicated scenario definitions for Blazor (including SOD and AOT variants), MAUI (covering Android, iOS, and Desktop platforms with specific runtime configurations like Mono, CoreCLR, and NativeAOT), and NativeAOT console apps. The change adds shared configuration properties (Scenarios.Common.props), a payload preparation target (PreparePayloadWorkItems.targets), and a helix.proj for partitioning microbenchmarks, enabling consistent execution of startup, size-on-disk, and build-time measurements across these platforms on Helix agents.

eng/performance · high confidence

A new solution file, RealWorldBenchmarks.sln, has been added to the benchmarks/real-world directory. This solution aggregates several distinct benchmark projects, including DemoBenchmarks (BepuPhysics), ImageSharp.Benchmarks, Microsoft.ML.Benchmarks, CompilerBenchmarks (Roslyn), FSharp, ILLinkBenchmarks, BenchmarkDotNet.Extensions, and Akade.IndexedSet.Benchmarks. This change enables users to run these specific real-world workload benchmarks as a unified group.

src/benchmarks/real-world · high confidence

A new solution file (Reporting.sln) has been introduced for the Reporting tool, defining two projects: the main Reporting library and its corresponding test project (Reporting.Tests). This establishes the build structure for the new reporting capability.

src/tools/Reporting · high confidence

Added a suite of micro-benchmarks for System.Text.Json serialization in the \src/benchmarks/micro/libraries/System.Text.Json/Serializer\ directory. These new files measure cold-start performance, read/write operations via strings, UTF-8 bytes, streams, and \Utf8JsonWriter\, and specific behaviors like missing properties, case-insensitive matching, and reference preservation. The benchmarks also distinguish between reflection-based and source-generated serialization modes where supported.

src/benchmarks/micro/libraries/System.Text.Json/Serializer · high confidence

A new TraceCollector component has been added to the GC Infrastructure Core to enable trace collection for performance benchmarks on both Windows and Linux. On Windows, it utilizes PerfView to capture ETL traces with configurable event types (such as GC, CPU, and threading), while on Linux it leverages the dotnet-trace CLI tool to collect .nettrace files. The implementation includes automatic installation of these dependencies from a local folder or remote sources and supports various collection modes like GC-only, verbose, and CPU profiling.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure.Core/TraceCollection · high confidence

The GC benchmarking infrastructure now uses a structured YAML configuration system to define and validate benchmark runs. This change introduces dedicated configuration parsers for ASP.NET benchmarks, GCPerfSim, microbenchmarks, and reliability framework (RF) analysis, allowing users to specify run parameters, environment variables, output paths, and trace settings via YAML files. A key behavioral change is the enforcement of a policy that disallows COMPlus\_ environment variables in favor of DOTNET equivalents, ensuring consistent runtime configuration. The system also includes a Markdown report builder that automatically generates checklists and detailed failure reports for incomplete tests, improving visibility into benchmark execution status.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure.Core/Configurations · high confidence

The benchmark run command now includes a new set of base configuration files that define how specific benchmark suites are executed. This adds structured YAML and CSV definitions for ASP.NET benchmarks (separated by OS and combined), GCPerfSim scenarios (including Normal Workstation and Low Volatility server profiles with specific memory and GC parameters), and microbenchmarks (with invocation counts and specific test lists). It also introduces a percentile-based metrics configuration to calculate P50 through P99 values for working set and private memory from crank results, providing more granular memory usage insights for users analyzing benchmark outcomes.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure/Commands/RunCommand/BaseSuite · high confidence

The \src/harness\ location now includes a new \BenchmarkDotNet.Extensions\ library that enhances the benchmarking harness with several capabilities. It introduces a \PartitionFilter\ that uses SHA-256 hashing of test names to deterministically distribute benchmarks across partitions, enabling parallel CI runs. It adds \ExclusionFilter\ and \CategoryExclusionFilter\ to allow users to exclude specific benchmarks or categories via command-line arguments. Validation is strengthened with \MandatoryCategoryValidator\ (ensuring benchmarks belong to required CI categories), \NoWasmValidator\ (preventing async benchmarks from running on WASM), \TooManyTestCasesValidator\ (limiting test cases per benchmark to 16), and \UniqueArgumentsValidator\ (preventing duplicate argument combinations). A new \PerfLabExporter\ generates JSON reports for the CI lab environment, and \RecommendedConfig\ provides a standardized configuration including memory diagnosis, specific column providers, and optional diffable disassembly export.

src/harness · high confidence

The Common benchmarking library now includes several new internal components to support performance testing: an AlignedMemory class for allocating aligned memory buffers, a ConnectedStreams class providing in-memory producer/consumer streams for unidirectional and bidirectional communication, a MultiArrayBuffer struct for managing sliding buffers using pooled 16K blocks, and a ByteUtils helper for hex string conversion. Additionally, large text corpora in Chinese, Cyrillic, Greek, and English (ASCII and mostly ASCII) have been added as test data sources, alongside a FileUtils helper for generating temporary test file paths.

src/benchmarks/micro/libraries/Common · high confidence

The GC Infrastructure now includes dedicated command builders for ASP.NET benchmarks, GCPerfSim, and microbenchmarks, replacing or supplementing previous ad-hoc command construction. ASP.NET benchmark runs now automatically handle environment variable merging, GC log retrieval, trace collection (with OS-specific formats), framework version overrides, and artifact uploads via a centralized builder. GCPerfSim runs support both local execution (using corerun directly) and server-side execution via Crank, with parameter overriding and trace collection. Microbenchmark runs are built using dotnet CLI with configurable framework versions, filters, invocation counts, and artifact paths. These changes provide a more consistent and configurable way to construct benchmark commands across different workload types.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure.Core/CommandBuilders · high confidence

This change introduces a comprehensive set of scripts and configuration files to automate the creation of cross-compilation rootfs environments. It adds Tizen-specific patches and build scripts (tizen-build-rootfs.sh, tizen-fetch.sh) that apply linker script fixes to resolve library resolution issues on Tizen targets. It also includes a new build-android-rootfs.sh script to download and configure the Android NDK (defaulting to r21) and required Termux packages for Android arm64 builds. Additionally, a generalized build-rootfs.sh script is added to bootstrap rootfs images for various Linux distributions (Ubuntu, Alpine, Debian), FreeBSD, OpenBSD, Illumos, and Haiku, while a new install-debs.py utility provides asynchronous, checksum-verified package downloading. The toolchain.cmake file is updated to detect these new environments and configure the appropriate CMake toolchain chains for each supported architecture and OS.

eng/common/cross · high confidence

The micro-benchmarks location now includes a new solution and entry point that supports running benchmarks on WebAssembly (CoreCLR and Mono) with Ready-to-Run (R2R) compilation. This change introduces a Categories class to organize benchmarks (e.g., Runtime, Libraries, ThirdParty, NoWASM, NoInterpreter) and a Program.cs entry point that uses BenchmarkDotNet Extensions to filter benchmarks by category, partition runs, and apply exclusion filters. The WebAssembly build is configured via MicroBenchmarks.Wasm.props and .targets files, enabling partial trimming, reflection-enabled JSON serialization, and native symbol preservation. A new linker descriptor (ILLink.Descriptors.Serialization.xml) ensures System.Private.DataContractSerialization types are preserved. The harness also includes benchmarks for System.IO.Pipelines (Perf\_Pipe, PipeThroughputBenchmark) and integrates with BenchmarkDotNet.Extensions for validation (e.g., NoWasmValidator) and exit-code reporting.

src/benchmarks/micro · high confidence

Added new micro-benchmarks in the runtime benchmark suite to measure the performance of SIMD vectorization and various algorithmic optimizations. The Burgers benchmark compares scalar implementations against SIMD-optimized versions of the Burgers' equation solver, while the ConsoleMandel benchmark evaluates Mandelbrot set rendering across scalar and vectorized (SIMD) implementations using both float and double precision, with and without abstract data type abstractions. These benchmarks help track JIT and runtime performance improvements for numerical computing workloads.

src/benchmarks/micro/runtime/Burgers, src/benchmarks/micro/runtime/SIMD/ConsoleMandel · high confidence

Added new micro-benchmarks in the System.Reflection category to measure performance of Activator.CreateInstance (generic, type, and assembly-name variants), GetCustomAttributes and IsDefined (covering class and method inheritance scenarios), and MethodBase.Invoke (including MethodInvoker usage in .NET 8+ and various argument array configurations).

src/benchmarks/micro/runtime/System.Reflection · high confidence

Added a comprehensive suite of micro-benchmarks in the \src/benchmarks/micro/libraries/System.Runtime\ directory to measure the performance of core .NET types. The new files cover \Array\ (creation and access), \Boolean\, \Byte\, \Char\ (case conversion), \DateTime\ and \DateTimeOffset\ (parsing, formatting, and property access), \Decimal\ and \Double\ (arithmetic and parsing), \Enum\ (flags and generic operations), \Guid\ (equality and parsing), \Half\ (conversion), \HashCode\ (combining), \Int128\, \Int16\, \Int32\, \Int64\, \SByte\, and \Single\ (parsing, formatting, and \CopySign\). Additional benchmarks target \Lazy\<T\>\ initialization, \Object\ creation and \GetType\, and extensive \String\ operations including concatenation, joining, insertion, padding, removal, and substring extraction.

src/benchmarks/micro/libraries/System.Memory, src/benchmarks/micro/libraries/System.Runtime · high confidence

The GC performance analysis tooling now includes a dedicated microbenchmark comparison engine. This change introduces new classes (MicrobenchmarkComparisonResult, MicrobenchmarkResult, etc.) that enable the system to load BenchmarkDotNet JSON results, map them to corresponding GC trace files, and compute statistical comparisons (including mean differences, outlier removal, and percentage changes) between baseline and comparand runs. Users can now see detailed per-microbenchmark performance deltas and regression/improvement classifications directly in the analysis output.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure.Core/Analysis/Microbenchmarks · high confidence

The GC Infrastructure now includes dedicated CLI commands to run and analyze microbenchmarks. The new \MicrobenchmarkCommand\ orchestrates benchmark execution across multiple runs and iterations, handling process management, trace collection, and invocation count caching. The new \MicrobenchmarkAnalyzeCommand\ processes the resulting BDN JSON data, performs statistical comparisons, and outputs the results as Markdown tables or JSON files.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure/Commands/Microbenchmark · high confidence

The microbenchmark presentation layer now includes dedicated classes for generating output reports. A new \Json\ class allows serialization of comparison results into JSON files, while a comprehensive \Markdown\ class generates detailed Markdown reports. These reports include summary tables categorizing benchmarks by regression and improvement thresholds (e.g., large regressions \>= 20%, stale improvements), display individual comparison details, and support additional custom metrics defined in the configuration.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure.Core/Presentation/Microbenchmarks · high confidence

Added a comprehensive suite of microbenchmarks for the System.Buffers library, covering ArrayPool rent/return patterns, Base64 encoding/decoding (including in-place operations and the new IsValid check), BinaryPrimitives endianness handling, ReadOnlySequence iteration and slicing, SearchValues byte/char containment and indexing, and Utf8Parser/Utf8Formatter numeric and date-time conversions.

src/benchmarks/micro/libraries/System.Buffers · high confidence

The GC Infrastructure Notebooks directory now includes a new set of Polyglot Notebooks and supporting files to facilitate benchmark analysis. This adds \ASPNetBenchmarkAnalysis.ipynb\ for analyzing ASP.NET benchmark data, \BenchmarkAnalysis.dib\ and \Reports.dib\ for data management and reporting logic, and a \README.md\ with usage instructions. Additionally, example notebooks are provided in the \Examples\ subdirectory to demonstrate the GC Analysis API for CPU analysis, general GC analysis, and custom dynamic events.

src/benchmarks/gc/GC.Infrastructure/Notebooks · high confidence

Added new PowerShell scripts to the post-build pipeline to enhance validation and publishing capabilities. The \check-channel-consistency.ps1\ script validates that Maestro-assigned channels match the YAML configuration, preventing misconfigured asset promotions. \nuget-validation.ps1\ and \nuget-verification.ps1\ introduce automated metadata verification for NuGet packages using the \NuGet.VerifyMicrosoftPackage\ tool. \publish-using-darc.ps1\ streamlines the promotion of builds to default channels via the Darc CLI. Additionally, \redact-logs.ps1\ adds secure log redaction using the \binlogtool\, and \symbols-validation.ps1\ provides comprehensive validation of symbol availability on Microsoft Symbol Server (MSDL) and internal SymWeb servers.

eng/common/post-build · high confidence

The ML.NET benchmark suite now includes real-world datasets (Wikipedia Detox, UCI Iris, Breast Cancer Wisconsin, and UCI Adult) and a new HashBench class to measure the performance of the hashing transformer on scalar and vector inputs of various types. These benchmarks are tagged with the 'mldotnet' category for execution in Machine Learning CI jobs.

src/benchmarks/real-world/Microsoft.ML.Benchmarks · high confidence

The ScenarioMeasurement tool now includes a suite of new parsers in the Util/Parsers directory to capture specific performance metrics for Android development workflows. These include AndroidInnerLoopParser for build and deploy task durations, AndroidMemoryParser and AndroidPowerParser for device-side memory and power consumption data, and BuildTimeParser for analyzing binary log files. Additionally, new parsers such as GenericStartupParser, DeviceTimeToMain, DotnetWatchParser, InnerLoopParser, InnerLoopMsBuildParser, and Crossgen2Parser have been added to measure startup times, hot reload intervals, MSBuild evaluation times, and IL compiler (Crossgen2) performance intervals.

src/tools/ScenarioMeasurement/Util/Parsers · high confidence

The repository now includes a new internal build infrastructure under eng/common/internal. This adds a Directory.Build.props file that imports the Microsoft.DotNet.Arcade.Sdk while disabling the automatic import of Directory.Build.targets and Directory.Packages.props, and a NuGet.config that restricts package sources to the internal dotnet-core-internal-tooling feed. This ensures that internal builds use the Arcade SDK and internal package sources exclusively.

eng/common/internal · high confidence

A new localization settings file (P22DotNetHtmlLocalization.lss) has been added to configure the POMHTML parser for HTML localization. This configuration enables the automatic inclusion of terms that lack resource identifiers and sets the default behavior for charset information generation, ensuring that generated HTML files correctly reflect the target language's character encoding and reading order.

eng/common/loc · high confidence

The microbenchmarks project now automatically configures BenchmarkDotNet when executed via VSTest, ensuring that benchmarks are tagged with the 'Sve' mandatory category alongside Libraries, Runtime, and ThirdParty. This change allows SVE-specific microbenchmarks to be discovered and run through the standard VSTest adapter without requiring manual configuration overrides.

src/benchmarks/micro/Properties · high confidence

The GC Infrastructure benchmark runner has switched its default GCPerfSim configuration from the previous high-volatility (Normal) suite to a LowVolatility suite. This change is implemented in the \CreateSuitesCommand\ within the \RunCommand\ directory, which now references \LowVolatilityRuns.yaml\ instead of the previously commented-out \GCPerfSim\_Normal\_Workstation.yaml\. The rest of the run command logic (orchestrating GCPerfSim, Microbenchmarks, and ASP.NET benchmarks) remains structurally similar, but the underlying benchmark profile for GCPerfSim scenarios is now lower volatility.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure/Commands/RunCommand · high confidence

The GCPerfSim benchmark tool has been migrated from its previous Python infrastructure to a new C\# implementation. This change introduces a comprehensive set of command-line arguments to control simulation parameters, including thread count, allocation ratios for SOH/LOH/POH, request processing simulation, and object survival intervals. The new tool allows users to define complex multi-phase workloads via configuration files and provides detailed logging of GC performance metrics, replacing the older Python-based simulation capabilities.

src/benchmarks/gc/GCPerfSim · high confidence

The benchmark environment under src/benchmarks/gc/env has been replaced with a new C++/C implementation to support GC benchmarking on Windows. This change introduces a CMake build system and several native utilities: get\_host\_info.cpp gathers detailed CPU and cache topology; make\_memory\_load.c creates controlled memory pressure; run\_in\_job.c executes processes within Windows Job Objects with configurable memory and CPU limits; is\_in\_job.c checks job membership; and write\_pid\_and\_exec.py assists in launching processes while recording the parent PID. This infrastructure provides the low-level environment control previously handled by the deprecated Python setup.

src/benchmarks/gc/env · high confidence

The GCPerfSim analysis pipeline has been rebuilt with a new set of core classes in the Analysis namespace. \GCTraceMetrics\ now extracts detailed GC statistics (pause times, heap sizes, allocation rates) from trace files, while \GCTraceMetricComparison\ handles the parallel collection and statistical comparison of these metrics between baseline and comparand runs. A key behavioral improvement is the introduction of \MetricDirection\, which ensures that regression and improvement classifications are direction-aware (e.g., treating higher \Speed\_MBPerMSec\ as an improvement rather than a regression). The system also introduces \BdnJsonResult\ to model BenchmarkDotNet JSON output structures and \ProcessExecutionDetails\ to capture execution context, providing a more robust and accurate foundation for GC performance reporting.

src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure.Core/Analysis · high confidence

The ScenarioMeasurement tooling now uses a dedicated solution (ScenarioMeasurement.sln) that targets .NET 8 (via Directory.Build.props) and includes new projects for MemoryConsumption and PowerConsumption alongside existing Startup, Util, Reporting, SizeOnDisk, and Startup.Tests projects. This change establishes the build infrastructure and project structure for measuring power and memory consumption scenarios on .NET 8.

src/tools/ScenarioMeasurement · high confidence

Add Utf8JsonReader performance benchmarks; Add ValueTask performance benchmarks; Add benchmark for creating a Readonly memory mapped file and view accessor; Add benchmarks for System.Formats.Cbor COSE key serialization; Add benchmarks for X509Certificate2 and X509Chain operations; Add initial performance benchmarks for XmlConvert serialization; Add micro-benchmarks for System.Runtime.Extensions libraries; Add micro-benchmarks for interop, safe handles, and crypto primitives; Added LINQ micro-benchmarks for Where queries; Added benchmarks for ConfigurationBinder and GetChildKeys performance; Added benchmarks for System.Numerics.Tensors TensorPrimitives; Added benchmarks for System.Reflection.Metadata TypeName parsing; Added benchmarks for System.Text.Json Node operations; Added benchmarks for runtime if-statement performance; Added benchmarks for struct-based span enumerators and wrappers; Added micro-benchmarks for ASCII, UTF-8, and generic Encoding operations; Added micro-benchmarks for BigInteger operations; Added micro-benchmarks for StringSegment and StringValues; Added micro-benchmarks for System.Console I/O and color operations; Added micro-benchmarks for System.Diagnostics components; Added micro-benchmarks for System.Net.Primitives types; Added micro-benchmarks for System.Threading.Timer performance; Added micro-benchmarks for array deabstraction performance; Added micro-benchmarks for new single/double precision Math APIs; Added microbenchmarks for Crc32 and Crc64 hashing algorithms; Added microbenchmarks for EventListener and EventSource performance; Added microbenchmarks for System.Text.Encodings.Web encoders; Added new StringBuilder micro-benchmarks; Added notebook-based functional tests for the GC Infrastructure; Added real-world benchmarks for Akade.IndexedSet; Added startup trace session tests for Windows and Linux; Added strength reduction benchmarks for loop iterations; Added test coverage for performance scripts and WASM CoreCLR R2R workflows; Added tests for BenchmarkDotNet.Extensions harness components; Added unit tests for CertHelper components; Added unit tests for DynamicEvent schema validation; Added unit tests for GC Infrastructure Core components; Added unit tests for ResultsComparer tool; Added unit tests for the Reporting tool's reporter and environment mocking; New micro-benchmarks for System.Globalization string and culture operations; New micro-benchmarks for Utf8JsonWriter performance; New microbenchmarks for ComWrappers RCW lookup and Marshal structure operations; New microbenchmarks for System.Numerics.Vectors types and operations.

This change introduces the new GC Infrastructure tooling, including the GC.Analysis.API, GC.Infrastructure.Core, and MCPServer components, all targeting .NET 10.0. It also adds a new requirements.txt file pinning Python dependencies such as cryptography to 48.0.1, azure.storage packages, and opentelemetry libraries, while updating the internal build tools manifest to include MicroBuild and IBCMerge.

(dependencies) · high confidence

The WASM microbenchmark project now uses a dedicated nuget.config file that replaces the default nuget.org feed with a specific set of Azure Artifacts sources (dotnet-public, dotnet6, xamarin, dotnet-eng, dotnet-tools, and benchmark-dotnet-prerelease). This ensures that benchmark dependencies are resolved from the internal .NET engineering feeds rather than the public registry.

src/benchmarks/micro/wasm · high confidence

The build and test infrastructure dependencies have been updated to the latest builds from dotnet/arcade, dotnet/maui, dotnet/runtime, dotnet/aspnetcore, dotnet/emsdk, dotnet/android, dotnet/windowsdesktop, dotnet/macios, dotnet/xharness, and dotnet/dotnet. These updates ensure the performance testing pipelines use the most recent tooling, SDKs, and runtime components, maintaining compatibility and stability for continuous integration runs across various .NET versions and platforms.

(repo-wide) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 38.

• Code Health 73
• Architecture 94
• Maturity 56
• Readiness 49
• Security 21
• Accessibility 45
• Performance 81

• 300 commits — 264 feature/other, 36 fixes

• src/benchmarks — 71 commits
• (root) — 54 commits
• eng/pipelines — 46 commits
• eng/Version.Details.xml — 29 commits
• src/scenarios — 21 commits
• eng/performance — 17 commits
• scripts/run_performance_job.py — 13 commits
• eng/common — 11 commits
• src/tools — 8 commits
• reports/net9to10 — 4 commits
• scripts/channel_map.py — 4 commits
• eng/Versions.props — 3 commits
• scripts/benchmarks_ci.py — 3 commits
• docs/benchmarkdotnet.md — 2 commits
• scripts/ci_setup.py — 2 commits
• scripts/dotnet.py — 2 commits
• src/harness — 2 commits
• .azuredevops/dependabot.yml — 1 commit
• .github/workflows — 1 commit
• docs/benchmarking-workflow-dotnet-runtime.md — 1 commit

• fix: Disable blazor_scenarios testing in runtime-wasm-perf-jobs.yml until it is fixed. (#5058)
• fix: Fix F# nested type definition error & disable x86. (#4972)
• fix: Fix GC ASPNet bnechmarks on Linux (#5239)
• fix: Fix GC aspnet test machines (#5234)
• fix: Fix GC performance infrastructure tests on Linux (#5236)
• fix: Fix GC pipeline (#5210)
• fix: Fix MAUI Android inner loop MSBuild arg splitting on Helix (#5285)
• fix: Fix MAUI NuGet config pinning when workload feeds fall back (#5302)
• fix: Fix SVE benchmark CreateWhileLessThanMask API rename for .NET 11 (#5183)
• fix: Fix SignOutSessionStateManager compilation error for .NET 11+ (#5086)
• fix: Fix Sve benchmark warning and config (#5012)
• fix: Fix WASM tool framework version rollover (#5310)
• fix: Fix Windows Helix work item exit code and prerequisite error handling (#5075)
• fix: Fix markdownlint issues (#4998)
• fix: Fix wasm_coreclr runtime type missing from the exclusion list. (#5130)
• fix: Fix aspnetcore perf-build CI failures found in first test runs (#5255)
• fix: Fix command syntax for creating virtual environment (#5082)
• fix: Fix device selection by switching from device name to UUID (#5111)
• fix: Fix duplicated test name in Perf.TypeName and update validation (#4898)
• fix: Fix exception handling in resource monitoring loop to continue on error (#5115)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

dotnet/performance was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.