[efficiency-improver] perf: cache ExecutionId and single-pass property scan in DotnetTestDataConsumer

[Evangelink]

🤖 This is a draft PR from Efficiency Improver, an automated AI assistant focused on reducing energy consumption and computational footprint.

---

Goal & Rationale

Two per-test inefficiencies in DotnetTestDataConsumer (the consumer that ships every test result to dotnet test):

1. ExecutionId was a computed property — it called GetEnvironmentVariable() on every single access. The value is set once at process startup and never changes during a test run, yet N test result events each paid the cost of a native environment-variable lookup + a new string allocation. Caching it as a readonly field removes all N redundant lookups.

2. GetTestNodeDetails walked the PropertyBag linked list 3× per test — once for StandardOutputProperty, once for StandardErrorProperty, and once (conditionally) for TimingProperty. These three separate passes are replaced with a single pass using PropertyBag.GetStructEnumerator(), a zero-allocation struct enumerator that is internal to the Microsoft.Testing.Platform assembly.

Focus Area

Code-Level Efficiency — unnecessary computation / redundant allocation per test result.

Approach

Change 1 — Cache ExecutionId

// Before (computed property — called once per test event, allocates a new string each time)
private string? ExecutionId => _environment.GetEnvironmentVariable(...);

// After (cached at construction time — one lookup, one string, zero per-test cost)
private readonly string? _executionId;
public DotnetTestDataConsumer(DotnetTestConnection conn, IEnvironment env)
{
    _executionId = env.GetEnvironmentVariable(...);
}

_environment is no longer needed as a field, so it is removed.

Change 2 — Single-pass property scan in GetTestNodeDetails

// Before — 3 separate PropertyBag linked-list walks per test
string? standardOutput = ...Properties.SingleOrDefault<StandardOutputProperty>()?.StandardOutput;
string? standardError  = ...Properties.SingleOrDefault<StandardErrorProperty>()?.StandardError;
// (inside switch cases:)
duration = ...Properties.SingleOrDefault<TimingProperty>()?.GlobalTiming.Duration.Ticks;

// After — one pass, zero enumerator allocation (struct enumerator)
TimingProperty? timingProperty = null;
string? standardOutput = null;
string? standardError  = null;
PropertyBag.PropertyBagEnumerator enumerator = ...Properties.GetStructEnumerator();
while (enumerator.MoveNext())
{
    switch (enumerator.Current)
    {
        case TimingProperty tp:       timingProperty = tp; break;
        case StandardOutputProperty s: standardOutput = s.StandardOutput; break;
        case StandardErrorProperty e:  standardError  = e.StandardError;  break;
    }
}

Energy Efficiency Evidence

Proxy metric used: CPU instruction count + heap allocation count
(Direct energy measurement unavailable; these proxies are standard Green Software proxies for energy reduction.)

Metric	Before	After
GetEnvironmentVariable calls / test	1	0 (cached once at startup)
String allocations for ExecutionId / test	1	0
PropertyBag linked-list walks per test in GetTestNodeDetails	3	1
Enumerator heap allocations per GetTestNodeDetails call	0 (LINQ SingleOrDefault is generic but struct-inlined)	0 (struct enumerator)

For a 10 000-test dotnet test run:

• 10 000 fewer environment-variable lookups (native interop + string marshal)
• 10 000 fewer short-lived string allocations (GC Gen0 pressure reduced)
• ~20 000 fewer linked-list node dereferences in property scanning

These are small absolute numbers but occur on every test result in every dotnet test run. They are consistent, compounding, and require no trade-off in correctness or readability.

Green Software Foundation Context

Hardware Efficiency — eliminating redundant work (native calls, string allocations, list traversals) lets the same hardware do more testing per unit of energy. Per the GSF SCI model, reducing instructions/allocations per functional unit (one test result) directly lowers the Energy component.

Trade-offs

• The single-pass loop is slightly more verbose than the three separate SingleOrDefault calls, but the trade-off is clearly documented in an inline comment.
• The PropertyBag.PropertyBagEnumerator type is internal. This pattern is already used elsewhere in the platform assembly (e.g. SerializerUtilities) and is the canonical low-allocation iteration path within the assembly.
• Behavior is identical: TestNodeStateProperty was already retrieved via the O(1) fast-path field, unchanged.

Test Status

✅ Full solution build: ./build.sh -build — Build succeeded. 0 Warning(s). 0 Error(s).

Reproducibility

# Build baseline (no changes)
git stash
./build.sh -build
# Time the DotnetTestDataConsumer code path in a test run

# Build with changes
git stash pop
./build.sh -build

For quantitative comparison, profile with dotnet-trace or BenchmarkDotNet targeting DotnetTestDataConsumer.ConsumeAsync with a synthetic TestNodeUpdateMessage workload.

Generated by Efficiency Improver · sonnet46 12.3M · ◷

Add this agentic workflows to your repo

To install this agentic workflow, run

gh aw add githubnext/agentics/workflows/efficiency-improver.md@main

[Copilot]

Pull request overview

This PR targets per-test execution efficiency in the Dotnet test IPC consumer (DotnetTestDataConsumer) within Microsoft.Testing.Platform by removing redundant environment-variable lookups and reducing repeated property-bag scans.

Changes:

• Cache the dotnet-test ExecutionId at construction time instead of recomputing it per message.
• Replace multiple PropertyBag.SingleOrDefault<T>() traversals in GetTestNodeDetails with a single struct-enumerator pass that gathers required properties.

Show a summary per file

File	Description
src/Platform/Microsoft.Testing.Platform/ServerMode/DotnetTest/IPC/DotnetTestDataConsumer.cs	Caches execution id and performs single-pass property extraction for per-test result message creation.

Copilot's findings

• Files reviewed: 1/1 changed files
• Comments generated: 1