graal-compiler: src/share/vm/services/memoryManager.cpp comparison

comparison src/share/vm/services/memoryManager.cpp @ 1703:f6f3eef8a521

6581734: CMS Old Gen's collection usage is zero after GC which is incorrect Summary: Management code enabled for use by a concurrent collector. Reviewed-by: mchung, ysr

author	kevinw
date	Fri, 30 Jul 2010 22:43:50 +0100
parents	c18cbe5936b8
children	f95d63e2154a

comparison

equal deleted inserted replaced

-:b9bc732be7c0
+:f6f3eef8a521
 GCStatInfo::~GCStatInfo() {
 FREE_C_HEAP_ARRAY(MemoryUsage*, _before_gc_usage_array);
 FREE_C_HEAP_ARRAY(MemoryUsage*, _after_gc_usage_array);
 }
-void GCStatInfo::copy_stat(GCStatInfo* stat) {
-set_index(stat->gc_index());
-set_start_time(stat->start_time());
-set_end_time(stat->end_time());
-assert(_usage_array_size == stat->usage_array_size(), "Must have same array size");
-for (int i = 0; i < _usage_array_size; i++) {
-set_before_gc_usage(i, stat->before_gc_usage_for_pool(i));
-set_after_gc_usage(i, stat->after_gc_usage_for_pool(i));
-}
-}
 void GCStatInfo::set_gc_usage(int pool_index, MemoryUsage usage, bool before_gc) {
 MemoryUsage* gc_usage_array;
 if (before_gc) {
 gc_usage_array = _before_gc_usage_array;
 } else {
 gc_usage_array = _after_gc_usage_array;
 }
 gc_usage_array[pool_index] = usage;
 }
