src/share/vm/gc/parallel/psCompactionManager.cpp

rev 10845 : 8150994: UseParallelGC fails with UseDynamicNumberOfGCThreads with specjbb2005
Reviewed-by: tschatzl, kbarrett

*** 41,83 ****
  #include "runtime/atomic.inline.hpp"
  
  PSOldGen*            ParCompactionManager::_old_gen = NULL;
  ParCompactionManager**  ParCompactionManager::_manager_array = NULL;
  
- RegionTaskQueue**              ParCompactionManager::_region_list = NULL;
- 
  OopTaskQueueSet*     ParCompactionManager::_stack_array = NULL;
  ParCompactionManager::ObjArrayTaskQueueSet*
    ParCompactionManager::_objarray_queues = NULL;
  ObjectStartArray*    ParCompactionManager::_start_array = NULL;
  ParMarkBitMap*       ParCompactionManager::_mark_bitmap = NULL;
  RegionTaskQueueSet*  ParCompactionManager::_region_array = NULL;
  
- uint*                 ParCompactionManager::_recycled_stack_index = NULL;
- int                   ParCompactionManager::_recycled_top = -1;
- int                   ParCompactionManager::_recycled_bottom = -1;
- 
  ParCompactionManager::ParCompactionManager() :
!     _action(CopyAndUpdate),
!     _region_stack(NULL),
!     _region_stack_index((uint)max_uintx) {
  
    ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
  
    _old_gen = heap->old_gen();
    _start_array = old_gen()->start_array();
  
    marking_stack()->initialize();
    _objarray_stack.initialize();
  
    reset_bitmap_query_cache();
  }
  
