[martincostello]

Description

Reduces per-request CPU and allocations in AWSSDK.Core's request pipeline. Each change was profiled (dotnet-trace, GC allocation ticks, and a mocked-HTTP harness) and measured in isolation against a baseline build; only changes with a measurable win were kept.

One commit per logical change:

1. Chunked upload buffers sized to the payload. ChunkedUploadWrapperStream allocated two ~80 KB buffers per request regardless of body size. Buffers are now sized to the known remaining length for plain streams (encrypting streams keep the full size), the read-and-copy path clamps reads to the space left in the chunk, the short final chunk is signed in place instead of being copied, and the chunk header is written directly into the output buffer.
2. Lambda environment lookups cached. AWS_LAMBDA_FUNCTION_NAME / AWS_LAMBDA_MAX_CONCURRENCY are read once per process instead of on every request; the per-invocation trace id is still read per request.
3. Telemetry no-op short-circuit. TracingUtilities.CreateSpan returns a shared no-op span when no tracer is registered, and HTTP telemetry recording is skipped when both the tracer and meter providers are no-ops.
4. SigV4 hashing from pooled buffers (net8+). The canonical request and string-to-sign are encoded into a pooled buffer and hashed with the span APIs instead of allocating byte[] copies.
5. Pooled JSON buffers returned after each response. StreamingUtf8JsonReader only returned its 4 KB pooled buffer when a caller read past the end of the stream, but generated unmarshallers stop at the root value's closing token, so every JSON response effectively allocated a new 4 KB array. The buffer is released when the root value closes, and the Unmarshaller handler disposes the context for non-streaming responses (returning its pooled path buffer too). Extracted to Return pooled JSON reader buffers after each response #4567.
6. Endpoint resolution allocations. Services whose auth schemes come from the endpoint ruleset (S3) evaluated the ruleset twice per request; the first result is reused when the parameters are unchanged. Partition(region) builds one prototype bag per partition and hands out exact-size copies. Extracted to Reduce endpoint resolution allocations #4568.
7. Logger lookup and debug-message guard. Logger.GetLogger no longer locks around its ConcurrentDictionary, and CanonicalizeResourcePathV2 only builds its debug message arguments when a debug logger is attached. HttpClientResponseData drops a redundant per-response HashSet. Extracted to Trim per-request logger overhead #4569.

Motivation and Context

Steady-state cost of a request through the pipeline (mocked HTTP, no network), branch vs development (9ab8dcf), best of three interleaved rounds. Ratios are branch ÷ baseline.

Operation	Baseline min / median / alloc	Branch min / median / alloc	Time ratio (min / median)	Alloc ratio
DynamoDB GetItem	19.8 µs / 20.9 µs / 28.70 KB	16.7 µs / 18.1 µs / 21.67 KB	0.84 / 0.87	0.76
SQS SendMessage	16.9 µs / 18.1 µs / 26.02 KB	14.9 µs / 16.2 µs / 19.00 KB	0.88 / 0.89	0.73
S3 PutObject (40 B body)	46.0 µs / 48.0 µs / 205.36 KB	28.3 µs / 29.7 µs / 35.30 KB	0.62 / 0.62	0.17
S3 ListBuckets	33.5 µs / 34.5 µs / 48.77 KB	27.1 µs / 28.5 µs / 39.86 KB	0.81 / 0.83	0.82

Allocation figures are exact (GC.GetAllocatedBytesForCurrentThread) and identical across rounds. Timings are per operation on an i7-13700H (process pinned to the P-cores), .NET 10 runtime against the net8.0 build of the SDK, after a 6 s warm-up so tiered compilation has settled; each row is the best of three interleaved baseline/branch rounds of 20 × 2000 operations. Individual commit messages record the effect measured for that commit alone.

Benchmark code

The harness is not checked in. It is a console project that references the SDK projects directly, replaces the HTTP client with a canned-response handler, and measures a full client call through the pipeline. Build it once from the default branch and copy bin/Release/net10.0 to CoreBench-base, then build it from the branch and run ab.sh "ddb sqs put list" 3.

CoreBench.csproj

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>disable</Nullable>
    <LangVersion>latest</LangVersion>
    <ServerGarbageCollection>false</ServerGarbageCollection>
    <TieredPGO>true</TieredPGO>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="BenchmarkDotNet" Version="0.15.2" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="D:\Coding\aws\aws-sdk-net\sdk\src\Core\AWSSDK.Core.NetStandard.csproj" />
    <ProjectReference Include="D:\Coding\aws\aws-sdk-net\sdk\src\Services\DynamoDBv2\AWSSDK.DynamoDBv2.NetStandard.csproj" />
    <ProjectReference Include="D:\Coding\aws\aws-sdk-net\sdk\src\Services\S3\AWSSDK.S3.NetStandard.csproj" />
    <ProjectReference Include="D:\Coding\aws\aws-sdk-net\sdk\src\Services\SQS\AWSSDK.SQS.NetStandard.csproj" />
  </ItemGroup>
