jdk8-mips64-public/hotspot: comparison src/share/vm/services/lowMemoryDetector.hpp

--1:000000000000
+:f90c822e73f8
+/*
+* Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
+* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+*
+* This code is free software; you can redistribute it and/or modify it
+* under the terms of the GNU General Public License version 2 only, as
+* published by the Free Software Foundation.
+*
+* This code is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+* version 2 for more details (a copy is included in the LICENSE file that
+* accompanied this code).
+*
+* You should have received a copy of the GNU General Public License version
+* 2 along with this work; if not, write to the Free Software Foundation,
+* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+*
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+* or visit www.oracle.com if you need additional information or have any
+* questions.
+*
+*/
+#ifndef SHARE_VM_SERVICES_LOWMEMORYDETECTOR_HPP
+#define SHARE_VM_SERVICES_LOWMEMORYDETECTOR_HPP
+#include "memory/allocation.hpp"
+#include "services/memoryPool.hpp"
+#include "services/memoryService.hpp"
+// Low Memory Detection Support
+// Two memory alarms in the JDK (we called them sensors).
+//   - Heap memory sensor
+//   - Non-heap memory sensor
+// When the VM detects if the memory usage of a memory pool has reached
+// or exceeded its threshold, it will trigger the sensor for the type
+// of the memory pool (heap or nonheap or both).
+//
+// If threshold == -1, no low memory detection is supported and
+// the threshold value is not allowed to be changed.
+// If threshold == 0, no low memory detection is performed for
+// that memory pool.  The threshold can be set to any non-negative
+// value.
+//
+// The default threshold of the Hotspot memory pools are:
+//   Eden space        -1
+//   Survivor space 1  -1
+//   Survivor space 2  -1
+//   Old generation    0
+//   Perm generation   0
+//   CodeCache         0
+//
+// For heap memory, detection will be performed when GC finishes
+// and also in the slow path allocation.
+// For Code cache, detection will be performed in the allocation
+// and deallocation.
+//
+// May need to deal with hysteresis effect.
+//
+// Memory detection code runs in the Service thread (serviceThread.hpp).
+class OopClosure;
+class MemoryPool;
+class ThresholdSupport : public CHeapObj<mtInternal> {
+private:
+bool            _support_high_threshold;
+bool            _support_low_threshold;
+size_t          _high_threshold;
+size_t          _low_threshold;
+public:
+ThresholdSupport(bool support_high, bool support_low) {
+_support_high_threshold = support_high;
+_support_low_threshold = support_low;
+_high_threshold = 0;
+_low_threshold= 0;
+}
+size_t      high_threshold() const        { return _high_threshold; }
+size_t      low_threshold()  const        { return _low_threshold; }
+bool        is_high_threshold_supported() { return _support_high_threshold; }
+bool        is_low_threshold_supported()  { return _support_low_threshold; }
+bool        is_high_threshold_crossed(MemoryUsage usage) {
+if (_support_high_threshold && _high_threshold > 0) {
+return (usage.used() >= _high_threshold);
+}
+return false;
+}
+bool        is_low_threshold_crossed(MemoryUsage usage) {
+if (_support_low_threshold && _low_threshold > 0) {
+return (usage.used() < _low_threshold);
+}
+return false;
+}
+size_t      set_high_threshold(size_t new_threshold) {
+assert(_support_high_threshold, "can only be set if supported");
+assert(new_threshold >= _low_threshold, "new_threshold must be >= _low_threshold");
+size_t prev = _high_threshold;
+_high_threshold = new_threshold;
+return prev;
+}
+size_t      set_low_threshold(size_t new_threshold) {
+assert(_support_low_threshold, "can only be set if supported");
+assert(new_threshold <= _high_threshold, "new_threshold must be <= _high_threshold");
+size_t prev = _low_threshold;
+_low_threshold = new_threshold;
+return prev;
+}
+};
+class SensorInfo : public CHeapObj<mtInternal> {
+private:
+instanceOop     _sensor_obj;
+bool            _sensor_on;
+size_t          _sensor_count;
+// before the actual sensor on flag and sensor count are set
+// we maintain the number of pending triggers and clears.
+// _pending_trigger_count means the number of pending triggers
+// and the sensor count should be incremented by the same number.
+int             _pending_trigger_count;
+// _pending_clear_count takes precedence if it's > 0 which
+// indicates the resulting sensor will be off
+// Sensor trigger requests will reset this clear count to
+// indicate the resulting flag should be on.
+int             _pending_clear_count;
+MemoryUsage     _usage;
+void clear(int count, TRAPS);
+void trigger(int count, TRAPS);
+public:
+SensorInfo();
+void set_sensor(instanceOop sensor) {
+assert(_sensor_obj == NULL, "Should be set only once");
+_sensor_obj = sensor;
+}
+bool has_pending_requests() {
+return (_pending_trigger_count > 0 || _pending_clear_count > 0);
+}
+int pending_trigger_count()      { return _pending_trigger_count; }
+int pending_clear_count()        { return _pending_clear_count; }
+// When this method is used, the memory usage is monitored
+// as a gauge attribute.  High and low thresholds are designed
+// to provide a hysteresis mechanism to avoid repeated triggering
+// of notifications when the attribute value makes small oscillations
+// around the high or low threshold value.
+//
+// The sensor will be triggered if:
+//  (1) the usage is crossing above the high threshold and
+//      the sensor is currently off and no pending
+//      trigger requests; or
+//  (2) the usage is crossing above the high threshold and
+//      the sensor will be off (i.e. sensor is currently on
+//      and has pending clear requests).
+//
+// Subsequent crossings of the high threshold value do not cause
+// any triggers unless the usage becomes less than the low threshold.
+//
+// The sensor will be cleared if:
+//  (1) the usage is crossing below the low threshold and
+//      the sensor is currently on and no pending
+//      clear requests; or
+//  (2) the usage is crossing below the low threshold and
+//      the sensor will be on (i.e. sensor is currently off
+//      and has pending trigger requests).
+//
+// Subsequent crossings of the low threshold value do not cause
+// any clears unless the usage becomes greater than or equal
+// to the high threshold.
+//
+// If the current level is between high and low threhsold, no change.
+//
+void set_gauge_sensor_level(MemoryUsage usage, ThresholdSupport* high_low_threshold);
+// When this method is used, the memory usage is monitored as a
+// simple counter attribute.  The sensor will be triggered
+// whenever the usage is crossing the threshold to keep track
+// of the number of times the VM detects such a condition occurs.
+//
+// The sensor will be triggered if:
+//   - the usage is crossing above the high threshold regardless
+//     of the current sensor state.
+//
+// The sensor will be cleared if:
+//  (1) the usage is crossing below the low threshold and
+//      the sensor is currently on; or
+//  (2) the usage is crossing below the low threshold and
+//      the sensor will be on (i.e. sensor is currently off
+//      and has pending trigger requests).
+//
+void set_counter_sensor_level(MemoryUsage usage, ThresholdSupport* counter_threshold);
+void process_pending_requests(TRAPS);
+void oops_do(OopClosure* f);
+#ifndef PRODUCT
+// printing on default output stream;
+void print();
+#endif // PRODUCT
+};
+class LowMemoryDetector : public AllStatic {
+friend class LowMemoryDetectorDisabler;
+friend class ServiceThread;
+private:
+// true if any collected heap has low memory detection enabled
+static volatile bool _enabled_for_collected_pools;
+// > 0 if temporary disabed
+static volatile jint _disabled_count;
+static void check_memory_usage();
+static bool has_pending_requests();
+static bool temporary_disabled() { return _disabled_count > 0; }
+static void disable() { Atomic::inc(&_disabled_count); }
+static void enable() { Atomic::dec(&_disabled_count); }
+static void process_sensor_changes(TRAPS);
+public:
+static void detect_low_memory();
+static void detect_low_memory(MemoryPool* pool);
+static void detect_after_gc_memory(MemoryPool* pool);
+static bool is_enabled(MemoryPool* pool) {
+// low memory detection is enabled for collected memory pools
+// iff one of the collected memory pool has a sensor and the
+// threshold set non-zero
+if (pool->usage_sensor() == NULL) {
+return false;
+} else {
+ThresholdSupport* threshold_support = pool->usage_threshold();
+return (threshold_support->is_high_threshold_supported() ?
+(threshold_support->high_threshold() > 0) : false);
+}
+}
+// indicates if low memory detection is enabled for any collected
+// memory pools
+static inline bool is_enabled_for_collected_pools() {
+return !temporary_disabled() && _enabled_for_collected_pools;
+}
+// recompute enabled flag
+static void recompute_enabled_for_collected_pools();
+// low memory detection for collected memory pools.
+static inline void detect_low_memory_for_collected_pools() {
+// no-op if low memory detection not enabled
+if (!is_enabled_for_collected_pools()) {
+return;
+}
+int num_memory_pools = MemoryService::num_memory_pools();
+for (int i=0; i<num_memory_pools; i++) {
+MemoryPool* pool = MemoryService::get_memory_pool(i);
+// if low memory detection is enabled then check if the
+// current used exceeds the high threshold
+if (pool->is_collected_pool() && is_enabled(pool)) {
+size_t used = pool->used_in_bytes();
+size_t high = pool->usage_threshold()->high_threshold();
+if (used > high) {
+detect_low_memory(pool);
+}
+}
+}
+}
+};
+class LowMemoryDetectorDisabler: public StackObj {
+public:
+LowMemoryDetectorDisabler()
+{
+LowMemoryDetector::disable();
+}
+~LowMemoryDetectorDisabler()
+{
+assert(LowMemoryDetector::temporary_disabled(), "should be disabled!");
+LowMemoryDetector::enable();
+}
+};
+#endif // SHARE_VM_SERVICES_LOWMEMORYDETECTOR_HPP

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/services/lowMemoryDetector.hpp

src/share/vm/services/lowMemoryDetector.hpp