src/hotspot/share/services/memoryService.cpp

rev 48000 : [mq]: open.patch
rev 48001 : [mq]: 8191564-new.patch

*** 74,92 ****
    // set the GC thread count
    GcThreadCountClosure gctcc;
    heap->gc_threads_do(&gctcc);
    int count = gctcc.count();
  
!   GrowableArray<GCMemoryManager*> gc_mem_mgrs = heap->memory_managers();
!   for (int i = 0; i < gc_mem_mgrs.length(); i++) {
!     GCMemoryManager* gc_mgr = gc_mem_mgrs.at(i);
  
      if (count > 0) {
!       gc_mgr->set_num_gc_threads(count);
      }
!     gc_mgr->initialize_gc_stat_info();
!     _managers_list->append(gc_mgr);
    }
  }
  
  void MemoryService::add_code_heap_memory_pool(CodeHeap* heap, const char* name) {
    // Create new memory pool for this heap
--- 74,92 ----
    // set the GC thread count
    GcThreadCountClosure gctcc;
    heap->gc_threads_do(&gctcc);
    int count = gctcc.count();
  
!   GrowableArray<GCMemoryManager*> gc_memory_managers = heap->memory_managers();
!   for (int i = 0; i < gc_memory_managers.length(); i++) {
!     GCMemoryManager* gc_manager = gc_memory_managers.at(i);
  
      if (count > 0) {
!       gc_manager->set_num_gc_threads(count);
      }
!     gc_manager->initialize_gc_stat_info();
!     _managers_list->append(gc_manager);
    }
  }
  
  void MemoryService::add_code_heap_memory_pool(CodeHeap* heap, const char* name) {
    // Create new memory pool for this heap
*** 160,190 ****
    if (LowMemoryDetector::is_enabled(pool)) {
      LowMemoryDetector::detect_low_memory(pool);
    }
  }
  
! void MemoryService::gc_begin(GCMemoryManager* mgr, bool recordGCBeginTime,
                               bool recordAccumulatedGCTime,
                               bool recordPreGCUsage, bool recordPeakUsage) {
  
!   mgr->gc_begin(recordGCBeginTime, recordPreGCUsage, recordAccumulatedGCTime);
  
    // Track the peak memory usage when GC begins
    if (recordPeakUsage) {
      for (int i = 0; i < _pools_list->length(); i++) {
        MemoryPool* pool = _pools_list->at(i);
        pool->record_peak_memory_usage();
      }
    }
  }
  
! void MemoryService::gc_end(GCMemoryManager* mgr, bool recordPostGCUsage,
                             bool recordAccumulatedGCTime,
                             bool recordGCEndTime, bool countCollection,
                             GCCause::Cause cause) {
    // register the GC end statistics and memory usage
!   mgr->gc_end(recordPostGCUsage, recordAccumulatedGCTime, recordGCEndTime,
                countCollection, cause);
  }
  
  void MemoryService::oops_do(OopClosure* f) {
    int i;
--- 160,190 ----
    if (LowMemoryDetector::is_enabled(pool)) {
      LowMemoryDetector::detect_low_memory(pool);
    }
  }
  
! void MemoryService::gc_begin(GCMemoryManager* manager, bool recordGCBeginTime,
                               bool recordAccumulatedGCTime,
                               bool recordPreGCUsage, bool recordPeakUsage) {
  
!   manager->gc_begin(recordGCBeginTime, recordPreGCUsage, recordAccumulatedGCTime);
  
    // Track the peak memory usage when GC begins
    if (recordPeakUsage) {
      for (int i = 0; i < _pools_list->length(); i++) {
        MemoryPool* pool = _pools_list->at(i);
        pool->record_peak_memory_usage();
      }
    }
  }
  
! void MemoryService::gc_end(GCMemoryManager* manager, bool recordPostGCUsage,
                             bool recordAccumulatedGCTime,
                             bool recordGCEndTime, bool countCollection,
                             GCCause::Cause cause) {
    // register the GC end statistics and memory usage
!   manager->gc_end(recordPostGCUsage, recordAccumulatedGCTime, recordGCEndTime,
                    countCollection, cause);
  }
  
  void MemoryService::oops_do(OopClosure* f) {
    int i;
*** 232,279 ****
                            &args,
                            CHECK_NH);
    return obj;
  }
  