</Project>

Benchmarks.cs

using Amazon;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;
using Amazon.S3;
using Amazon.S3.Model;
using Amazon.SQS;
using Amazon.SQS.Model;
using BenchmarkDotNet.Attributes;

namespace CoreBench;

[MemoryDiagnoser]
public class PipelineBenchmarks
{
    private AmazonDynamoDBClient _ddb;
    private AmazonS3Client _s3;
    private AmazonSQSClient _sqs;
    private GetItemRequest _getItem;
    private PutObjectRequest _putObject;
    private ListBucketsRequest _listBuckets;
    private SendMessageRequest _sendMessage;

    [GlobalSetup]
    public void Setup()
    {
        var creds = new BasicAWSCredentials("AKIAIOSFODNN7EXAMPLE", "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY");
        var factory = new MockHttpClientFactory();
        _ddb = new AmazonDynamoDBClient(creds, new AmazonDynamoDBConfig { RegionEndpoint = RegionEndpoint.USEast1, HttpClientFactory = factory });
        _s3 = new AmazonS3Client(creds, new AmazonS3Config { RegionEndpoint = RegionEndpoint.USEast1, HttpClientFactory = factory });
        _sqs = new AmazonSQSClient(creds, new AmazonSQSConfig { RegionEndpoint = RegionEndpoint.USEast1, HttpClientFactory = factory });

        _getItem = new GetItemRequest
        {
            TableName = "BenchmarkTable",
            Key = new Dictionary<string, AttributeValue>
            {
                ["pk"] = new AttributeValue { S = "id-1" },
                ["sk"] = new AttributeValue { S = "sort-1" },
            },
            ConsistentRead = true,
        };
        _putObject = new PutObjectRequest
        {
            BucketName = "my-bucket",
            Key = "some/key.txt",
            ContentBody = "hello world, this is a small object body",
            ContentType = "text/plain",
        };
        _listBuckets = new ListBucketsRequest();
        _sendMessage = new SendMessageRequest
        {
            QueueUrl = "https://sqs.us-east-1.amazonaws.com/123456789012/my-queue",
            MessageBody = MockHttpMessageHandler.SqsBody,
        };

        // warm once to fail fast on bad mock wiring
        DynamoGetItem().GetAwaiter().GetResult();
        S3PutObject().GetAwaiter().GetResult();
        S3ListBuckets().GetAwaiter().GetResult();
        SqsSendMessage().GetAwaiter().GetResult();
    }

    [Benchmark] public Task<GetItemResponse> DynamoGetItem() => _ddb.GetItemAsync(_getItem);
    [Benchmark] public Task<PutObjectResponse> S3PutObject() => _s3.PutObjectAsync(_putObject);
    [Benchmark] public PutObjectResponse S3PutObjectSync() => _s3.PutObjectAsync(_putObject).GetAwaiter().GetResult();
    [Benchmark] public Task<ListBucketsResponse> S3ListBuckets() => _s3.ListBucketsAsync(_listBuckets);
    [Benchmark] public Task<SendMessageResponse> SqsSendMessage() => _sqs.SendMessageAsync(_sendMessage);
}

MockHttp.cs

using System.Net;
using System.Security.Cryptography;
using System.Text;
using Amazon.Runtime;

namespace CoreBench;

public sealed class MockHttpClientFactory : HttpClientFactory
{
    public override HttpClient CreateHttpClient(IClientConfig clientConfig)
        => new HttpClient(new MockHttpMessageHandler(), disposeHandler: true);

    public override bool UseSDKHttpClientCaching(IClientConfig clientConfig) => true;
}

public sealed class MockHttpMessageHandler : HttpMessageHandler
{
    public const string SqsBody = "hello world";
    public static readonly byte[] DdbGetItemBytes = Encoding.UTF8.GetBytes(
        "{\"Item\":{\"pk\":{\"S\":\"id-1\"},\"sk\":{\"S\":\"sort-1\"},\"payload\":{\"S\":\"" + new string('a', 256) + "\"},\"count\":{\"N\":\"42\"},\"flag\":{\"BOOL\":true}}}");
    private static readonly byte[] SqsSendMessage = Encoding.UTF8.GetBytes(
        "{\"MD5OfMessageBody\":\"" + Convert.ToHexString(MD5.HashData(Encoding.UTF8.GetBytes(SqsBody))).ToLowerInvariant() + "\",\"MessageId\":\"5fea7756-0ea4-451a-a703-a558b933e274\"}");
    private static readonly byte[] S3ListBuckets = Encoding.UTF8.GetBytes(
        "<?xml version=\"1.0\" encoding=\"UTF-8\"?><ListAllMyBucketsResult xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\"><Owner><ID>abc</ID><DisplayName>me</DisplayName></Owner><Buckets><Bucket><Name>bucket-a</Name><CreationDate>2020-01-01T00:00:00.000Z</CreationDate></Bucket><Bucket><Name>bucket-b</Name><CreationDate>2020-01-02T00:00:00.000Z</CreationDate></Bucket></Buckets></ListAllMyBucketsResult>");
    private static readonly byte[] Empty = Array.Empty<byte>();

    protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        var host = request.RequestUri.Host;
        HttpResponseMessage response;
        if (host.StartsWith("dynamodb", StringComparison.Ordinal))
        {
            response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent(DdbGetItemBytes) };
            response.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/x-amz-json-1.0");
        }
        else if (host.StartsWith("sqs", StringComparison.Ordinal))
        {
            response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent(SqsSendMessage) };
            response.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/x-amz-json-1.0");
        }
        else if (request.Method == HttpMethod.Put)
        {
            response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent(Empty) };
            response.Headers.TryAddWithoutValidation("ETag", "\"9a0364b9e99bb480dd25e1f0284c8555\"");
        }
        else
        {
            response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent(S3ListBuckets) };
            response.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/xml");
        }
        response.Headers.TryAddWithoutValidation("x-amzn-RequestId", "0123456789abcdef");
        response.Headers.TryAddWithoutValidation("x-amz-id-2", "abcdefghijklmnopqrstuvwxyz");
        response.RequestMessage = request;
        return Task.FromResult(response);
    }
}

Program.cs

using BenchmarkDotNet.Running;
using CoreBench;

if (args.Length > 0 && args[0] == "bench")
{
    // Hybrid CPU (P + E cores): keep the process on the performance cores so the single benchmark
    // thread is not scheduled onto an efficiency core mid-run. Override with BENCH_AFFINITY (hex mask).
    var mask = Environment.GetEnvironmentVariable("BENCH_AFFINITY");
    System.Diagnostics.Process.GetCurrentProcess().ProcessorAffinity =
        (IntPtr)(mask != null ? Convert.ToInt64(mask, 16) : 0xFFF);

    // Self-contained steady-state harness: time-based warm-up (so tiered compilation settles), then
    // measures blocks and reports min / median / mean per operation plus allocated bytes per operation.
    var b = new PipelineBenchmarks();
    b.Setup();
    var which = args.Length > 1 ? args[1] : "put";
    var warmupSeconds = args.Length > 2 ? double.Parse(args[2]) : 6;
    var blocks = args.Length > 3 ? int.Parse(args[3]) : 20;
    var blockIters = args.Length > 4 ? int.Parse(args[4]) : 2000;
    Func<Task> op = which switch
    {
        "ddb" => () => b.DynamoGetItem(),
        "put" => () => b.S3PutObject(),
        "list" => () => b.S3ListBuckets(),
        "sqs" => () => b.SqsSendMessage(),
        _ => throw new ArgumentException(which),
    };
    var sw = System.Diagnostics.Stopwatch.StartNew();
    long warmIters = 0;
    while (sw.Elapsed.TotalSeconds < warmupSeconds || warmIters < 20000)
    {
        op().GetAwaiter().GetResult();
        warmIters++;
    }
    var results = new List<double>();
    long allocBefore = GC.GetAllocatedBytesForCurrentThread();
    for (int k = 0; k < blocks; k++)
    {
        var t0 = System.Diagnostics.Stopwatch.GetTimestamp();
        for (int i = 0; i < blockIters; i++) op().GetAwaiter().GetResult();
        var t1 = System.Diagnostics.Stopwatch.GetTimestamp();
        results.Add((t1 - t0) * 1_000_000.0 / System.Diagnostics.Stopwatch.Frequency / blockIters);
    }
    long allocAfter = GC.GetAllocatedBytesForCurrentThread();
    results.Sort();
    var median = results[results.Count / 2];
    var mean = results.Average();
    var allocPerOp = (allocAfter - allocBefore) / (double)(blocks * blockIters);
    Console.WriteLine($"{which,-5} min {results[0],7:F2} us  median {median,7:F2} us  mean {mean,7:F2} us  alloc {allocPerOp / 1024,7:F2} KB  (warmup {warmIters} iters)");
    return;
}

// BenchmarkDotNet (use --inProcess so the saved baseline binaries are the ones measured)
BenchmarkSwitcher.FromAssembly(typeof(PipelineBenchmarks).Assembly).Run(args);

ab.sh

