src/hotspot/share/services/memoryManager.cpp
author phh
Tue, 19 Jun 2018 05:18:49 -0700
changeset 50635 5d3c5af82654
parent 50429 83aec1d357d4
child 52718 263c7685a22a
permissions -rw-r--r--
8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results Summary: Memory pools can now be optional collection participants, e.g., G1 Old Gen in an incremental collection. Reviewed-by: ehelin, mchung
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
49360
886acec3b4c6 8199275: Fix inclusions of allocation.inline.hpp
stefank
parents: 48168
diff changeset
     2
 * Copyright (c) 2003, 2018, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4459
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4459
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4459
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6245
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6245
diff changeset
    26
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6245
diff changeset
    27
#include "classfile/vmSymbols.hpp"
49360
886acec3b4c6 8199275: Fix inclusions of allocation.inline.hpp
stefank
parents: 48168
diff changeset
    28
#include "memory/allocation.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6245
diff changeset
    29
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6245
diff changeset
    30
#include "runtime/handles.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6245
diff changeset
    31
#include "runtime/javaCalls.hpp"
50429
83aec1d357d4 8204301: Make OrderAccess functions available to hpp rather than inline.hpp files
coleenp
parents: 49360
diff changeset
    32
#include "runtime/orderAccess.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6245
diff changeset
    33
#include "services/lowMemoryDetector.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6245
diff changeset
    34
#include "services/management.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6245
diff changeset
    35
#include "services/memoryManager.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6245
diff changeset
    36
#include "services/memoryPool.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6245
diff changeset
    37
#include "services/memoryService.hpp"
9623
151c0b638488 7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents: 8921
diff changeset
    38
#include "services/gcNotifier.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6245
diff changeset
    39
#include "utilities/dtrace.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
48168
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47634
diff changeset
    41
MemoryManager::MemoryManager(const char* name) : _name(name) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
  _num_pools = 0;
24831
e4df2f64bb2e 8041623: Solaris Studio 12.4 C++ 5.13, CHECK_UNHANDLED_OOPS use of class oop's copy constructor definitions causing error level diagnostic.
lfoltan
parents: 24351
diff changeset
    43
  (void)const_cast<instanceOop&>(_memory_mgr_obj = instanceOop(NULL));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
50635
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
    46
