test/lib/jdk/test/lib/containers/cgroup/MetricsTesterCgroupV2.java

@  rev 57734 : Review feedback
|
o  rev 57733 : 8231111: Cgroups v2: Rework Metrics in java.base so as to recognize unified hierarchy
|  Reviewed-by: bobv, mchung
~
o  rev 56862 : 8231111: Cgroups v2: Rework Metrics in java.base so as to recognize unified hierarchy
|  Reviewed-by: bobv
~

*** 32,48 ****
  import java.util.Arrays;
  import java.util.List;
  import java.util.concurrent.TimeUnit;
  import java.util.stream.Collectors;
  
  import jdk.internal.platform.Metrics;
- import jdk.test.lib.Asserts;
  
  public class MetricsTesterCgroupV2 implements CgroupMetricsTester {
  
      private static final long UNLIMITED = -1;
-     private static final long NOT_SUPPORTED = -2;
      private static final UnifiedController UNIFIED = new UnifiedController();
      private static final String MAX = "max";
      private static final int PER_CPU_SHARES = 1024;
  
      private final long startSysVal;
--- 32,47 ----
  import java.util.Arrays;
  import java.util.List;
  import java.util.concurrent.TimeUnit;
  import java.util.stream.Collectors;
  
+ import jdk.internal.platform.CgroupSubsystem;
  import jdk.internal.platform.Metrics;
  
  public class MetricsTesterCgroupV2 implements CgroupMetricsTester {
  
      private static final long UNLIMITED = -1;
      private static final UnifiedController UNIFIED = new UnifiedController();
      private static final String MAX = "max";
      private static final int PER_CPU_SHARES = 1024;
  
      private final long startSysVal;
*** 151,175 ****
  
      private void warn(String metric, long oldVal, long newVal) {
          CgroupMetricsTester.warn(UnifiedController.NAME, metric, oldVal, newVal);
      }
  
-     private void verifyNotSupported(long metricVal) {
-         Asserts.assertEquals(metricVal, NOT_SUPPORTED, "Expected metric to be not supported!");
-     }
- 
-     private void verifyNotSupported(double metricVal) {
-         if (!CgroupMetricsTester.compareWithErrorMargin(NOT_SUPPORTED, metricVal)) {
-             throw new RuntimeException("Metric not supported, got: " + metricVal +
-                                        " expected: " + NOT_SUPPORTED);
-         }
-     }
- 
-     private void verifyPerCpuNotSupported(long[] perCpuUsage) {
-         Asserts.assertNull(perCpuUsage, "perCpuUsage expected to be not supported");
-     }
- 
      private long getCpuShares(String file) {
          long rawVal = getLongValueFromFile(file);
          if (rawVal == 0 || rawVal == 100) {
              return UNLIMITED;
          }
--- 150,159 ----
*** 241,273 ****
          oldVal = metrics.getMemoryUsage();
          newVal = getLongValueFromFile("memory.current");
          if (!CgroupMetricsTester.compareWithErrorMargin(oldVal, newVal)) {
              fail("memory.current", oldVal, newVal);
          }
-         verifyNotSupported(metrics.getMemoryMaxUsage());
- 
-         // Kernel memory
-         verifyNotSupported(metrics.getKernelMemoryFailCount());
-         verifyNotSupported(metrics.getKernelMemoryLimit());
-         verifyNotSupported(metrics.getKernelMemoryMaxUsage());
-         verifyNotSupported(metrics.getKernelMemoryUsage());
- 
-         //TCP Memory
-         verifyNotSupported(metrics.getTcpMemoryFailCount());
-         verifyNotSupported(metrics.getTcpMemoryLimit());
-         verifyNotSupported(metrics.getTcpMemoryMaxUsage());
  
          oldVal = metrics.getTcpMemoryUsage();
          newVal = getLongValueEntryFromFile("memory.stat", "sock");
          if (!CgroupMetricsTester.compareWithErrorMargin(oldVal, newVal)) {
              fail("memory.stat[sock]", oldVal, newVal);
          }
  
-         //  Memory and Swap
-         verifyNotSupported(metrics.getMemoryAndSwapFailCount());
-         verifyNotSupported(metrics.getMemoryAndSwapMaxUsage());
- 
          oldVal = metrics.getMemoryAndSwapLimit();
          newVal = getLongLimitValueFromFile("memory.swap.max");
          if (!CgroupMetricsTester.compareWithErrorMargin(oldVal, newVal)) {
              fail("memory.swap.max", oldVal, newVal);
          }
--- 225,241 ----
*** 282,292 ****
          newVal = getLongLimitValueFromFile("memory.high");
          if (!CgroupMetricsTester.compareWithErrorMargin(oldVal, newVal)) {
              fail("memory.high", oldVal, newVal);
          }
  
-         Asserts.assertNull(metrics.isMemoryOOMKillEnabled(), "Not supported");
      }
  
      @Override
      public void testCpuAccounting() {
          Metrics metrics = Metrics.systemMetrics();
--- 250,259 ----
*** 295,306 ****
  
          if (!CgroupMetricsTester.compareWithErrorMargin(oldVal, newVal)) {
              warn("cpu.stat[usage_usec]", oldVal, newVal);
          }
  
-         verifyPerCpuNotSupported(metrics.getPerCpuUsage());
- 
          oldVal = metrics.getCpuUserUsage();
          newVal = TimeUnit.MICROSECONDS.toNanos(getLongValueEntryFromFile("cpu.stat", "user_usec"));
          if (!CgroupMetricsTester.compareWithErrorMargin(oldVal, newVal)) {
              warn("cpu.stat[user_usec]", oldVal, newVal);
          }
--- 262,271 ----
*** 398,410 ****
          Arrays.sort(newVal);
          if (Arrays.compare(oldVal, newVal) != 0) {
              fail("cpuset.mems.effective", Arrays.toString(oldVal),
                                            Arrays.toString(newVal));
          }
- 
-         verifyNotSupported(metrics.getCpuSetMemoryPressure());
-         Asserts.assertNull(metrics.isCpuSetMemoryPressureEnabled(), "Should be not supported");
      }
  
      private int[] mapNullToEmpty(int[] cpus) {
          if (cpus == null) {
              // Not available. For sake of testing continue with an
--- 363,372 ----
*** 420,431 ****
          // make system call
          long newSysVal = metrics.getCpuSystemUsage();
          long newUserVal = metrics.getCpuUserUsage();
          long newUsage = metrics.getCpuUsage();
  
-         verifyPerCpuNotSupported(metrics.getPerCpuUsage());
- 
          // system/user CPU usage counters may be slowly increasing.
          // allow for equal values for a pass
          if (newSysVal < startSysVal) {
              fail("getCpuSystemUsage", newSysVal, startSysVal);
          }
--- 382,391 ----
*** 442,454 ****
      }
  
      @Override
      public void testMemoryUsage() {
          Metrics metrics = Metrics.systemMetrics();
-         long memoryMaxUsage = metrics.getMemoryMaxUsage();
          long memoryUsage = metrics.getMemoryUsage();
!         long newMemoryMaxUsage = 0, newMemoryUsage = 0;
  
          // allocate memory in a loop and check more than once for new values
          // otherwise we might occasionally see the effect of decreasing new memory
          // values. For example because the system could free up memory
          byte[][] bytes = new byte[32][];
--- 402,413 ----
      }
  
      @Override
      public void testMemoryUsage() {
          Metrics metrics = Metrics.systemMetrics();
          long memoryUsage = metrics.getMemoryUsage();
!         long newMemoryUsage = 0;
  
          // allocate memory in a loop and check more than once for new values
          // otherwise we might occasionally see the effect of decreasing new memory
          // values. For example because the system could free up memory
          byte[][] bytes = new byte[32][];
*** 457,472 ****
              newMemoryUsage = metrics.getMemoryUsage();
              if (newMemoryUsage > memoryUsage) {
                  break;
              }
          }
-         newMemoryMaxUsage = metrics.getMemoryMaxUsage();
- 
-         if (newMemoryMaxUsage < memoryMaxUsage) {
-             fail("getMemoryMaxUsage", memoryMaxUsage,
-                                       newMemoryMaxUsage);
-         }
  
          if (newMemoryUsage < memoryUsage) {
              fail("getMemoryUsage", memoryUsage, newMemoryUsage);
          }
      }
--- 416,425 ----
*** 509,517 ****
                              }
                          }
                          return accumulator;
                      }).collect(Collectors.summingLong(e -> e));
          } catch (IOException e) {
!             return Metrics.LONG_RETVAL_NOT_SUPPORTED;
          }
      }
  }
--- 462,470 ----
                              }
                          }
                          return accumulator;
                      }).collect(Collectors.summingLong(e -> e));
          } catch (IOException e) {
!             return CgroupSubsystem.LONG_RETVAL_UNLIMITED;
          }
      }
  }