#!/bin/bash
# Usage: ab.sh "<ops>" [rounds] [warmupSeconds]
# Runs the harness for the baseline build (CoreBench-base, built from the default branch)
# and the candidate build alternately, so machine noise affects both the same way.
BASE="./CoreBench-base/CoreBench.exe"
NEW="./CoreBench/bin/Release/net10.0/CoreBench.exe"
OPS="$1"; ROUNDS="${2:-2}"; WARM="${3:-6}"
for op in $OPS; do
  for r in $(seq 1 $ROUNDS); do
    for v in base new; do
      if [ $v = base ]; then exe="$BASE"; else exe="$NEW"; fi
      echo "[$v r$r] $("$exe" bench $op $WARM 20 2000 | tail -1)"
    done
  done
done

Testing

• AWSSDK.Core.NetStandard.csproj and AWSSDK.Core.NetFramework.csproj build for all targets with no warnings.
• AWSSDK.UnitTests.Core on net472: 1562 passed, 2 failed (DefaultCredentialsResolverTests.CredentialsAreReevaluated*), and those two fail identically on development on the same machine because they depend on local credential state.
• The net8.0 test target compiles but could not be executed locally (MSTest adapter/framework mismatch in this environment), so the net8-only code paths and the new HttpClientResponseDataTests rely on CI for their first run.
• New tests: chunk buffer sizing (exact-size, full-size for non-seekable and encrypting streams), the read-and-copy clamp with an oversized read buffer, multi-chunk round-trip with chunk signatures recomputed independently, endpoint cache hit / miss / null parameters, early pooled-buffer release with invalid bytes after the root value, and response header ordering and lookups.
• Two existing tests were updated to reset the new Lambda environment cache after changing environment variables.

Dry-runs

• DotNet Dry-run ID: N/A (external contribution)
  • Pending
  • Completed successfully
  • Failed
• PowerShell Dry-run ID: N/A (external contribution)
  • Pending
  • Completed successfully
  • Failed

Breaking Changes Assessment

1. No public API changes. Behavioral notes:
   • ChunkedUploadWrapperStream buffer sizes are now payload-dependent for seekable, non-encrypting streams; the emitted aws-chunked content is unchanged (tests pin chunk sizes and signatures).
   • The Lambda function name / max-concurrency environment variables are read once per process. The Lambda runtime sets them before user code runs, so deployed behavior is unchanged; tests that toggle them use an internal reset hook.
   • StreamingUtf8JsonReader.Read returns false after the root value's closing token instead of attempting to read past it; reading further would previously have thrown on trailing non-JSON bytes.
2. Reviewer assignment is at the maintainers' discretion.

Types of changes

• Bug fix (non-breaking change which fixes an issue)
• New feature (non-breaking change which adds functionality)
• Breaking change (fix or feature that would cause existing functionality to change)

Checklist

• My code follows the code style of this project
• My change requires a change to the documentation
• I have updated the documentation accordingly
• I have read the README document
• I have added tests to cover my changes
• All new and existing tests passed

License

• I confirm that this pull request can be released under the Apache 2 license

---

This change was generated by AI tools (Claude Code), and reviewed by Martin Costello (@martincostello).

🤖 Generated with Claude Code

[Copilot]

Copilot was unable to review this pull request because the user who requested the review has insufficient remaining quota.

[jnunn-aws]

Thanks, Martin. This is well organized and well measured.

Several of these changes overlap draft PRs we already have open:

• Telemetry no-op span and HTTP telemetry skip: Make disabled request metrics and no-op tracing nearly free #4559, Trim per-request work in the HttpClient adapter #4561
• HttpClientResponseData: Trim per-request work in the HttpClient adapter #4561
• Lambda environment cache: Read AWS_LAMBDA_FUNCTION_NAME once for recursion detection #4563
• SigV4 hashing: Reduce managed overhead and crypto calls in SigV4 signing #4558
• Chunk buffer sizing: [4.1] Reduce CPU and allocations for checksums and chunked uploads #4533

The JSON pooled-buffer release, the endpoint reuse with the Partition prototype, and the logger trims aren't covered by any of those. Could you split those three into separate PRs? That way each can be reviewed and measured on its own, without conflicting with the drafts above.

*Edited to remove prior suggestion to target feature/4.1 branch.

[martincostello]

The JSON pooled-buffer release, the endpoint reuse with the Partition prototype, and the logger trims aren't covered by any of those. Could you split those three into separate PRs?

Created #4567, #4568 and #4569 for those three changes.

[martincostello]

I also created #4570 which builds on top of the same ideas as #4533 with some fixes for findings during a local review loop of 56aa152.

[jnunn-aws]

Thanks again, Martin! Everything here is now covered elsewhere: the JSON buffer, endpoint reuse and logger changes in #4567–#4569, chunked uploads in #4570, and the rest in our #4558, #4559, #4561, #4563 and #4533. I'm closing this in favor of those.