< prev index next >

src/java.base/share/classes/jdk/internal/platform/Metrics.java

Print this page
@  rev 57446 : Review changes
|
o  rev 57445 : 8231111: Cgroups v2: Rework Metrics in java.base so as to recognize unified hierarchy
|  Reviewed-by: bobv
~
o  rev 56863 : 8231111: Cgroups v2: Rework Metrics in java.base so as to recognize unified hierarchy
|  Reviewed-by: bobv
~


  33  * "Isolation Group" or "Container".  When the term "Isolation Group"
  34  * is used in the API description, this refers to either:
  35  *
  36  *<ol>
  37  *<li> All processes, including the current process within a container.
  38  *
  39  *<li> All processes, including the current process running together
  40  *    isolated from other non-isolated processes.
  41  *
  42  *<li> All processes running on a host when that there is no isolation
  43  *     in effect.
  44  *</ol>
  45  *
  46  * @author bobv
  47  * @since 11
  48  */
  49 
  50 public interface Metrics {
  51 
  52     /**

















  53      * Returns an instance of the Metrics class.
  54      *
  55      * @return Metrics object or null if not supported on this platform.
  56      */
  57     public static Metrics systemMetrics() {
  58         try {
  59             // We currently only support cgroupv1
  60             Class<?> c = Class.forName("jdk.internal.platform.cgroupv1.Metrics");
  61             @SuppressWarnings("unchecked")
  62             Method m = c.getMethod("getInstance");
  63             return (Metrics) m.invoke(null);
  64         } catch (ClassNotFoundException e) {
  65             return null;
  66         } catch (ReflectiveOperationException e) {
  67             throw new InternalError(e);
  68         }
  69     }
  70 
  71     /**
  72      * Returns the interface responsible for providing the
  73      * platform metrics.
  74      *
  75      * @implNote
  76      * Metrics are currently only supported Linux.
  77      * The provider for Linux is cgroupsv1.
  78      *
  79      * @return The name of the provider.
  80      *
  81      */
  82     public String getProvider();
  83 
  84 
  85     /*****************************************************************
  86      * CPU Accounting Subsystem
  87      ****************************************************************/
  88 
  89     /**
  90      * Returns the aggregate time, in nanoseconds, consumed by all
  91      * tasks in the Isolation Group.
  92      *
  93      * @return Time in nanoseconds or 0L if metric is not available.
  94      *
  95      */
  96     public long getCpuUsage();
  97 
  98     /**
  99      * Returns the aggregate time, in nanoseconds, consumed by all tasks in
 100      * the Isolation Group, separated by CPU. If the current process
 101      * is running within a container, the reported time will only be
 102      * valid for processes running within the same container.  The values
 103      * are returned in an array, one entry for each physical processor
 104      * on the system.  Time values for processors unavailable to this
 105      * Group are undefined.
 106      *
 107      * @return long array of time values.  The size of the array is equal
 108      *         to the total number of physical processors in the system. If
 109      *         this metric is not available, a zero length array will be
 110      *         returned.
 111      *
 112      */
 113     public long[] getPerCpuUsage();
 114 
 115     /**
 116      * Returns the aggregate user time, in nanoseconds, consumed by all
 117      * tasks in the Isolation Group.
 118      *
 119      * @return User time in nanoseconds or 0L if metric is not available.
 120      *
 121      */
 122     public long getCpuUserUsage();
 123 
 124     /**
 125      * Returns the aggregate system time, in nanoseconds, consumed by
 126      * all tasks in the Isolation Group.
 127      *
 128      * @return System time in nanoseconds or 0L if metric is not available.
 129      *
 130      */
 131     public long getCpuSystemUsage();
 132 
 133     /*****************************************************************
 134      * CPU Scheduling Metrics
 135      ****************************************************************/
 136 
 137     /**
 138      * Returns the length of the scheduling period, in
 139      * microseconds, for processes within the Isolation Group.
 140      *
 141      * @return time in microseconds or 0L if metric is not available.
 142      *
 143      */
 144     public long getCpuPeriod();
 145 
 146     /**
 147      * Returns the total available run-time allowed, in microseconds,
 148      * during each scheduling period for all tasks in the Isolation
 149      * Group.
 150      *
 151      * @return time in microseconds or -1 if the quota is unlimited.
 152      *
 153      */
 154     public long getCpuQuota();
 155 
 156 
 157     /**
 158      * Returns the relative weighting of processes with the Isolation
 159      * Group used for prioritizing the scheduling of processes across
 160      * all Isolation Groups running on a host.
 161      *
 162      * @implNote
 163      * Popular container orchestration systems have standardized shares
 164      * to be multiples of 1024, where 1024 is interpreted as 1 CPU share
 165      * of execution.  Users can distribute CPU resources to multiple
 166      * Isolation Groups by specifying the CPU share weighting needed by
 167      * each process.  To request 2 CPUS worth of execution time, CPU shares
 168      * would be set to 2048.
 169      *
 170      * @return shares value or -1 if no share set.
 171      *
 172      */
 173     public long getCpuShares();
 174 
 175     /**
 176      * Returns the number of time-slice periods that have elapsed if
 177      * a CPU quota has been setup for the Isolation Group; otherwise
 178      * returns 0.
 179      *
 180      * @return count of elapsed periods or 0 if the quota is unlimited.
 181      *
 182      */
 183     public long getCpuNumPeriods();
 184 
 185     /**
 186      * Returns the number of time-slice periods that the group has
 187      * been throttled or limited due to the group exceeding its quota
 188      * if a CPU quota has been setup for the Isolation Group.
 189      *
 190      * @return count of throttled periods or 0 if the quota is unlimited.
 191      *
 192      */
 193     public long getCpuNumThrottled();
 194 
 195     /**
 196      * Returns the total time duration, in nanoseconds, that the
 197      * group has been throttled or limited due to the group exceeding
 198      * its quota if a CPU quota has been setup for the Isolation Group.
 199      *
 200      * @return Throttled time in nanoseconds or 0 if the quota is unlimited.
 201      *
 202      */
 203     public long getCpuThrottledTime();
 204 
 205 
 206     /**
 207      * Returns the number of effective processors that this Isolation
 208      * group has available to it.  This effective processor count is
 209      * computed based on the number of dedicated CPUs, CPU shares and
 210      * CPU quotas in effect for this isolation group.
 211      *
 212      * This method returns the same value as
 213      * {@link java.lang.Runtime#availableProcessors()}.
 214      *
 215      * @return The number of effective CPUs.
 216      *
 217      */
 218     public long getEffectiveCpuCount();
 219 
 220     /*****************************************************************
 221      * CPU Sets
 222      ****************************************************************/
 223 
 224     /**
 225      * Returns the CPUS that are available for execution of processes
 226      * in the current Isolation Group. The size of the array is equal
 227      * to the total number of CPUs and the elements in the array are the
 228      * physical CPU numbers that are available.  Some of the CPUs returned
 229      * may be offline.  To get the current online CPUs, use
 230      * {@link getEffectiveCpuSetCpus()}.
 231      *
 232      * @return An array of available CPUs or a zero length array
 233      *         if the metric is not available.
 234      *
 235      */
 236     public int[] getCpuSetCpus();
 237 
 238     /**
 239      * Returns the CPUS that are available and online for execution of
 240      * processes within the current Isolation Group. The size of the
 241      * array is equal to the total number of CPUs and the elements in
 242      * the array are the physical CPU numbers.
 243      *
 244      * @return An array of available and online CPUs or a zero length
 245      *         array if the metric is not available.
 246      *
 247      */
 248     public int[] getEffectiveCpuSetCpus();
 249 
 250     /**
 251      * Returns the memory nodes that are available for use by processes
 252      * in the current Isolation Group. The size of the array is equal
 253      * to the total number of nodes and the elements in the array are the
 254      * physical node numbers that are available.  Some of the nodes returned
 255      * may be offline.  To get the current online memory nodes, use
 256      * {@link getEffectiveCpuSetMems()}.
 257      *
 258      * @return An array of available memory nodes or a zero length array
 259      *         if the metric is not available.
 260      *
 261      */
 262     public int[] getCpuSetMems();
 263 
 264     /**
 265      * Returns the memory nodes that are available and online for use by
 266      * processes within the current Isolation Group. The size of the
 267      * array is equal to the total number of nodes and the elements in
 268      * the array are the physical node numbers.
 269      *
 270      * @return An array of available and online nodes or a zero length
 271      *         array if the metric is not available.
 272      *
 273      */
 274     public int[] getEffectiveCpuSetMems();
 275 
 276     /**
 277      * Returns the (attempts per second * 1000), if enabled, that the
 278      * operating system tries to satisfy a memory request for any
 279      * process in the current Isolation Group when no free memory is
 280      * readily available.  Use {@link #isCpuSetMemoryPressureEnabled()} to
 281      * determine if this support is enabled.
 282      *
 283      * @return Memory pressure or 0 if not enabled or metric is not
 284      *         available.
 285      *
 286      */
 287     public double getCpuSetMemoryPressure();
 288 
 289     /**
 290      * Returns the state of the memory pressure detection support.
 291      *
 292      * @return true if the support is available and enabled, otherwise false.

 293      *
 294      */
 295     public boolean isCpuSetMemoryPressureEnabled();
 296 
 297     /*****************************************************************
 298      * Memory Subsystem
 299      ****************************************************************/
 300 
 301     /**
 302      * Returns the number of times that user memory requests in the
 303      * Isolation Group have exceeded the memory limit.
 304      *
 305      * @return The number of exceeded requests or 0 if none or metric
 306      *         is not available.
 307      *
 308      */
 309     public long getMemoryFailCount();
 310 
 311     /**
 312      * Returns the maximum amount of physical memory, in bytes, that
 313      * can be allocated in the Isolation Group.
 314      *
 315      * @return The maximum amount of memory in bytes or -1 if either
 316      *         there is no limit set or this metric is not available.
 317      *
 318      */
 319     public long getMemoryLimit();
 320 
 321     /**
 322      * Returns the largest amount of physical memory, in bytes, that
 323      * have been allocated in the Isolation Group.
 324      *
 325      * @return The largest amount of memory in bytes or 0 if this
 326      *         metric is not available.
 327      *
 328      */
 329     public long getMemoryMaxUsage();
 330 
 331     /**
 332      * Returns the amount of physical memory, in bytes, that is currently
 333      * allocated in the current Isolation Group.
 334      *
 335      * @return The amount of memory in bytes allocated or 0 if this
 336      *         metric is not available.
 337      *
 338      */
 339     public long getMemoryUsage();
 340 
 341     /**
 342      * Returns the number of times that kernel memory requests in the
 343      * Isolation Group have exceeded the kernel memory limit.
 344      *
 345      * @return The number of exceeded requests or 0 if none or metric
 346      *         is not available.
 347      *
 348      */
 349     public long getKernelMemoryFailCount();
 350 
 351     /**
 352      * Returns the maximum amount of kernel physical memory, in bytes, that
 353      * can be allocated in the Isolation Group.
 354      *
 355      * @return The maximum amount of memory in bytes or -1 if either
 356      *         there is no limit set or this metric is not available.
 357      *
 358      */
 359     public long getKernelMemoryLimit();
 360 
 361     /**
 362      * Returns the largest amount of kernel physical memory, in bytes, that
 363      * have been allocated in the Isolation Group.
 364      *
 365      * @return The largest amount of memory in bytes or 0 if this
 366      *         metric is not available.
 367      *
 368      */
 369     public long getKernelMemoryMaxUsage();
 370 
 371     /**
 372      * Returns the amount of kernel physical memory, in bytes, that
 373      * is currently allocated in the current Isolation Group.
 374      *
 375      * @return The amount of memory in bytes allocated or 0 if this
 376      *         metric is not available.
 377      *
 378      */
 379     public long getKernelMemoryUsage();
 380 
 381     /**
 382      * Returns the number of times that networking memory requests in the
 383      * Isolation Group have exceeded the kernel memory limit.
 384      *
 385      * @return The number of exceeded requests or 0 if none or metric
 386      *         is not available.
 387      *
 388      */
 389     public long getTcpMemoryFailCount();
 390 
 391     /**
 392      * Returns the maximum amount of networking physical memory, in bytes,
 393      * that can be allocated in the Isolation Group.
 394      *
 395      * @return The maximum amount of memory in bytes or -1 if either
 396      *         there is no limit set or this metric is not available.
 397      *
 398      */
 399     public long getTcpMemoryLimit();
 400 
 401     /**
 402      * Returns the largest amount of networking physical memory, in bytes,
 403      * that have been allocated in the Isolation Group.
 404      *
 405      * @return The largest amount of memory in bytes or 0 if this
 406      *         metric is not available.
 407      *
 408      */
 409     public long getTcpMemoryMaxUsage();
 410 
 411     /**
 412      * Returns the amount of networking physical memory, in bytes, that
 413      * is currently allocated in the current Isolation Group.
 414      *
 415      * @return The amount of memory in bytes allocated or 0 if this
 416      *         metric is not available.
 417      *
 418      */
 419     public long getTcpMemoryUsage();
 420 
 421     /**
 422      * Returns the number of times that user memory requests in the
 423      * Isolation Group have exceeded the memory + swap limit.
 424      *
 425      * @return The number of exceeded requests or 0 if none or metric
 426      *         is not available.
 427      *
 428      */
 429     public long getMemoryAndSwapFailCount();
 430 
 431     /**
 432      * Returns the maximum amount of physical memory and swap space,
 433      * in bytes, that can be allocated in the Isolation Group.
 434      *
 435      * @return The maximum amount of memory in bytes or -1 if either
 436      *         there is no limit set or this metric is not available.
 437      *
 438      */
 439     public long getMemoryAndSwapLimit();
 440 
 441     /**
 442      * Returns the largest amount of physical memory and swap space,
 443      * in bytes, that have been allocated in the Isolation Group.
 444      *
 445      * @return The largest amount of memory in bytes or 0 if this
 446      *         metric is not available.
 447      *
 448      */
 449     public long getMemoryAndSwapMaxUsage();
 450 
 451     /**
 452      * Returns the amount of physical memory and swap space, in bytes,
 453      * that is currently allocated in the current Isolation Group.
 454      *
 455      * @return The amount of memory in bytes allocated or 0 if this
 456      *         metric is not available.
 457      *
 458      */
 459     public long getMemoryAndSwapUsage();
 460 
 461     /**
 462      * Returns the state of the Operating System Out of Memory termination
 463      * policy.
 464      *
 465      * @return Returns true if operating system will terminate processes
 466      *         in the Isolation Group that exceed the amount of available
 467      *         memory, otherwise false.  Flase will be returned if this
 468      *         capability is not available on the current operating system.
 469      *
 470      */
 471     public boolean isMemoryOOMKillEnabled();
 472 
 473     /**
 474      * Returns the hint to the operating system that allows groups
 475      * to specify the minimum amount of physical memory that they need to
 476      * achieve reasonable performance in low memory systems.  This allows
 477      * host systems to provide greater sharing of memory.
 478      *
 479      * @return The minimum amount of physical memory, in bytes, that the
 480      *         operating system will try to maintain under low memory
 481      *         conditions.  If this metric is not available, 0 will be
 482      *         returned.
 483      *
 484      */
 485     public long getMemorySoftLimit();
 486 
 487     /*****************************************************************
 488      * BlKIO Subsystem
 489      ****************************************************************/
 490 
 491     /**
 492      * Returns the number of block I/O requests to the disk that have been
 493      * issued by the Isolation Group.
 494      *
 495      * @return The count of requests or 0 if this metric is not available.
 496      *
 497      */
 498     public long getBlkIOServiceCount();
 499 
 500     /**
 501      * Returns the number of block I/O bytes that have been transferred
 502      * to/from the disk by the Isolation Group.
 503      *
 504      * @return The number of bytes transferred or 0 if this metric is not available.
 505      *
 506      */
 507     public long getBlkIOServiced();
 508 }


  33  * "Isolation Group" or "Container".  When the term "Isolation Group"
  34  * is used in the API description, this refers to either:
  35  *
  36  *<ol>
  37  *<li> All processes, including the current process within a container.
  38  *
  39  *<li> All processes, including the current process running together
  40  *    isolated from other non-isolated processes.
  41  *
  42  *<li> All processes running on a host when that there is no isolation
  43  *     in effect.
  44  *</ol>
  45  *
  46  * @author bobv
  47  * @since 11
  48  */
  49 
  50 public interface Metrics {
  51 
  52     /**
  53      * Returned for metrics of type long if the underlying implementation
  54      * has determined that no limit is being imposed.
  55      */
  56     public static final long LONG_RETVAL_UNLIMITED = -1;
  57     /**
  58      * Returned for metrics of type long if the underlying implementation
  59      * doesn't support that metric.
  60      */
  61     public static final long LONG_RETVAL_NOT_SUPPORTED = -2;
  62     public static final double DOUBLE_RETVAL_NOT_SUPPORTED = LONG_RETVAL_NOT_SUPPORTED;
  63     /**
  64      * Returned for metrics of type Boolean if the underlying implementation
  65      * doesn't support that metric.
  66      */
  67     public static final Boolean BOOL_RETVAL_NOT_SUPPORTED = null;
  68 
  69     /**
  70      * Returns an instance of the Metrics class.
  71      *
  72      * @return Metrics object or null if not supported on this platform.
  73      */
  74     public static Metrics systemMetrics() {
  75         try {
  76             Class<?> c = Class.forName("jdk.internal.platform.CgroupMetrics");


  77             Method m = c.getMethod("getInstance");
  78             return (Metrics) m.invoke(null);
  79         } catch (ClassNotFoundException e) {
  80             return null;
  81         } catch (ReflectiveOperationException e) {
  82             throw new InternalError(e);
  83         }
  84     }
  85 
  86     /**
  87      * Returns the interface responsible for providing the
  88      * platform metrics.
  89      *
  90      * @implNote
  91      * Metrics are currently only supported Linux.
  92      * The provider for Linux is cgroups (version 1 or 2).
  93      *
  94      * @return The name of the provider.
  95      *
  96      */
  97     public String getProvider();
  98 
  99 
 100     /*****************************************************************
 101      * CPU Accounting Subsystem
 102      ****************************************************************/
 103 
 104     /**
 105      * Returns the aggregate time, in nanoseconds, consumed by all
 106      * tasks in the Isolation Group.
 107      *
 108      * @return Time in nanoseconds or -2 if metric is not available.
 109      *
 110      */
 111     public long getCpuUsage();
 112 
 113     /**
 114      * Returns the aggregate time, in nanoseconds, consumed by all tasks in
 115      * the Isolation Group, separated by CPU. If the current process
 116      * is running within a container, the reported time will only be
 117      * valid for processes running within the same container.  The values
 118      * are returned in an array, one entry for each physical processor
 119      * on the system.  Time values for processors unavailable to this
 120      * Group are undefined.
 121      *
 122      * @return long array of time values.  The size of the array is equal
 123      *         to the total number of physical processors in the system. If
 124      *         this metric is not available, null will be
 125      *         returned.
 126      *
 127      */
 128     public long[] getPerCpuUsage();
 129 
 130     /**
 131      * Returns the aggregate user time, in nanoseconds, consumed by all
 132      * tasks in the Isolation Group.
 133      *
 134      * @return User time in nanoseconds or -2 if metric is not available.
 135      *
 136      */
 137     public long getCpuUserUsage();
 138 
 139     /**
 140      * Returns the aggregate system time, in nanoseconds, consumed by
 141      * all tasks in the Isolation Group.
 142      *
 143      * @return System time in nanoseconds or -2 if metric is not available.
 144      *
 145      */
 146     public long getCpuSystemUsage();
 147 
 148     /*****************************************************************
 149      * CPU Scheduling Metrics
 150      ****************************************************************/
 151 
 152     /**
 153      * Returns the length of the scheduling period, in
 154      * microseconds, for processes within the Isolation Group.
 155      *
 156      * @return time in microseconds or -2 if metric is not available.
 157      *
 158      */
 159     public long getCpuPeriod();
 160 
 161     /**
 162      * Returns the total available run-time allowed, in microseconds,
 163      * during each scheduling period for all tasks in the Isolation
 164      * Group.
 165      *
 166      * @return time in microseconds or -2 if the quota is unlimited.
 167      *
 168      */
 169     public long getCpuQuota();
 170 
 171 
 172     /**
 173      * Returns the relative weighting of processes with the Isolation
 174      * Group used for prioritizing the scheduling of processes across
 175      * all Isolation Groups running on a host.
 176      *
 177      * @implNote
 178      * Popular container orchestration systems have standardized shares
 179      * to be multiples of 1024, where 1024 is interpreted as 1 CPU share
 180      * of execution.  Users can distribute CPU resources to multiple
 181      * Isolation Groups by specifying the CPU share weighting needed by
 182      * each process.  To request 2 CPUS worth of execution time, CPU shares
 183      * would be set to 2048.
 184      *
 185      * @return shares value or -2 if no share set.
 186      *
 187      */
 188     public long getCpuShares();
 189 
 190     /**
 191      * Returns the number of time-slice periods that have elapsed if
 192      * a CPU quota has been setup for the Isolation Group; otherwise
 193      * returns 0.
 194      *
 195      * @return count of elapsed periods or -2 if the quota is unlimited.
 196      *
 197      */
 198     public long getCpuNumPeriods();
 199 
 200     /**
 201      * Returns the number of time-slice periods that the group has
 202      * been throttled or limited due to the group exceeding its quota
 203      * if a CPU quota has been setup for the Isolation Group.
 204      *
 205      * @return count of throttled periods or -2 if the quota is unlimited.
 206      *
 207      */
 208     public long getCpuNumThrottled();
 209 
 210     /**
 211      * Returns the total time duration, in nanoseconds, that the
 212      * group has been throttled or limited due to the group exceeding
 213      * its quota if a CPU quota has been setup for the Isolation Group.
 214      *
 215      * @return Throttled time in nanoseconds or -2 if the quota is unlimited.
 216      *
 217      */
 218     public long getCpuThrottledTime();
 219 
 220 
 221     /**
 222      * Returns the number of effective processors that this Isolation
 223      * group has available to it.  This effective processor count is
 224      * computed based on the number of dedicated CPUs, CPU shares and
 225      * CPU quotas in effect for this isolation group.
 226      *
 227      * This method returns the same value as
 228      * {@link java.lang.Runtime#availableProcessors()}.
 229      *
 230      * @return The number of effective CPUs.
 231      *
 232      */
 233     public long getEffectiveCpuCount();
 234 
 235     /*****************************************************************
 236      * CPU Sets
 237      ****************************************************************/
 238 
 239     /**
 240      * Returns the CPUS that are available for execution of processes
 241      * in the current Isolation Group. The size of the array is equal
 242      * to the total number of CPUs and the elements in the array are the
 243      * physical CPU numbers that are available.  Some of the CPUs returned
 244      * may be offline.  To get the current online CPUs, use
 245      * {@link getEffectiveCpuSetCpus()}.
 246      *
 247      * @return An array of available CPUs or null
 248      *         if the metric is not available.
 249      *
 250      */
 251     public int[] getCpuSetCpus();
 252 
 253     /**
 254      * Returns the CPUS that are available and online for execution of
 255      * processes within the current Isolation Group. The size of the
 256      * array is equal to the total number of CPUs and the elements in
 257      * the array are the physical CPU numbers.
 258      *
 259      * @return An array of available and online CPUs or null
 260      *         if the metric is not available.
 261      *
 262      */
 263     public int[] getEffectiveCpuSetCpus();
 264 
 265     /**
 266      * Returns the memory nodes that are available for use by processes
 267      * in the current Isolation Group. The size of the array is equal
 268      * to the total number of nodes and the elements in the array are the
 269      * physical node numbers that are available.  Some of the nodes returned
 270      * may be offline.  To get the current online memory nodes, use
 271      * {@link getEffectiveCpuSetMems()}.
 272      *
 273      * @return An array of available memory nodes or null
 274      *         if the metric is not available.
 275      *
 276      */
 277     public int[] getCpuSetMems();
 278 
 279     /**
 280      * Returns the memory nodes that are available and online for use by
 281      * processes within the current Isolation Group. The size of the
 282      * array is equal to the total number of nodes and the elements in
 283      * the array are the physical node numbers.
 284      *
 285      * @return An array of available and online nodes or null
 286      *         if the metric is not available.
 287      *
 288      */
 289     public int[] getEffectiveCpuSetMems();
 290 
 291     /**
 292      * Returns the (attempts per second * 1000), if enabled, that the
 293      * operating system tries to satisfy a memory request for any
 294      * process in the current Isolation Group when no free memory is
 295      * readily available.  Use {@link #isCpuSetMemoryPressureEnabled()} to
 296      * determine if this support is enabled.
 297      *
 298      * @return Memory pressure or 0 if not enabled or -2 if metric is not
 299      *         available.
 300      *
 301      */
 302     public double getCpuSetMemoryPressure();
 303 
 304     /**
 305      * Returns the state of the memory pressure detection support.
 306      *
 307      * @return true if support is available and enabled. null if metric is
 308      *         not available. false otherwise.
 309      *
 310      */
 311     public Boolean isCpuSetMemoryPressureEnabled();
 312 
 313     /*****************************************************************
 314      * Memory Subsystem
 315      ****************************************************************/
 316 
 317     /**
 318      * Returns the number of times that user memory requests in the
 319      * Isolation Group have exceeded the memory limit.
 320      *
 321      * @return The number of exceeded requests or -2 if metric
 322      *         is not available.
 323      *
 324      */
 325     public long getMemoryFailCount();
 326 
 327     /**
 328      * Returns the maximum amount of physical memory, in bytes, that
 329      * can be allocated in the Isolation Group.
 330      *
 331      * @return The maximum amount of memory in bytes or -1 if
 332      *         there is no limit or -2 if this metric is not available.
 333      *
 334      */
 335     public long getMemoryLimit();
 336 
 337     /**
 338      * Returns the largest amount of physical memory, in bytes, that
 339      * have been allocated in the Isolation Group.
 340      *
 341      * @return The largest amount of memory in bytes or -2 if this
 342      *         metric is not available.
 343      *
 344      */
 345     public long getMemoryMaxUsage();
 346 
 347     /**
 348      * Returns the amount of physical memory, in bytes, that is currently
 349      * allocated in the current Isolation Group.
 350      *
 351      * @return The amount of memory in bytes allocated or -2 if this
 352      *         metric is not available.
 353      *
 354      */
 355     public long getMemoryUsage();
 356 
 357     /**
 358      * Returns the number of times that kernel memory requests in the
 359      * Isolation Group have exceeded the kernel memory limit.
 360      *
 361      * @return The number of exceeded requests or -2 if metric
 362      *         is not available.
 363      *
 364      */
 365     public long getKernelMemoryFailCount();
 366 
 367     /**
 368      * Returns the maximum amount of kernel physical memory, in bytes, that
 369      * can be allocated in the Isolation Group.
 370      *
 371      * @return The maximum amount of memory in bytes or -1 if
 372      *         there is no limit set or -2 if this metric is not available.
 373      *
 374      */
 375     public long getKernelMemoryLimit();
 376 
 377     /**
 378      * Returns the largest amount of kernel physical memory, in bytes, that
 379      * have been allocated in the Isolation Group.
 380      *
 381      * @return The largest amount of memory in bytes or -2 if this
 382      *         metric is not available.
 383      *
 384      */
 385     public long getKernelMemoryMaxUsage();
 386 
 387     /**
 388      * Returns the amount of kernel physical memory, in bytes, that
 389      * is currently allocated in the current Isolation Group.
 390      *
 391      * @return The amount of memory in bytes allocated or -2 if this
 392      *         metric is not available.
 393      *
 394      */
 395     public long getKernelMemoryUsage();
 396 
 397     /**
 398      * Returns the number of times that networking memory requests in the
 399      * Isolation Group have exceeded the kernel memory limit.
 400      *
 401      * @return The number of exceeded requests or -2 if the metric
 402      *         is not available.
 403      *
 404      */
 405     public long getTcpMemoryFailCount();
 406 
 407     /**
 408      * Returns the maximum amount of networking physical memory, in bytes,
 409      * that can be allocated in the Isolation Group.
 410      *
 411      * @return The maximum amount of memory in bytes or -1 if
 412      *         there is no limit or -2 if this metric is not available.
 413      *
 414      */
 415     public long getTcpMemoryLimit();
 416 
 417     /**
 418      * Returns the largest amount of networking physical memory, in bytes,
 419      * that have been allocated in the Isolation Group.
 420      *
 421      * @return The largest amount of memory in bytes or -2 if this
 422      *         metric is not available.
 423      *
 424      */
 425     public long getTcpMemoryMaxUsage();
 426 
 427     /**
 428      * Returns the amount of networking physical memory, in bytes, that
 429      * is currently allocated in the current Isolation Group.
 430      *
 431      * @return The amount of memory in bytes allocated or -2 if this
 432      *         metric is not available.
 433      *
 434      */
 435     public long getTcpMemoryUsage();
 436 
 437     /**
 438      * Returns the number of times that user memory requests in the
 439      * Isolation Group have exceeded the memory + swap limit.
 440      *
 441      * @return The number of exceeded requests or -2 if the metric
 442      *         is not available.
 443      *
 444      */
 445     public long getMemoryAndSwapFailCount();
 446 
 447     /**
 448      * Returns the maximum amount of physical memory and swap space,
 449      * in bytes, that can be allocated in the Isolation Group.
 450      *
 451      * @return The maximum amount of memory in bytes or -1 if
 452      *         there is no limit set or -2 if this metric is not available.
 453      *
 454      */
 455     public long getMemoryAndSwapLimit();
 456 
 457     /**
 458      * Returns the largest amount of physical memory and swap space,
 459      * in bytes, that have been allocated in the Isolation Group.
 460      *
 461      * @return The largest amount of memory in bytes or -2 if this
 462      *         metric is not available.
 463      *
 464      */
 465     public long getMemoryAndSwapMaxUsage();
 466 
 467     /**
 468      * Returns the amount of physical memory and swap space, in bytes,
 469      * that is currently allocated in the current Isolation Group.
 470      *
 471      * @return The amount of memory in bytes allocated or -2 if this
 472      *         metric is not available.
 473      *
 474      */
 475     public long getMemoryAndSwapUsage();
 476 
 477     /**
 478      * Returns the state of the Operating System Out of Memory termination
 479      * policy.
 480      *
 481      * @return Returns true if operating system will terminate processes
 482      *         in the Isolation Group that exceed the amount of available
 483      *         memory, otherwise false. null will be returned if this
 484      *         capability is not available on the current operating system.
 485      *
 486      */
 487     public Boolean isMemoryOOMKillEnabled();
 488 
 489     /**
 490      * Returns the hint to the operating system that allows groups
 491      * to specify the minimum amount of physical memory that they need to
 492      * achieve reasonable performance in low memory systems.  This allows
 493      * host systems to provide greater sharing of memory.
 494      *
 495      * @return The minimum amount of physical memory, in bytes, that the
 496      *         operating system will try to maintain under low memory
 497      *         conditions.  If this metric is not available, -2 will be
 498      *         returned.
 499      *
 500      */
 501     public long getMemorySoftLimit();
 502 
 503     /*****************************************************************
 504      * BlKIO Subsystem
 505      ****************************************************************/
 506 
 507     /**
 508      * Returns the number of block I/O requests to the disk that have been
 509      * issued by the Isolation Group.
 510      *
 511      * @return The count of requests or -2 if this metric is not available.
 512      *
 513      */
 514     public long getBlkIOServiceCount();
 515 
 516     /**
 517      * Returns the number of block I/O bytes that have been transferred
 518      * to/from the disk by the Isolation Group.
 519      *
 520      * @return The number of bytes transferred or -2 if this metric is not available.
 521      *
 522      */
 523     public long getBlkIOServiced();
 524 }
< prev index next >