Perf framework: align with .NET Azure.Test.Perf (#7201)

* Perf framework: align with .NET Azure.Test.Perf (Option A parity)

Brings the C++ perf framework (sdk/core/perf) and Storage Blob perf tests
to format / contract parity with the .NET Azure.Test.Perf reference, which
the cross-language perf-automation pipeline keys off.

Framework (sdk/core/perf)
-------------------------
* New per-op latency collector (latency_stats.{hpp,cpp}) emitting the .NET
  8-percentile distribution: 50 / 75 / 90 / 99 / 99.9 / 99.99 / 99.999 /
  100 with the exact `=== Latency Distribution ===` header and
  `{pct,7:N3}%   {ms,8:N2}ms` row format.
* New CPU + memory sampler (process_stats.{hpp,cpp}); the throughput
  `Completed N operations ... (Y ops/s, Z s/op, P% CPU)` line now
  includes inline CPU like .NET while preserving the existing `(... ops/s`
  substring that downstream Cpp.cs regex relies on.
* New result_output.{hpp,cpp}:
   - `--results-file` writes `[{ "Time": <ms>, "Size": <bytes> }, ...]`
     matching .NET OperationResult schema (PascalCase, Size = -1 when test
     has no SizeOptions).
   - `--statistics` / `--job-statistics` wraps a `BenchmarkOutput`
     envelope between `#StartJobStatistics` and `#EndJobStatistics`
     with Metadata before Measurements (key order matches .NET).
   - Timestamp emitted at 100-nanosecond (7-digit) resolution like
     .NET DateTime.ToString("O").
* New versions.{hpp,cpp} printing a `=== Versions ===` block as the
  last thing emitted by the run (matches .NET ordering).
* New options: `--status-interval`, `--results-file`, `--sync`
  (all present in .NET PerfOptions).
* New non-breaking CLI aliases matching .NET names:
   - `--job-statistics` (bare switch) alongside existing `--statistics <0|1>`
   - `--no-cleanup` (bare switch) alongside existing `--noclean <0|1>`
* GTest coverage for latency, process_stats, circular_stream, and
  result_output (9 tests, all passing).

Storage Blob perf tests (sdk/storage/azure-storage-blobs/test/perf)
-------------------------------------------------------------------
* New blob-test flags aligning the C++ UploadBlob / DownloadBlob / ListBlob
  scenarios with the .NET / Go test surface:
   - `--upload-method` (buffer | stream | single)
   - `--download-method` (buffer | stream)
   - `--block-size`, `--concurrency`, `--num-blobs`, `--page-size`
* Memory-budget guard (memory_budget.hpp) prevents OOM in buffer-mode
  tests at multi-GiB payloads.

Verification
------------
Built MinSizeRel on Windows / VS 2026 with vcpkg x64-windows-static
(curl, openssl, gtest). All 9 unit tests pass. A live perf run against
the `euap` storage account using AzureCliCredential produced output
that diffs byte-clean against an equivalent .NET Azure.Storage.Blobs.Perf
run for every contract emitted by this change (latency distribution
header / rows, throughput line shape including `% CPU`,
BenchmarkOutput JSON shape and key order, timestamp precision,
Versions-block ordering, results-file schema).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Perf framework: drop versions.hpp / versions.cpp

The `=== Versions ===` block didn't actually mirror .NET's
PerfProgram.PrintAssemblyVersions: it printed compiler / __cplusplus
strings rather than runtime + Azure assembly versions, no caller ever
populated the `injectedVersions` extension point, and the data the
perf-automation pipeline consumes (the per-test `VCPKG_*_VERSION`
lines and the throughput / latency / BenchmarkOutput contracts) is
unaffected. The module produced output that no parser reads and that
isn't faithful to the framework it claims parity with, so drop it.

Also revert the azure-storage-blobs CHANGELOG entry from the previous
commit: the perf harness is internal and isn't customer-facing.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Storage Blobs perf: drop memory_budget.hpp

The guard threw a friendly std::runtime_error when `--size x --parallel`
would exceed 80%% of system memory, instead of letting buffer-mode
allocations OOM-kill the process. Assuming perf runs target hosts with
enough memory for the configured size, this is dead defensive code: drop
the header and the two `CheckMemoryBudget` calls in
upload_blob_test.hpp / download_blob_test.hpp. Oversized buffer-mode
runs now fail with std::bad_alloc / OS OOM as they would natively.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Perf: fix stack-overflow risk and stale CPU baseline after sampler reset

Addresses two Copilot review comments on PR #7201 that are real bugs:

1. download_blob_test.hpp: the streaming-download per-op loop declared
   `uint8_t buffer[1024*1024]` on the stack. On Windows the default
   thread stack is 1 MiB, so a single call already overflows; high
   `--parallel` makes it worse. Replace with a function-local
   `static thread_local std::vector<uint8_t>`: each worker thread
   allocates the 1 MiB drain buffer once on the heap and reuses it
   across operations.

2. process_stats.cpp: `ProcessStatsSampler::Reset()` updated members
   under the mutex but the sampler thread's `Run()` had already cached
   `previousCpuSeconds` / `previousTime` in locals, so the first
   sample after reset computed cpuDelta / wall against the pre-reset
   baseline and reported a wrong CPU%. Reset now stops and restarts the
   thread, which forces `Run()` to re-read the fresh baselines.

Verified: 9/9 perf unit tests still pass.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Perf: fix CI validations (ASCII, clang-format, cspell)

- Replace em-dashes with -- in two comments
- Add 'perfstress' to cspell dictionary (used in BenchmarkDotNet-compatible
  metric name to match .NET Azure.Test.Perf output)
- Apply clang-format to perf framework files

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Address review feedback: drop --sync, --job-statistics alias, and CPU/memory sampler

Per @jalauzon-msft review on PR #7201:
- Remove --sync (parsed-and-ignored option had no behavior). PerfAutomation
  is updated separately to set NoSync=true for the Cpp language so it never
  appends --sync to test arguments.
- Remove the --job-statistics bare-switch alias; keep --statistics <0|1>
  which is what perf-automation actually invokes.
- Remove the CPU/memory sampler (ProcessStatsSampler) and the associated
  ' Memory(MiB)' / '% CPU' columns; perf-automation tracks the process
  itself, so per-run sampling in C++ added complexity without value.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* perf: accept --sync as a no-op flag for cross-language CLI compatibility

PerfAutomation appends '--sync' to test runs for sync-only languages. C++ has
no async variant, but the driver still passes --sync, so the perf binary must
accept it. Register --sync as a bare switch that is parsed and intentionally
ignored, with no corresponding Sync field on GlobalTestOptions (so it doesn't
show up in the JSON options dump or anywhere else).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Revert perf-tests.yml additions to avoid confusion

The new --upload-method/--download-method/--block-size/--concurrency/--page-size
flags are available on the binaries but should be tuned per host, not baked
into the CI matrix. Keep perf-tests.yml at the pre-PR baseline.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Jinming-Hu

.vscode/cspell.json

@@ -226,6 +226,7 @@
     "PCERT",
     "PBYTE",
     "pdbs",
+    "perfstress",
     "phoebusm",
     "Piotrowski",
     "pkcs",

sdk/core/perf/CMakeLists.txt

@@ -18,9 +18,11 @@ set(
   inc/azure/perf/argagg.hpp
   inc/azure/perf/base_test.hpp
   inc/azure/perf/dynamic_test_options.hpp
+  inc/azure/perf/latency_stats.hpp
   inc/azure/perf/options.hpp
   inc/azure/perf/program.hpp
   inc/azure/perf/random_stream.hpp
+  inc/azure/perf/result_output.hpp
   inc/azure/perf/test.hpp
   inc/azure/perf/test_metadata.hpp
   inc/azure/perf/test_options.hpp
@@ -30,9 +32,11 @@ set(
   AZURE_PERFORMANCE_SOURCE
   src/arg_parser.cpp
   src/base_test.cpp
+  src/latency_stats.cpp
   src/options.cpp
   src/program.cpp
   src/random_stream.cpp
+  src/result_output.cpp
 )
 
 add_library(azure-perf ${AZURE_PERFORMANCE_HEADER} ${AZURE_PERFORMANCE_SOURCE})

sdk/core/perf/inc/azure/perf.hpp

@@ -12,8 +12,11 @@
 #include "azure/perf/argagg.hpp"
 #include "azure/perf/base_test.hpp"
 #include "azure/perf/dynamic_test_options.hpp"
+#include "azure/perf/latency_stats.hpp"
 #include "azure/perf/options.hpp"
 #include "azure/perf/program.hpp"
+#include "azure/perf/random_stream.hpp"
+#include "azure/perf/result_output.hpp"
 #include "azure/perf/test.hpp"
 #include "azure/perf/test_metadata.hpp"
 #include "azure/perf/test_options.hpp"

sdk/core/perf/inc/azure/perf/latency_stats.hpp

@@ -0,0 +1,105 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+/**
+ * @file
+ * @brief Per-operation latency collector and percentile summary.
+ *
+ */
+
+#pragma once
+
+#include <chrono>
+#include <cstdint>
+#include <mutex>
+#include <string>
+#include <vector>
+
+namespace Azure { namespace Perf {
+
+  /**
+   * @brief Thread-safe collector of per-operation latency samples.
+   *
+   * @remark Records nanosecond-resolution durations from many worker threads and computes
+   * percentile summaries (p50/p90/p95/p99/max) on demand. Designed to match the latency
+   * reporting added in the Go perf framework so cross-language results are comparable.
+   *
+   */
+  class LatencyCollector {
+  public:
+    /**
+     * @brief A single latency sample, optionally tagged by call type.
+     *
+     */
+    struct Sample
+    {
+      std::chrono::nanoseconds Duration{0};
+      std::string CallType;
+    };
+
+    /**
+     * @brief Latency summary expressed in milliseconds, matching the .NET
+     * `Azure.Test.Perf` percentile distribution: 50, 75, 90, 99, 99.9, 99.99, 99.999, 100.
+     *
+     */
+    struct Summary
+    {
+      uint64_t Count = 0;
+      double P50Ms = 0;
+      double P75Ms = 0;
+      double P90Ms = 0;
+      double P99Ms = 0;
+      double P999Ms = 0;
+      double P9999Ms = 0;
+      double P99999Ms = 0;
+      double P100Ms = 0;
+      double MeanMs = 0;
+    };
+
+    /**
+     * @brief Record a single latency sample with no call-type tag.
+     *
+     * @param duration The latency to record.
+     */
+    void Record(std::chrono::nanoseconds duration);
+
+    /**
+     * @brief Record a single latency sample tagged with a call type.
+     *
+     * @param callType A short label for the operation (e.g. "Upload").
+     * @param duration The latency to record.
+     */
+    void Record(std::string const& callType, std::chrono::nanoseconds duration);
+
+    /**
+     * @brief Clear all recorded samples.
+     *
+     */
+    void Reset();
+
+    /**
+     * @brief Compute the summary over all recorded samples.
+     *
+     * @return The percentile summary.
+     */
+    Summary Summarize() const;
+
+    /**
+     * @brief Compute summaries grouped by call type.
+     *
+     * @return A vector of (callType, summary) pairs, sorted by callType.
+     */
+    std::vector<std::pair<std::string, Summary>> SummarizeByCallType() const;
+
+    /**
+     * @brief Snapshot all recorded samples (copy).
+     *
+     */
+    std::vector<Sample> Samples() const;
+
+  private:
+    mutable std::mutex m_mutex;
+    std::vector<Sample> m_samples;
+  };
+
+}} // namespace Azure::Perf

sdk/core/perf/inc/azure/perf/options.hpp

@@ -108,6 +108,22 @@ namespace Azure { namespace Perf {
      */
     std::vector<std::string> TestProxies;
 
+    /**
+     * @brief Interval in seconds between live status lines printed during a run.
+     *
+     */
+    int StatusInterval = 1;
+
+    /**
+     * @brief When set, write a per-operation results file (JSON) containing the per-op
+     * latency (ms) and the per-op size (bytes) for every measured operation, matching the
+     * .NET `OperationResult { Time, Size }` schema.
+     *
+     * @remark Only populated when #Latency is also enabled.
+     *
+     */
+    std::string ResultsFile;
+
     /**
      * @brief Create an array of the performance framework options.
      *

sdk/core/perf/inc/azure/perf/result_output.hpp

@@ -0,0 +1,84 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+/**
+ * @file
+ * @brief Run-summary helpers: `--results-file` writer and `#StartJobStatistics` printer.
+ *
+ */
+
+#pragma once
+
+#include "azure/perf/latency_stats.hpp"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace Azure { namespace Perf {
+
+  /**
+   * @brief A consolidated run summary used by the framework. Fields mirror the data
+   * already printed in the .NET reference framework's results block.
+   *
+   */
+  struct RunSummary
+  {
+    std::string TestName;
+    int Parallel = 1;
+    int DurationSeconds = 0;
+    int Warmup = 0;
+    int Iterations = 1;
+    uint64_t TotalOperations = 0;
+    double WeightedAverageSeconds = 0;
+    double OperationsPerSecond = 0;
+    double SecondsPerOperation = 0;
+    LatencyCollector::Summary Latency;
+    std::vector<std::pair<std::string, LatencyCollector::Summary>> LatencyByCallType;
+  };
+
+  /**
+   * @brief A single per-operation result, matching the .NET
+   * `Azure.Test.Perf.OperationResult { Time, Size }` schema.
+   *
+   * `Time` is the operation latency in milliseconds; `Size` is the operation size in
+   * bytes (or -1 if the test does not have a meaningful size).
+   *
+   */
+  struct OperationResult
+  {
+    double Time = 0;
+    int64_t Size = -1;
+  };
+
+  /**
+   * @brief Write per-operation results to `path` as a JSON array of
+   * `OperationResult { Time, Size }` objects, matching the .NET `--results-file` output
+   * shape.
+   *
+   * @param path Destination file.
+   * @param results The per-operation samples to write.
+   */
+  void WriteResultsFile(std::string const& path, std::vector<OperationResult> const& results);
+
+  /**
+   * @brief Print the `#StartJobStatistics`/`#EndJobStatistics` JSON block consumed by the
+   * perf-automation tool.
+   *
+   * @details The payload matches the .NET reference framework's `BenchmarkOutput`
+   * envelope:
+   * ```
+   * { "Metadata": [
+   *     {"Source","Name","ShortDescription","LongDescription","Format"}
+   *   ],
+   *   "Measurements": [
+   *     {"Timestamp","Name","Value"}
+   *   ]
+   * }
+   * ```
+   *
+   * @param summary The run summary to serialize.
+   */
+  void PrintJobStatistics(RunSummary const& summary);
+
+}} // namespace Azure::Perf

sdk/core/perf/src/arg_parser.cpp

@@ -78,6 +78,11 @@ Azure::Perf::GlobalTestOptions Azure::Perf::Program::ArgParser::Parse(
   {
     options.NoCleanup = parsedArgs["NoCleanup"].as<bool>();
   }
+  // .NET-compatible bare-switch alias --no-cleanup; presence implies true.
+  if (parsedArgs["NoCleanupSwitch"])
+  {
+    options.NoCleanup = true;
+  }
   if (parsedArgs["Parallel"])
   {
     options.Parallel = parsedArgs["Parallel"];
@@ -103,6 +108,14 @@ Azure::Perf::GlobalTestOptions Azure::Perf::Program::ArgParser::Parse(
       options.TestProxies.push_back(proxy);
     }
   }
+  if (parsedArgs["StatusInterval"])
+  {
+    options.StatusInterval = parsedArgs["StatusInterval"];
+  }
+  if (parsedArgs["ResultsFile"])
+  {
+    options.ResultsFile = parsedArgs["ResultsFile"].as<std::string>();
+  }
 
   return options;
 }