Do not allow machine_memory_info data source instability

Author: jsikstro

src/hotspot/share/gc/z/zAdaptiveHeap.cpp

@@ -33,6 +33,7 @@
 #include "logging/log.hpp"
 #include "runtime/atomicAccess.hpp"
 #include "runtime/globals_extension.hpp"
+#include "runtime/java.hpp"
 #include "runtime/os.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/globalDefinitions.hpp"
@@ -45,6 +46,7 @@ bool ZAdaptiveHeap::_can_adapt;
 bool ZAdaptiveHeap::_initialized;
 bool ZAdaptiveHeap::_initialized_generation_data;
 ZAdaptiveHeap::ZIntensitySmoother ZAdaptiveHeap::_gc_intensities;
+ZBooleanStability ZAdaptiveHeap::_machine_memory_info_valid;
 
 Atomic<double> ZAdaptiveHeap::_young_to_old_gc_time(0.0);
 double ZAdaptiveHeap::_accumulated_young_gc_time = 0.0;
@@ -57,6 +59,21 @@ static double calculate_progression(double availability, double from, double to)
   return 1.0 - (availability - to) / (from - to);
 }
 
+bool ZBooleanStability::record_and_check_stability(bool observed) {
+  const ValidityState observed_state = observed ? ValidityState::ObservedTrue : ValidityState::ObservedFalse;
+
+  ValidityState expected_state = _expected_state.load_relaxed();
+  if (expected_state == ValidityState::Uninitialized) {
+    expected_state = _expected_state.compare_exchange(ValidityState::Uninitialized, observed_state);
+    if (expected_state == ValidityState::Uninitialized) {
+      // This is the first observation, so nothing to compare against
+      return true;
+    }
+  }
+
+  return expected_state == observed_state;
+}
+
 void ZAdaptiveHeap::ZIntensitySmoother::initialize() {
   _lock = new ZLock();
 }
@@ -285,6 +302,13 @@ ZMemoryPressureMetrics ZAdaptiveHeap::memory_pressure_metrics() {
 
   const ZMachineMemoryInfo machine_memory_info = ZAdaptiveHeap::machine_memory_info();
 
+  if (!_machine_memory_info_valid.record_and_check_stability(machine_memory_info._is_valid)) {
+    log_warning(gc)("The data source for machine_memory_info is unstable (expected _is_valid to be %s, got %s). "
+                    "This behavior is unsupported for Automatic Heap Sizing. Please run without Automatic Heap Sizing using -XX:ZGCIntensity=0",
+                    BOOL_TO_STR(!machine_memory_info._is_valid), BOOL_TO_STR(machine_memory_info._is_valid));
+    vm_exit(1);
+  }
+
   const physical_memory_size_type machine_max_memory = machine_memory_info._physical_memory;
 
   const physical_memory_size_type machine_used_memory = machine_memory_info._is_valid

src/hotspot/share/gc/z/zAdaptiveHeap.hpp

@@ -86,6 +86,23 @@ struct ZMachineMemoryInfo {
   bool _is_valid;
 };
 
+struct ZBooleanStability {
+private:
+  enum class ValidityState {
+    Uninitialized,
+    ObservedFalse,
+    ObservedTrue,
+  };
+
+  Atomic<ValidityState> _expected_state;
+
+public:
+  ZBooleanStability()
+    : _expected_state(ValidityState::Uninitialized) {}
+
+  bool record_and_check_stability(bool observed);
+};
+
 class ZAdaptiveHeap : public AllStatic {
   friend class ZAdaptiveHeapTest;
 private:
@@ -139,6 +156,7 @@ class ZAdaptiveHeap : public AllStatic {
   static ZGenerationOverhead _old_data;
   static Atomic<uint> _initial_young_worker_cap;
   static ZIntensitySmoother _gc_intensities;
+  static ZBooleanStability _machine_memory_info_valid;
 
   static ZCpuPressureMetrics cpu_pressure_metrics(ZGenerationId generation);
 

test/hotspot/gtest/gc/z/test_zAdaptiveHeap.cpp

@@ -180,3 +180,18 @@ TEST_F(ZAdaptiveHeapTest, test_mem_pressure) {
     }
   }
 }
+
+TEST(ZAdaptiveHeap, test_boolean_stability) {
+  // The stability state should latch onto the first observation it sees, and
+  // then comapre any following observation against the first observation.
+
+  ZBooleanStability stability_false;
+  EXPECT_TRUE(stability_false.record_and_check_stability(false));
+  EXPECT_TRUE(stability_false.record_and_check_stability(false));
+  EXPECT_FALSE(stability_false.record_and_check_stability(true));
+
+  ZBooleanStability stability_true;
+  EXPECT_TRUE(stability_true.record_and_check_stability(true));
+  EXPECT_TRUE(stability_true.record_and_check_stability(true));
+  EXPECT_FALSE(stability_true.record_and_check_stability(false));
+}