- ParCompactionManager::~ParCompactionManager() {
-   delete _recycled_stack_index;
- }
- 
  void ParCompactionManager::initialize(ParMarkBitMap* mbm) {
    assert(PSParallelCompact::gc_task_manager() != NULL,
      "Needed for initialization");
  
    _mark_bitmap = mbm;
--- 41,72 ----
  #include "runtime/atomic.inline.hpp"
  
  PSOldGen*            ParCompactionManager::_old_gen = NULL;
  ParCompactionManager**  ParCompactionManager::_manager_array = NULL;
  
  OopTaskQueueSet*     ParCompactionManager::_stack_array = NULL;
  ParCompactionManager::ObjArrayTaskQueueSet*
    ParCompactionManager::_objarray_queues = NULL;
  ObjectStartArray*    ParCompactionManager::_start_array = NULL;
  ParMarkBitMap*       ParCompactionManager::_mark_bitmap = NULL;
  RegionTaskQueueSet*  ParCompactionManager::_region_array = NULL;
  
  ParCompactionManager::ParCompactionManager() :
!     _action(CopyAndUpdate) {
  
    ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
  
    _old_gen = heap->old_gen();
    _start_array = old_gen()->start_array();
  
    marking_stack()->initialize();
    _objarray_stack.initialize();
+   _region_stack.initialize();
  
    reset_bitmap_query_cache();
  }
  
  void ParCompactionManager::initialize(ParMarkBitMap* mbm) {
    assert(PSParallelCompact::gc_task_manager() != NULL,
      "Needed for initialization");
  
    _mark_bitmap = mbm;
*** 86,108 ****
  
    assert(_manager_array == NULL, "Attempt to initialize twice");
    _manager_array = NEW_C_HEAP_ARRAY(ParCompactionManager*, parallel_gc_threads+1, mtGC);
    guarantee(_manager_array != NULL, "Could not allocate manager_array");
  
-   _region_list = NEW_C_HEAP_ARRAY(RegionTaskQueue*,
-                          parallel_gc_threads+1, mtGC);
-   guarantee(_region_list != NULL, "Could not initialize promotion manager");
- 
-   _recycled_stack_index = NEW_C_HEAP_ARRAY(uint, parallel_gc_threads, mtGC);
- 
-   // parallel_gc-threads + 1 to be consistent with the number of
-   // compaction managers.
-   for(uint i=0; i<parallel_gc_threads + 1; i++) {
-     _region_list[i] = new RegionTaskQueue();
-     region_list(i)->initialize();
-   }
- 
    _stack_array = new OopTaskQueueSet(parallel_gc_threads);
    guarantee(_stack_array != NULL, "Could not allocate stack_array");
    _objarray_queues = new ObjArrayTaskQueueSet(parallel_gc_threads);
    guarantee(_objarray_queues != NULL, "Could not allocate objarray_queues");
    _region_array = new RegionTaskQueueSet(parallel_gc_threads);
--- 75,84 ----
*** 112,122 ****
    for(uint i=0; i<parallel_gc_threads; i++) {
      _manager_array[i] = new ParCompactionManager();
      guarantee(_manager_array[i] != NULL, "Could not create ParCompactionManager");
      stack_array()->register_queue(i, _manager_array[i]->marking_stack());
      _objarray_queues->register_queue(i, &_manager_array[i]->_objarray_stack);
!     region_array()->register_queue(i, region_list(i));
    }
  
    // The VMThread gets its own ParCompactionManager, which is not available
    // for work stealing.
    _manager_array[parallel_gc_threads] = new ParCompactionManager();
--- 88,98 ----
    for(uint i=0; i<parallel_gc_threads; i++) {
      _manager_array[i] = new ParCompactionManager();
      guarantee(_manager_array[i] != NULL, "Could not create ParCompactionManager");
      stack_array()->register_queue(i, _manager_array[i]->marking_stack());
      _objarray_queues->register_queue(i, &_manager_array[i]->_objarray_stack);
!     region_array()->register_queue(i, _manager_array[i]->region_stack());
    }
  
    // The VMThread gets its own ParCompactionManager, which is not available
    // for work stealing.
    _manager_array[parallel_gc_threads] = new ParCompactionManager();
*** 131,163 ****
    for (uint i=0; i<=parallel_gc_threads; i++) {
      _manager_array[i]->reset_bitmap_query_cache();
    }
  }
  
- int ParCompactionManager::pop_recycled_stack_index() {
-   assert(_recycled_bottom <= _recycled_top, "list is empty");
-   // Get the next available index
-   if (_recycled_bottom < _recycled_top) {
-     uint cur, next, last;
-     do {
-       cur = _recycled_bottom;
-       next = cur + 1;
-       last = Atomic::cmpxchg(next, &_recycled_bottom, cur);
-     } while (cur != last);
-     return _recycled_stack_index[next];
-   } else {
-     return -1;
-   }
- }
- 
- void ParCompactionManager::push_recycled_stack_index(uint v) {
-   // Get the next available index
-   int cur = Atomic::add(1, &_recycled_top);
-   _recycled_stack_index[cur] = v;
-   assert(_recycled_bottom <= _recycled_top, "list top and bottom are wrong");
- }
- 
  bool ParCompactionManager::should_update() {
    assert(action() != NotValid, "Action is not set");
    return (action() == ParCompactionManager::Update) ||
           (action() == ParCompactionManager::CopyAndUpdate) ||
           (action() == ParCompactionManager::UpdateAndCopy);
--- 107,116 ----
*** 168,186 ****
    return (action() == ParCompactionManager::Copy) ||
           (action() == ParCompactionManager::CopyAndUpdate) ||
           (action() == ParCompactionManager::UpdateAndCopy);
  }
  
- void ParCompactionManager::region_list_push(uint list_index,
-                                             size_t region_index) {
-   region_list(list_index)->push(region_index);
- }
- 
- void ParCompactionManager::verify_region_list_empty(uint list_index) {
-   assert(region_list(list_index)->is_empty(), "Not empty");
- }
- 
  ParCompactionManager*
  ParCompactionManager::gc_thread_compaction_manager(uint index) {
    assert(index < ParallelGCThreads, "index out of range");
    assert(_manager_array != NULL, "Sanity");
    return _manager_array[index];
--- 121,130 ----