Add memory-streaming stride-sweep to feature extractors (prod DRAM/LLC match)

Differential Revision: D114964801

Author: excelle08

packages/feedsim/third_party/src/workloads/ranking/feature_extractors/FeatureExtractorSuite.cpp

@@ -9,6 +9,8 @@
 #include <iostream>
 #include <random>
 
+#include "generated/extractor_helpers.h"
+
 void FeatureExtractorSuite::addExtractor(
     std::unique_ptr<FeatureExtractorBase> extractor) {
   extractors_.push_back(std::move(extractor));
@@ -191,7 +193,15 @@ void FeatureExtractorSuite::runFlatExtractors(
   size_t start = flat_pos_.fetch_add(static_cast<size_t>(count),
                                      std::memory_order_relaxed) %
       total;
+  // Memory-streaming lever: FEEDSIM_SWEEP_N reads per call over a large
+  // read-only buffer, folded into live state so it can't be elided. No-op
+  // when FEEDSIM_SWEEP_N=0. Hoist the enabled check out of the loop.
+  const int sweep_n = dcperf::feature_extractors::helpers::sweepReadsPerCall();
   for (int i = 0; i < count; ++i) {
     flat_copies_[(start + static_cast<size_t>(i)) % total](&ctx);
+    if (sweep_n > 0) {
+      local_struct[0] += dcperf::feature_extractors::helpers::runStrideSweep(
+          start + static_cast<size_t>(i));
+    }
   }
 }

packages/feedsim/third_party/src/workloads/ranking/feature_extractors/generated/extractor_helpers.cpp

@@ -5,7 +5,11 @@
 
 #include "extractor_helpers.h"
 #include <cmath>
+#include <cstdint>
+#include <cstdlib>
 #include <cstring>
+#include <mutex>
+#include <vector>
 
 namespace dcperf {
 namespace feature_extractors {
@@ -280,6 +284,84 @@ float cappedConvertFloat(double value, float min_val, float max_val) {
   return result;
 }
 
+// ======================================================================
+// Memory-streaming stride sweep (backend/DRAM-pressure lever)
+// ======================================================================
+
+namespace {
+
+struct SweepConfig {
+  std::vector<float> buf;  // process-wide, read-only after init
+  size_t size = 0;         // element count
+  int n = 0;               // reads per extractor call (FEEDSIM_SWEEP_N)
+  size_t stride = 16;      // element stride (FEEDSIM_SWEEP_STRIDE); 16 = 64B line
+};
+
+SweepConfig g_sweep;
+std::once_flag g_sweep_once;
+
+int envInt(const char* name, int fallback) {
+  const char* v = std::getenv(name);
+  if (v == nullptr || v[0] == '\0') {
+    return fallback;
+  }
+  int parsed = std::atoi(v);
+  return parsed;
+}
+
+void initSweep() {
+  // Defaults are the validated winning config (CPL/BGM/Grace, 2026-08-04):
+  // 16 strided reads/call over a 64 MB DRAM-resident buffer at a 64 B (1 cache
+  // line) stride. This closes most of the DRAM-bandwidth / LLC / L1-D / IPC gap
+  // to prod (BGM mean uArch err 27%->18%, Grace 34%->23%). Override any knob via
+  // the FEEDSIM_SWEEP_* env vars; set FEEDSIM_SWEEP_N=0 to disable entirely.
+  int mb = envInt("FEEDSIM_SWEEP_MB", 64);
+  if (mb < 1) {
+    mb = 1;
+  }
+  g_sweep.n = envInt("FEEDSIM_SWEEP_N", 16);
+  if (g_sweep.n < 0) {
+    g_sweep.n = 0;
+  }
+  int stride = envInt("FEEDSIM_SWEEP_STRIDE", 16);
+  g_sweep.stride = stride < 1 ? 1 : static_cast<size_t>(stride);
+  g_sweep.size = static_cast<size_t>(mb) * 1024 * 1024 / sizeof(float);
+  g_sweep.buf.resize(g_sweep.size);
+  // Fill with pseudo-random data so the compiler can't fold the buffer away.
+  uint64_t s = 0x9E3779B97F4A7C15ULL;
+  for (size_t i = 0; i < g_sweep.size; ++i) {
+    s = s * 6364136223846793005ULL + 1442695040888963407ULL;
+    g_sweep.buf[i] = static_cast<float>((s >> 40) & 0xFFFF) * 1e-3f;
+  }
+}
+
+} // namespace
+
+int sweepReadsPerCall() {
+  std::call_once(g_sweep_once, initSweep);
+  return g_sweep.n;
+}
+
+float runStrideSweep(uint64_t seed) {
+  const SweepConfig& c = g_sweep;
+  if (c.n == 0 || c.size == 0) {
+    return 0.0f;
+  }
+  // Rotate the start offset per call so successive calls cover the whole
+  // buffer rather than re-touching one region (that was the flaw in the
+  // earlier size-only bumps and the B3 random gather).
+  size_t off = (seed * 2654435761ULL) % c.size;
+  float acc = 0.0f;
+  for (int i = 0; i < c.n; ++i) {
+    acc += c.buf[off];
+    off += c.stride;
+    if (off >= c.size) {
+      off -= c.size;
+    }
+  }
+  return acc;
+}
+
 } // namespace helpers
 } // namespace feature_extractors
 } // namespace dcperf

packages/feedsim/third_party/src/workloads/ranking/feature_extractors/generated/extractor_helpers.h

@@ -115,6 +115,24 @@ bool validateFeatureValue(float value, int validation_type);
 __attribute__((noinline))
 float cappedConvertFloat(double value, float min_val, float max_val);
 
+// ======================================================================
+// Memory-streaming stride sweep (backend/DRAM-pressure lever)
+// ======================================================================
+// Reads FEEDSIM_SWEEP_N elements, FEEDSIM_SWEEP_STRIDE floats apart, from a
+// process-wide read-only buffer of FEEDSIM_SWEEP_MB megabytes. Adds genuine
+// memory-level-parallelism / working-set pressure per extractor call to close
+// the backend-bound / DRAM-bandwidth gap vs prod. All three knobs are read
+// from the environment once, so one build sweeps the full parameter space;
+// FEEDSIM_SWEEP_N=0 (default) makes it a no-op. Returns FEEDSIM_SWEEP_N (cached
+// after first call, which initializes the buffer).
+int sweepReadsPerCall();
+
+// Accumulate a strided walk seeded by `seed` (rotates the start offset so
+// successive calls cover the whole buffer). Caller folds the result into live
+// state to defeat dead-code elimination. Assumes sweepReadsPerCall() ran first.
+__attribute__((noinline))
+float runStrideSweep(uint64_t seed);
+
 } // namespace helpers
 } // namespace feature_extractors
 } // namespace dcperf