Use allocated memory for fixed heap pressure (envoyproxy#41442)

After applying this PR the fixed heap resource monitor will use
allocated memory for memory pressure calculation, so reported pressure
is lower and more accurate. This can prevent unnecessary load shedding
when there is enough free memory.
New formula is simply: `currently_allocated / max_heap_size` and it does
not include any overhead that allocations might have.
See
envoyproxy#21923 (comment)
for background.
**Risk Level:** Low
**Testing:** test case added
**Docs Changes:**
**Release Notes:**
**Runtime guard:** `envoy.reloadable_features.fixed_heap_use_allocated`.
Default value is `false`.

Fixes envoyproxy#21923

---------

Signed-off-by: Tero Saarni <[email protected]>
Signed-off-by: Tero Saarni <[email protected]>

Author: tsaarni

changelogs/current.yaml

@@ -18,5 +18,12 @@ removed_config_or_runtime:
 # *Normally occurs at the end of the* :ref:`deprecation period <deprecated>`
 
 new_features:
+- area: overload management
+  change: |
+    The fixed heap resource monitor can now calculate memory pressure as currently allocated memory divided by maximum heap size,
+    giving more accurate and lower memory pressure values.
+    This can avoid unnecessary load shedding or overload actions.
+    To enable, set ``envoy.reloadable_features.fixed_heap_use_allocated`` to true.
+    The default algorithm (heap_size - pageheap_unmapped - pageheap_free) does not discount for free memory in TCMalloc caches.
 
 deprecated:

source/common/runtime/runtime_features.cc

@@ -190,6 +190,8 @@ FALSE_RUNTIME_GUARD(envoy_restart_features_use_cached_grpc_client_for_xds);
 // Runtime guard to revert back to old non-RFC-compliant CONNECT behavior without Host header.
 // TODO(vinaykul): Drop this false-runtime-guard when deemed safe with RFC 9110 compliant CONNECT.
 FALSE_RUNTIME_GUARD(envoy_reloadable_features_http_11_proxy_connect_legacy_format);
+// TODO(tsaarni): Flip to true after prod testing or remove.
+FALSE_RUNTIME_GUARD(envoy_reloadable_features_fixed_heap_use_allocated);
 
 // Block of non-boolean flags. Use of int flags is deprecated. Do not add more.
 ABSL_FLAG(uint64_t, re2_max_program_size_error_level, 100, ""); // NOLINT

source/extensions/resource_monitors/fixed_heap/fixed_heap_monitor.cc

@@ -4,6 +4,7 @@
 
 #include "source/common/common/assert.h"
 #include "source/common/memory/stats.h"
+#include "source/common/runtime/runtime_features.h"
 
 namespace Envoy {
 namespace Extensions {
@@ -16,6 +17,10 @@ uint64_t MemoryStatsReader::unmappedHeapBytes() { return Memory::Stats::totalPag
 
 uint64_t MemoryStatsReader::freeMappedHeapBytes() { return Memory::Stats::totalPageHeapFree(); }
 
+uint64_t MemoryStatsReader::allocatedHeapBytes() {
+  return Memory::Stats::totalCurrentlyAllocated();
+}
+
 FixedHeapMonitor::FixedHeapMonitor(
     const envoy::extensions::resource_monitors::fixed_heap::v3::FixedHeapConfig& config,
     std::unique_ptr<MemoryStatsReader> stats)
@@ -25,16 +30,17 @@ FixedHeapMonitor::FixedHeapMonitor(
 
 void FixedHeapMonitor::updateResourceUsage(Server::ResourceUpdateCallbacks& callbacks) {
 
-  auto computeUsedMemory = [this]() -> size_t {
+  size_t used = 0;
+  if (Runtime::runtimeFeatureEnabled("envoy.reloadable_features.fixed_heap_use_allocated")) {
+    used = stats_->allocatedHeapBytes();
+  } else {
     const size_t physical = stats_->reservedHeapBytes();
     const size_t unmapped = stats_->unmappedHeapBytes();
     const size_t free_mapped = stats_->freeMappedHeapBytes();
     ASSERT(physical >= (unmapped + free_mapped));
-    return physical - unmapped - free_mapped;
+    used = physical - unmapped - free_mapped;
   };
 
-  const size_t used = computeUsedMemory();
-
   Server::ResourceUsage usage;
   usage.resource_pressure_ = used / static_cast<double>(max_heap_);
 

source/extensions/resource_monitors/fixed_heap/fixed_heap_monitor.h

@@ -22,6 +22,8 @@ class MemoryStatsReader {
   virtual uint64_t unmappedHeapBytes();
   // Memory in free, mapped pages in the page heap.
   virtual uint64_t freeMappedHeapBytes();
+  // Memory currently allocated by the process.
+  virtual uint64_t allocatedHeapBytes();
 };
 
 /**

test/extensions/resource_monitors/fixed_heap/BUILD

@@ -18,6 +18,7 @@ envoy_extension_cc_test(
     rbe_pool = "6gig",
     deps = [
         "//source/extensions/resource_monitors/fixed_heap:fixed_heap_monitor",
+        "//test/test_common:test_runtime_lib",
         "@com_google_absl//absl/types:optional",
         "@envoy_api//envoy/extensions/resource_monitors/fixed_heap/v3:pkg_cc_proto",
     ],

test/extensions/resource_monitors/fixed_heap/fixed_heap_monitor_test.cc

@@ -2,6 +2,8 @@
 
 #include "source/extensions/resource_monitors/fixed_heap/fixed_heap_monitor.h"
 
+#include "test/test_common/test_runtime.h"
+
 #include "absl/types/optional.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
@@ -21,6 +23,7 @@ class MockMemoryStatsReader : public MemoryStatsReader {
   MOCK_METHOD(uint64_t, reservedHeapBytes, ());
   MOCK_METHOD(uint64_t, unmappedHeapBytes, ());
   MOCK_METHOD(uint64_t, freeMappedHeapBytes, ());
+  MOCK_METHOD(uint64_t, allocatedHeapBytes, ());
 };
 
 class ResourcePressure : public Server::ResourceUpdateCallbacks {
@@ -58,6 +61,23 @@ TEST(FixedHeapMonitorTest, ComputesCorrectUsage) {
   EXPECT_EQ(resource.pressure(), 0.5);
 }
 
+TEST(FixedHeapMonitorTest, ComputesCorrectUsageRuntimeUseAllocated) {
+  TestScopedRuntime scoped_runtime;
+  scoped_runtime.mergeValues({{"envoy.reloadable_features.fixed_heap_use_allocated", "true"}});
+
+  envoy::extensions::resource_monitors::fixed_heap::v3::FixedHeapConfig config;
+  config.set_max_heap_size_bytes(1000);
+  auto stats_reader = std::make_unique<MockMemoryStatsReader>();
+  EXPECT_CALL(*stats_reader, allocatedHeapBytes()).WillOnce(Return(600));
+  auto monitor = std::make_unique<FixedHeapMonitor>(config, std::move(stats_reader));
+
+  ResourcePressure resource;
+  monitor->updateResourceUsage(resource);
+  ASSERT_TRUE(resource.hasPressure());
+  ASSERT_FALSE(resource.hasError());
+  EXPECT_EQ(resource.pressure(), 0.6);
+}
+
 TEST(FixedHeapMonitorTest, ComputeUsageWithRealMemoryStats) {
 
   envoy::extensions::resource_monitors::fixed_heap::v3::FixedHeapConfig config;
@@ -74,6 +94,24 @@ TEST(FixedHeapMonitorTest, ComputeUsageWithRealMemoryStats) {
   monitor->updateResourceUsage(resource);
   EXPECT_NEAR(resource.pressure(), expected_usage, 0.0005);
 }
+
+TEST(FixedHeapMonitorTest, ComputesUsageRuntimeUseAllocatedWithRealMemoryStats) {
+  TestScopedRuntime scoped_runtime;
+  scoped_runtime.mergeValues({{"envoy.reloadable_features.fixed_heap_use_allocated", "true"}});
+
+  envoy::extensions::resource_monitors::fixed_heap::v3::FixedHeapConfig config;
+  const uint64_t max_heap = 1024 * 1024 * 1024;
+  config.set_max_heap_size_bytes(max_heap);
+  auto stats_reader = std::make_unique<MemoryStatsReader>();
+  const double expected_pressure =
+      stats_reader->allocatedHeapBytes() / static_cast<double>(max_heap);
+  auto monitor = std::make_unique<FixedHeapMonitor>(config, std::move(stats_reader));
+
+  ResourcePressure resource;
+  monitor->updateResourceUsage(resource);
+  EXPECT_NEAR(resource.pressure(), expected_pressure, 0.0005);
+}
+
 } // namespace
 } // namespace FixedHeapMonitor
 } // namespace ResourceMonitors