+void GCStatInfo::clear() {
+_index = 0;
+_start_time = 0L;
+_end_time = 0L;
+size_t len = _usage_array_size * sizeof(MemoryUsage);
+memset(_before_gc_usage_array, 0, len);
+memset(_after_gc_usage_array, 0, len);
+}
 GCMemoryManager::GCMemoryManager() : MemoryManager() {
 _num_collections = 0;
 _last_gc_stat = NULL;
+_last_gc_lock = new Mutex(Mutex::leaf, "_last_gc_lock", true);
+_current_gc_stat = NULL;
 _num_gc_threads = 1;
 }
 GCMemoryManager::~GCMemoryManager() {
 delete _last_gc_stat;
+delete _last_gc_lock;
+delete _current_gc_stat;
 }
 void GCMemoryManager::initialize_gc_stat_info() {
 assert(MemoryService::num_memory_pools() > 0, "should have one or more memory pools");
 _last_gc_stat = new GCStatInfo(MemoryService::num_memory_pools());
-}
+_current_gc_stat = new GCStatInfo(MemoryService::num_memory_pools());
+// tracking concurrent collections we need two objects: one to update, and one to
-void GCMemoryManager::gc_begin() {
+// hold the publicly available "last (completed) gc" information.
-assert(_last_gc_stat != NULL, "Just checking");
+}
-_accumulated_timer.start();
-_num_collections++;
+void GCMemoryManager::gc_begin(bool recordGCBeginTime, bool recordPreGCUsage,
-_last_gc_stat->set_index(_num_collections);
+bool recordAccumulatedGCTime) {
-_last_gc_stat->set_start_time(Management::timestamp());
+assert(_last_gc_stat != NULL && _current_gc_stat != NULL, "Just checking");
+if (recordAccumulatedGCTime) {
-// Keep memory usage of all memory pools
+_accumulated_timer.start();
-for (int i = 0; i < MemoryService::num_memory_pools(); i++) {
+}
-MemoryPool* pool = MemoryService::get_memory_pool(i);
+// _num_collections now increases in gc_end, to count completed collections
-MemoryUsage usage = pool->get_memory_usage();
+if (recordGCBeginTime) {
-_last_gc_stat->set_before_gc_usage(i, usage);
+_current_gc_stat->set_index(_num_collections+1);
-HS_DTRACE_PROBE8(hotspot, mem__pool__gc__begin,
+_current_gc_stat->set_start_time(Management::timestamp());
-name(), strlen(name()),
+}
-pool->name(), strlen(pool->name()),
-usage.init_size(), usage.used(),
+if (recordPreGCUsage) {
-usage.committed(), usage.max_size());
+// Keep memory usage of all memory pools
-}
+for (int i = 0; i < MemoryService::num_memory_pools(); i++) {
-}
+MemoryPool* pool = MemoryService::get_memory_pool(i);
+MemoryUsage usage = pool->get_memory_usage();
-void GCMemoryManager::gc_end() {
+_current_gc_stat->set_before_gc_usage(i, usage);
-_accumulated_timer.stop();
+HS_DTRACE_PROBE8(hotspot, mem__pool__gc__begin,
-_last_gc_stat->set_end_time(Management::timestamp());
+name(), strlen(name()),
+pool->name(), strlen(pool->name()),
-int i;
+usage.init_size(), usage.used(),
-// keep the last gc statistics for all memory pools
+usage.committed(), usage.max_size());
-for (i = 0; i < MemoryService::num_memory_pools(); i++) {
+}
-MemoryPool* pool = MemoryService::get_memory_pool(i);
+}
-MemoryUsage usage = pool->get_memory_usage();
+}
-HS_DTRACE_PROBE8(hotspot, mem__pool__gc__end,
+// A collector MUST, even if it does not complete for some reason,
-name(), strlen(name()),
+// make a TraceMemoryManagerStats object where countCollection is true,
-pool->name(), strlen(pool->name()),
+// to ensure the current gc stat is placed in _last_gc_stat.
-usage.init_size(), usage.used(),
+void GCMemoryManager::gc_end(bool recordPostGCUsage,
-usage.committed(), usage.max_size());
+bool recordAccumulatedGCTime,
+bool recordGCEndTime, bool countCollection) {
-_last_gc_stat->set_after_gc_usage(i, usage);
+if (recordAccumulatedGCTime) {
-}
+_accumulated_timer.stop();
+}
-// Set last collection usage of the memory pools managed by this collector
+if (recordGCEndTime) {
-for (i = 0; i < num_memory_pools(); i++) {
+_current_gc_stat->set_end_time(Management::timestamp());
-MemoryPool* pool = get_memory_pool(i);
+}
-MemoryUsage usage = pool->get_memory_usage();
+if (recordPostGCUsage) {
-// Compare with GC usage threshold
+int i;
-pool->set_last_collection_usage(usage);
+// keep the last gc statistics for all memory pools
-LowMemoryDetector::detect_after_gc_memory(pool);
+for (i = 0; i < MemoryService::num_memory_pools(); i++) {
-}
+MemoryPool* pool = MemoryService::get_memory_pool(i);
-}
+MemoryUsage usage = pool->get_memory_usage();
+HS_DTRACE_PROBE8(hotspot, mem__pool__gc__end,
+name(), strlen(name()),
+pool->name(), strlen(pool->name()),
+usage.init_size(), usage.used(),
+usage.committed(), usage.max_size());
+_current_gc_stat->set_after_gc_usage(i, usage);
+}
+// Set last collection usage of the memory pools managed by this collector
+for (i = 0; i < num_memory_pools(); i++) {
+MemoryPool* pool = get_memory_pool(i);
+MemoryUsage usage = pool->get_memory_usage();
+// Compare with GC usage threshold
+pool->set_last_collection_usage(usage);
+LowMemoryDetector::detect_after_gc_memory(pool);
+}
+}
+if (countCollection) {
+_num_collections++;
+// alternately update two objects making one public when complete
+{
+MutexLockerEx ml(_last_gc_lock, Mutex::_no_safepoint_check_flag);
+GCStatInfo *tmp = _last_gc_stat;
+_last_gc_stat = _current_gc_stat;
+_current_gc_stat = tmp;
+// reset the current stat for diagnosability purposes
+_current_gc_stat->clear();
+}
+}
+}
+size_t GCMemoryManager::get_last_gc_stat(GCStatInfo* dest) {
+MutexLockerEx ml(_last_gc_lock, Mutex::_no_safepoint_check_flag);
+if (_last_gc_stat->gc_index() != 0) {
+dest->set_index(_last_gc_stat->gc_index());
+dest->set_start_time(_last_gc_stat->start_time());
+dest->set_end_time(_last_gc_stat->end_time());
+assert(dest->usage_array_size() == _last_gc_stat->usage_array_size(),
+"Must have same array size");
+size_t len = dest->usage_array_size() * sizeof(MemoryUsage);
+memcpy(dest->before_gc_usage_array(), _last_gc_stat->before_gc_usage_array(), len);
+memcpy(dest->after_gc_usage_array(), _last_gc_stat->after_gc_usage_array(), len);
+}
+return _last_gc_stat->gc_index();
+}

Mercurial > hg > graal-compiler

comparison src/share/vm/services/memoryManager.cpp @ 1703:f6f3eef8a521