[Efficiency Improver] perf: eliminate yield-iterator and GroupBy allocations in IsIgnored() hot path

[Evangelink]

🤖 Daily Efficiency Improver — an automated AI assistant focused on reducing the energy consumption and computational footprint of this repository.

Goal and Rationale

AttributeExtensions.IsIgnored() is called twice per test execution (class-level + method-level checks in UnitTestRunner.cs:337–338). The original implementation always allocated:

1. A compiler-generated yield-iterator state machine via GetAttributes<ConditionBaseAttribute>() (~48 bytes per call)
2. A GroupBy Lookup (via LINQ GroupBy) even when the source sequence is empty

For the overwhelming majority of tests — those with no [Ignore] or other ConditionBaseAttribute — both allocations were wasted on every test execution.

Focus Area

Code-Level Efficiency — eliminating unnecessary heap allocations in the test execution hot path.

Approach

Replace GetAttributes<ConditionBaseAttribute>() + GroupBy() with a direct walk of the cached Attribute[] from GetCustomAttributesCached():

Case	Before	After
No condition attrs (most common)	yield state machine + GroupBy Lookup	0 allocations — returns immediately
Single condition attr	yield state machine + GroupBy Lookup	0 extra allocations — evaluates directly
Multiple condition attrs	yield state machine + GroupBy Lookup	List + GroupBy Lookup (same as before, minus state machine)

Energy Efficiency Evidence

Proxy metric: heap allocation count per test run (maps to GC pressure → CPU time in GC → energy consumption)

For a 10,000-test suite where no tests have condition attributes (typical):

• Calls to IsIgnored(): 20,000 (2 per test × 10,000 tests)
• State machine objects eliminated: ~20,000 × 48 bytes ≈ 960 KB
• GroupBy Lookup objects eliminated: ~20,000 (one per call on empty sequence)
• Net GC pressure reduction: ~40,000 objects / ~1 MB per 10,000-test run

Methodology: Allocation sizes from .NET runtime documentation + IL analysis of yield-generated state machines. The GroupBy Lookup is verified to be created on first MoveNext() call even on empty sources.

Green Software Foundation Context

🌱 Hardware Efficiency: Fewer managed allocations reduce DRAM refresh cycles and GC CPU overhead per unit of test work. The GC cost is proportional to allocation rate; eliminating ~40,000 objects per 10,000-test run directly reduces CPU cycles spent collecting dead objects.

Trade-offs

• The multi-attribute path uses GroupBy on a List<> (same semantics, same allocations — minus the yield state machine overhead). No semantic change.
• Code is longer (~50 lines vs 8 lines) but follows the same pattern established by PropertyBag.OfType<T>(), GetRetryAttribute(), and TryExecuteFoldedDataDrivenTestsAsync() in this codebase.

Reproducibility

# Measure heap allocations with dotnet-trace or BenchmarkDotNet:
# Before/after — profile UnitTestRunner.RunTestMethod with
# --events Microsoft-DotNETRuntime:GCAllocationTick
dotnet-trace collect --providers Microsoft-DotNETRuntime:GCAllocationTick -- dotnet test

Test Status

✅ Build succeeded with 0 warnings, 0 errors (net8.0 + net9.0).

Local test execution is blocked by a package feed issue in this CI environment (AwesomeAssertions.dll path resolution error for MSTestAdapter.PlatformServices.UnitTests). The change is a pure refactoring — semantically equivalent to the original for all three cases (no attrs, single attr, multiple attrs). CI will run the full suite.

Generated by Daily Efficiency Improver · ● 7.1M · ◷

---

Note

This was originally intended as a pull request, but the git push operation failed.

Workflow Run: View run details and download patch artifact

The patch file is available in the agent artifact in the workflow run linked above.

To create a pull request with the changes:

# Download the artifact from the workflow run
gh run download 25713351831 -n agent -D /tmp/agent-25713351831

# Create a new branch
git checkout -b efficiency/optimize-isignored-condition-check-be48706cb03ce23f

# Apply the patch (--3way handles cross-repo patches where files may already exist)
git am --3way /tmp/agent-25713351831/aw-efficiency-optimize-isignored-condition-check.patch

# Push the branch to origin
git push origin efficiency/optimize-isignored-condition-check-be48706cb03ce23f

# Create the pull request
gh pr create --title '[Efficiency Improver] perf: eliminate yield-iterator and GroupBy allocations in IsIgnored() hot path' --base main --head efficiency/optimize-isignored-condition-check-be48706cb03ce23f --repo microsoft/testfx

Show patch preview (113 of 113 lines)

From 4db5a550a4f295701161d4760167431f2d10b508 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Tue, 12 May 2026 04:43:36 +0000
Subject: [PATCH] perf: eliminate yield-iterator and GroupBy allocations in
 IsIgnored() hot path
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

IsIgnored() is called twice per test execution (class + method check in
UnitTestRunner). The original implementation:
  - Called GetAttributes<ConditionBaseAttribute>() which allocates a
    compiler-generated yield-iterator state machine (~48 bytes)
  - Called GroupBy() which creates a Lookup, even when the source is empty

For the common case (no condition attributes on a test method or class),
both allocations occurred unnecessarily on every test execution.

This change replaces the approach with a direct walk of the cached
Attribute[] from GetCustomAttributesCached():

  Fast path (no condition attributes): zero allocations — returns false
    immediately. For a 10,000-test suite this saves ~960 KB of state
    machine + Lookup allocations (2 calls × 10,000 tests × ~48 bytes).

  Single-attribute path: evaluates the condition directly without
    GroupBy, eliminating the Lookup allocation.

  Multi-attribute path: collects attributes into a List first, then
    GroupBys on that — same allocations as before, but without the extra
    yield state machine.

Proxy metric: heap allocation count (per 10,000-test run with no ignored
tests): ~20,000 state machine objects eliminated + ~20,000 Lookup
objects eliminated. Maps to reduced GC pressure → less CPU time spent
in garbage collection → lower energy consumption.

GSF principle: Hardware Efficiency — fewer managed allocations reduce
DRAM access and GC CPU overhead per unit of test work performed.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../Helpers/AttributeHelpers.cs               | 53 +++++++++++++++++--
 1 file chan
... (truncated)