! TraceMemoryManagerStats::TraceMemoryManagerStats(GCMemoryManager* gc_mem_mgr,
                                                   GCCause::Cause cause,
                                                   bool recordGCBeginTime,
                                                   bool recordPreGCUsage,
                                                   bool recordPeakUsage,
                                                   bool recordPostGCUsage,
                                                   bool recordAccumulatedGCTime,
                                                   bool recordGCEndTime,
                                                   bool countCollection) {
!   initialize(gc_mem_mgr, cause, recordGCBeginTime, recordPreGCUsage, recordPeakUsage,
               recordPostGCUsage, recordAccumulatedGCTime, recordGCEndTime,
               countCollection);
  }
  
  // for a subclass to create then initialize an instance before invoking
  // the MemoryService
! void TraceMemoryManagerStats::initialize(GCMemoryManager* gc_mem_mgr,
                                           GCCause::Cause cause,
                                           bool recordGCBeginTime,
                                           bool recordPreGCUsage,
                                           bool recordPeakUsage,
                                           bool recordPostGCUsage,
                                           bool recordAccumulatedGCTime,
                                           bool recordGCEndTime,
                                           bool countCollection) {
!   _gc_mem_mgr = gc_mem_mgr;
    _recordGCBeginTime = recordGCBeginTime;
    _recordPreGCUsage = recordPreGCUsage;
    _recordPeakUsage = recordPeakUsage;
    _recordPostGCUsage = recordPostGCUsage;
    _recordAccumulatedGCTime = recordAccumulatedGCTime;
    _recordGCEndTime = recordGCEndTime;
    _countCollection = countCollection;
    _cause = cause;
  
!   MemoryService::gc_begin(_gc_mem_mgr, _recordGCBeginTime, _recordAccumulatedGCTime,
                            _recordPreGCUsage, _recordPeakUsage);
  }
  
  TraceMemoryManagerStats::~TraceMemoryManagerStats() {
!   MemoryService::gc_end(_gc_mem_mgr, _recordPostGCUsage, _recordAccumulatedGCTime,
                          _recordGCEndTime, _countCollection, _cause);
  }
--- 232,279 ----
                            &args,
                            CHECK_NH);
    return obj;
  }
  
! TraceMemoryManagerStats::TraceMemoryManagerStats(GCMemoryManager* gc_memory_manager,
                                                   GCCause::Cause cause,
                                                   bool recordGCBeginTime,
                                                   bool recordPreGCUsage,
                                                   bool recordPeakUsage,
                                                   bool recordPostGCUsage,
                                                   bool recordAccumulatedGCTime,
                                                   bool recordGCEndTime,
                                                   bool countCollection) {
!   initialize(gc_memory_manager, cause, recordGCBeginTime, recordPreGCUsage, recordPeakUsage,
               recordPostGCUsage, recordAccumulatedGCTime, recordGCEndTime,
               countCollection);
  }
  
  // for a subclass to create then initialize an instance before invoking
  // the MemoryService
! void TraceMemoryManagerStats::initialize(GCMemoryManager* gc_memory_manager,
                                           GCCause::Cause cause,
                                           bool recordGCBeginTime,
                                           bool recordPreGCUsage,
                                           bool recordPeakUsage,
                                           bool recordPostGCUsage,
                                           bool recordAccumulatedGCTime,
                                           bool recordGCEndTime,
                                           bool countCollection) {
!   _gc_memory_manager = gc_memory_manager;
    _recordGCBeginTime = recordGCBeginTime;
    _recordPreGCUsage = recordPreGCUsage;
    _recordPeakUsage = recordPeakUsage;
    _recordPostGCUsage = recordPostGCUsage;
    _recordAccumulatedGCTime = recordAccumulatedGCTime;
    _recordGCEndTime = recordGCEndTime;
    _countCollection = countCollection;
    _cause = cause;
  
!   MemoryService::gc_begin(_gc_memory_manager, _recordGCBeginTime, _recordAccumulatedGCTime,
                            _recordPreGCUsage, _recordPeakUsage);
  }
  
  TraceMemoryManagerStats::~TraceMemoryManagerStats() {
!   MemoryService::gc_end(_gc_memory_manager, _recordPostGCUsage, _recordAccumulatedGCTime,
                          _recordGCEndTime, _countCollection, _cause);
  }