int MemoryManager::add_pool(MemoryPool* pool) {
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
    47
  int index = _num_pools;
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
    48
  assert(index < MemoryManager::max_num_pools, "_num_pools exceeds the max");
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
    49
  if (index < MemoryManager::max_num_pools) {
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
    50
    _pools[index] = pool;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
    _num_pools++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  pool->add_manager(this);
50635
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
    54
  return index;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
MemoryManager* MemoryManager::get_code_cache_memory_manager() {
48168
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47634
diff changeset
    58
  return new MemoryManager("CodeCacheManager");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
18444
8adb4bc92f18 8013590: NPG: Add a memory pool MXBean for Metaspace
ehelin
parents: 16453
diff changeset
    61
MemoryManager* MemoryManager::get_metaspace_memory_manager() {
48168
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47634
diff changeset
    62
  return new MemoryManager("Metaspace Manager");
4459
eb506d590394 6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents: 1
diff changeset
    63
}
eb506d590394 6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents: 1
diff changeset
    64
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
instanceOop MemoryManager::get_memory_manager_instance(TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  // Must do an acquire so as to force ordering of subsequent
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  // loads from anything _memory_mgr_obj points to or implies.
47634
6a0c42c40cd1 8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents: 47216
diff changeset
    68
  instanceOop mgr_obj = OrderAccess::load_acquire(&_memory_mgr_obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  if (mgr_obj == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
    // It's ok for more than one thread to execute the code up to the locked region.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
    // Extra manager instances will just be gc'ed.
30247
9925b07bba5b 8042901: Allow com.sun.management to be in a different module to java.lang.management
sjiang
parents: 28163
diff changeset
    72
    Klass* k = Management::sun_management_ManagementFactoryHelper_klass(CHECK_0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
    Handle mgr_name = java_lang_String::create_from_str(name(), CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
    JavaValue result(T_OBJECT);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
    JavaCallArguments args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
    args.push_oop(mgr_name);    // Argument 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    80
    Symbol* method_name = NULL;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    81
    Symbol* signature = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
    if (is_gc_memory_manager()) {
30247
9925b07bba5b 8042901: Allow com.sun.management to be in a different module to java.lang.management
sjiang
parents: 28163
diff changeset
    83
      Klass* extKlass = Management::com_sun_management_internal_GarbageCollectorExtImpl_klass(CHECK_0);
9925b07bba5b 8042901: Allow com.sun.management to be in a different module to java.lang.management
sjiang
parents: 28163
diff changeset
    84
      // com.sun.management.GarbageCollectorMXBean is in jdk.management module which may not be present.
9925b07bba5b 8042901: Allow com.sun.management to be in a different module to java.lang.management
sjiang
parents: 28163
diff changeset
    85
      if (extKlass != NULL) {
9925b07bba5b 8042901: Allow com.sun.management to be in a different module to java.lang.management
sjiang
parents: 28163
diff changeset
    86
        k = extKlass;
9925b07bba5b 8042901: Allow com.sun.management to be in a different module to java.lang.management
sjiang
parents: 28163
diff changeset
    87
      }
9925b07bba5b 8042901: Allow com.sun.management to be in a different module to java.lang.management
sjiang
parents: 28163
diff changeset
    88
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    89
      method_name = vmSymbols::createGarbageCollector_name();
30247
9925b07bba5b 8042901: Allow com.sun.management to be in a different module to java.lang.management
sjiang
parents: 28163
diff changeset
    90
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    91
      signature = vmSymbols::createGarbageCollector_signature();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
      args.push_oop(Handle());      // Argument 2 (for future extension)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
    } else {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    94
      method_name = vmSymbols::createMemoryManager_name();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    95
      signature = vmSymbols::createMemoryManager_signature();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 30247
diff changeset
    98
    InstanceKlass* ik = InstanceKlass::cast(k);
30247
9925b07bba5b 8042901: Allow com.sun.management to be in a different module to java.lang.management
sjiang
parents: 28163
diff changeset
    99
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
    JavaCalls::call_static(&result,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
                           ik,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
                           method_name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
                           signature,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
                           &args,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
                           CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
    instanceOop m = (instanceOop) result.get_jobject();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
    instanceHandle mgr(THREAD, m);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
      // Get lock before setting _memory_mgr_obj
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
      // since another thread may have created the instance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
      MutexLocker ml(Management_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
      // Check if another thread has created the management object.  We reload
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
      // _memory_mgr_obj here because some other thread may have initialized
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
      // it while we were executing the code before the lock.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
      //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
      // The lock has done an acquire, so the load can't float above it, but
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
      // we need to do a load_acquire as above.
47634
6a0c42c40cd1 8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents: 47216
diff changeset
   121
      mgr_obj = OrderAccess::load_acquire(&_memory_mgr_obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
      if (mgr_obj != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
         return mgr_obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
      // Get the address of the object we created via call_special.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
      mgr_obj = mgr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
      // Use store barrier to make sure the memory accesses associated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
      // with creating the management object are visible before publishing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
      // its address.  The unlock will publish the store to _memory_mgr_obj
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
      // because it does a release first.
47634
6a0c42c40cd1 8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents: 47216
diff changeset
   133
      OrderAccess::release_store(&_memory_mgr_obj, mgr_obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  return mgr_obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
void MemoryManager::oops_do(OopClosure* f) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  f->do_oop((oop*) &_memory_mgr_obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
GCStatInfo::GCStatInfo(int num_pools) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  // initialize the arrays for memory usage
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11591
diff changeset
   146
  _before_gc_usage_array = (MemoryUsage*) NEW_C_HEAP_ARRAY(MemoryUsage, num_pools, mtInternal);
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11591
diff changeset
   147
  _after_gc_usage_array  = (MemoryUsage*) NEW_C_HEAP_ARRAY(MemoryUsage, num_pools, mtInternal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  _usage_array_size = num_pools;
11171
02c21e3d0a66 7110173: GCNotifier::pushNotification publishes stale data.
johnc
parents: 10739
diff changeset
   149
  clear();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
GCStatInfo::~GCStatInfo() {
27880
afb974a04396 8060074: os::free() takes MemoryTrackingLevel but doesn't need it
coleenp
parents: 24831
diff changeset
   153
  FREE_C_HEAP_ARRAY(MemoryUsage*, _before_gc_usage_array);
afb974a04396 8060074: os::free() takes MemoryTrackingLevel but doesn't need it
coleenp
parents: 24831
diff changeset
   154
  FREE_C_HEAP_ARRAY(MemoryUsage*, _after_gc_usage_array);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
void GCStatInfo::set_gc_usage(int pool_index, MemoryUsage usage, bool before_gc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  MemoryUsage* gc_usage_array;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  if (before_gc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
    gc_usage_array = _before_gc_usage_array;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
    gc_usage_array = _after_gc_usage_array;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  gc_usage_array[pool_index] = usage;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   167
void GCStatInfo::clear() {
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   168
  _index = 0;
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   169
  _start_time = 0L;
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   170
  _end_time = 0L;
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   171
  size_t len = _usage_array_size * sizeof(MemoryUsage);
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   172
  memset(_before_gc_usage_array, 0, len);
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   173
  memset(_after_gc_usage_array, 0, len);
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   174
}
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   175
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   176
48168
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47634
diff changeset
   177
GCMemoryManager::GCMemoryManager(const char* name, const char* gc_end_message) :
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47634
diff changeset
   178
  MemoryManager(name), _gc_end_message(gc_end_message) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  _num_collections = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  _last_gc_stat = NULL;
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27880
diff changeset
   181
  _last_gc_lock = new Mutex(Mutex::leaf, "_last_gc_lock", true,
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27880
diff changeset
   182
                            Monitor::_safepoint_check_never);
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   183
  _current_gc_stat = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  _num_gc_threads = 1;
9623
151c0b638488 7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents: 8921
diff changeset
   185
  _notification_enabled = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
GCMemoryManager::~GCMemoryManager() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  delete _last_gc_stat;
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   190
  delete _last_gc_lock;
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   191
  delete _current_gc_stat;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
50635
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
   194
void GCMemoryManager::add_pool(MemoryPool* pool) {
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
   195
  add_pool(pool, true);
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
   196
}
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
   197
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
   198
void GCMemoryManager::add_pool(MemoryPool* pool, bool always_affected_by_gc) {
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
   199
  int index = MemoryManager::add_pool(pool);
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
   200
  _pool_always_affected_by_gc[index] = always_affected_by_gc;
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
   201
}
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
   202
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
void GCMemoryManager::initialize_gc_stat_info() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  assert(MemoryService::num_memory_pools() > 0, "should have one or more memory pools");
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11591
diff changeset
   205
  _last_gc_stat = new(ResourceObj::C_HEAP, mtGC) GCStatInfo(MemoryService::num_memory_pools());
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11591
diff changeset
   206
  _current_gc_stat = new(ResourceObj::C_HEAP, mtGC) GCStatInfo(MemoryService::num_memory_pools());
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   207
  // tracking concurrent collections we need two objects: one to update, and one to
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   208
  // hold the publicly available "last (completed) gc" information.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   211
void GCMemoryManager::gc_begin(bool recordGCBeginTime, bool recordPreGCUsage,
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   212
                               bool recordAccumulatedGCTime) {
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   213
  assert(_last_gc_stat != NULL && _current_gc_stat != NULL, "Just checking");
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   214
  if (recordAccumulatedGCTime) {
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   215
    _accumulated_timer.start();
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   216
  }
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   217
  // _num_collections now increases in gc_end, to count completed collections
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   218
  if (recordGCBeginTime) {
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   219
    _current_gc_stat->set_index(_num_collections+1);
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   220
    _current_gc_stat->set_start_time(Management::timestamp());
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   221
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   223
  if (recordPreGCUsage) {
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   224
    // Keep memory usage of all memory pools
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   225
    for (int i = 0; i < MemoryService::num_memory_pools(); i++) {
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   226
      MemoryPool* pool = MemoryService::get_memory_pool(i);
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   227
      MemoryUsage usage = pool->get_memory_usage();
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   228
      _current_gc_stat->set_before_gc_usage(i, usage);
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 9623
diff changeset
   229
      HOTSPOT_MEM_POOL_GC_BEGIN(
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 9623
diff changeset
   230
        (char *) name(), strlen(name()),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 9623
diff changeset
   231
        (char *) pool->name(), strlen(pool->name()),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 9623
diff changeset
   232
        usage.init_size(), usage.used(),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 9623
diff changeset
   233
        usage.committed(), usage.max_size());
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   234
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   238
// A collector MUST, even if it does not complete for some reason,
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   239
// make a TraceMemoryManagerStats object where countCollection is true,
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   240
// to ensure the current gc stat is placed in _last_gc_stat.
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   241
void GCMemoryManager::gc_end(bool recordPostGCUsage,
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   242
                             bool recordAccumulatedGCTime,
9623
151c0b638488 7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents: 8921
diff changeset
   243
                             bool recordGCEndTime, bool countCollection,
50635
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
   244
                             GCCause::Cause cause,
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
   245
                             bool allMemoryPoolsAffected) {
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   246
  if (recordAccumulatedGCTime) {
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   247
    _accumulated_timer.stop();
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   248
  }
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   249
  if (recordGCEndTime) {
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   250
    _current_gc_stat->set_end_time(Management::timestamp());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   253
  if (recordPostGCUsage) {
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   254
    int i;
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   255
    // keep the last gc statistics for all memory pools
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   256
    for (i = 0; i < MemoryService::num_memory_pools(); i++) {
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   257
      MemoryPool* pool = MemoryService::get_memory_pool(i);
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   258
      MemoryUsage usage = pool->get_memory_usage();
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   259
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 9623
diff changeset
   260
      HOTSPOT_MEM_POOL_GC_END(
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 9623
diff changeset
   261
        (char *) name(), strlen(name()),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 9623
diff changeset
   262
        (char *) pool->name(), strlen(pool->name()),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 9623
diff changeset
   263
        usage.init_size(), usage.used(),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 9623
diff changeset
   264
        usage.committed(), usage.max_size());
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   265
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   266
      _current_gc_stat->set_after_gc_usage(i, usage);
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   267
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   269
    // Set last collection usage of the memory pools managed by this collector
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   270
    for (i = 0; i < num_memory_pools(); i++) {
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   271
      MemoryPool* pool = get_memory_pool(i);
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   272
      MemoryUsage usage = pool->get_memory_usage();
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   273
50635
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
   274
      if (allMemoryPoolsAffected || pool_always_affected_by_gc(i)) {
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
   275
        // Compare with GC usage threshold
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
   276
        pool->set_last_collection_usage(usage);
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
   277
        LowMemoryDetector::detect_after_gc_memory(pool);
5d3c5af82654 8195115: G1 Old Gen MemoryPool CollectionUsage.used values don't reflect mixed GC results
phh
parents: 50429
diff changeset
   278
      }
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   279
    }
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   280
  }
11171
02c21e3d0a66 7110173: GCNotifier::pushNotification publishes stale data.
johnc
parents: 10739
diff changeset
   281
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   282
  if (countCollection) {
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   283
    _num_collections++;
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   284
    // alternately update two objects making one public when complete
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   285
    {
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   286
      MutexLockerEx ml(_last_gc_lock, Mutex::_no_safepoint_check_flag);
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   287
      GCStatInfo *tmp = _last_gc_stat;
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   288
      _last_gc_stat = _current_gc_stat;
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   289
      _current_gc_stat = tmp;
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   290
      // reset the current stat for diagnosability purposes
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   291
      _current_gc_stat->clear();
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   292
    }
11171
02c21e3d0a66 7110173: GCNotifier::pushNotification publishes stale data.
johnc
parents: 10739
diff changeset
   293
02c21e3d0a66 7110173: GCNotifier::pushNotification publishes stale data.
johnc
parents: 10739
diff changeset
   294
    if (is_notification_enabled()) {
48168
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47634
diff changeset
   295
      GCNotifier::pushNotification(this, _gc_end_message, GCCause::to_string(cause));
11171
02c21e3d0a66 7110173: GCNotifier::pushNotification publishes stale data.
johnc
parents: 10739
diff changeset
   296
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
}
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   299
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   300
size_t GCMemoryManager::get_last_gc_stat(GCStatInfo* dest) {
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   301
  MutexLockerEx ml(_last_gc_lock, Mutex::_no_safepoint_check_flag);
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   302
  if (_last_gc_stat->gc_index() != 0) {
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   303
    dest->set_index(_last_gc_stat->gc_index());
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   304
    dest->set_start_time(_last_gc_stat->start_time());
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   305
    dest->set_end_time(_last_gc_stat->end_time());
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   306
    assert(dest->usage_array_size() == _last_gc_stat->usage_array_size(),
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   307
           "Must have same array size");
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   308
    size_t len = dest->usage_array_size() * sizeof(MemoryUsage);
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   309
    memcpy(dest->before_gc_usage_array(), _last_gc_stat->before_gc_usage_array(), len);
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   310
    memcpy(dest->after_gc_usage_array(), _last_gc_stat->after_gc_usage_array(), len);
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   311
  }
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   312
  return _last_gc_stat->gc_index();
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   313
}