jdk8-mips64-public/hotspot: comparison src/share/vm/gc_implementation/parNew/parNewGeneration.cpp

-:cea947c8a988
+:becb17ad5e51
 ParScanThreadState::ParScanThreadState(Space* to_space_,
 ParNewGeneration* gen_,
 Generation* old_gen_,
 int thread_num_,
 ObjToScanQueueSet* work_queue_set_,
+GrowableArray<oop>**  overflow_stack_set_,
 size_t desired_plab_sz_,
 ParallelTaskTerminator& term_) :
 _to_space(to_space_), _old_gen(old_gen_), _young_gen(gen_), _thread_num(thread_num_),
 _work_queue(work_queue_set_->queue(thread_num_)), _to_space_full(false),
+_overflow_stack(overflow_stack_set_[thread_num_]),
 _ageTable(false), // false ==> not the global age table, no perf data.
 _to_space_alloc_buffer(desired_plab_sz_),
 _to_space_closure(gen_, this), _old_gen_closure(gen_, this),
 _to_space_root_closure(gen_, this), _old_gen_root_closure(gen_, this),
 _older_gen_closure(gen_, this),
 (ChunkArray*) old_gen()->get_data_recorder(thread_num());
 _hash_seed = 17;  // Might want to take time-based random value.
 _start = os::elapsedTime();
 _old_gen_closure.set_generation(old_gen_);
 _old_gen_root_closure.set_generation(old_gen_);
-if (UseCompressedOops) {
-_overflow_stack = new (ResourceObj::C_HEAP) GrowableArray<oop>(512, true);
-} else {
-_overflow_stack = NULL;
-}
 }
 #ifdef _MSC_VER
 #pragma warning( pop )
 #endif
 // private overflow stack.
 } while (ParGCTrimOverflow && young_gen()->take_from_overflow_list(this));
 }
 bool ParScanThreadState::take_from_overflow_stack() {
-assert(UseCompressedOops, "Else should not call");
+assert(ParGCUseLocalOverflow, "Else should not call");
 assert(young_gen()->overflow_list() == NULL, "Error");
 ObjToScanQueue* queue = work_queue();
 GrowableArray<oop>* of_stack = overflow_stack();
 uint num_overflow_elems = of_stack->length();
 uint num_take_elems     = MIN2(MIN2((queue->max_elems() - queue->size())/4,
 assert(young_gen()->overflow_list() == NULL, "Error");
 return num_take_elems > 0;  // was something transferred?
 }
 void ParScanThreadState::push_on_overflow_stack(oop p) {
-assert(UseCompressedOops, "Else should not call");
+assert(ParGCUseLocalOverflow, "Else should not call");
 overflow_stack()->push(p);
 assert(young_gen()->overflow_list() == NULL, "Error");
 }
 HeapWord* ParScanThreadState::alloc_in_to_space_slow(size_t word_sz) {
 ParScanThreadStateSet(int                     num_threads,
 Space&                  to_space,
 ParNewGeneration&       gen,
 Generation&             old_gen,
 ObjToScanQueueSet&      queue_set,
+GrowableArray<oop>**    overflow_stacks_,
 size_t                  desired_plab_sz,
 ParallelTaskTerminator& term);
 inline ParScanThreadState& thread_sate(int i);
 int pushes() { return _pushes; }
 int pops()   { return _pops; }
 ParScanThreadStateSet::ParScanThreadStateSet(
 int num_threads, Space& to_space, ParNewGeneration& gen,
 Generation& old_gen, ObjToScanQueueSet& queue_set,
+GrowableArray<oop>** overflow_stack_set_,
 size_t desired_plab_sz, ParallelTaskTerminator& term)
 : ResourceArray(sizeof(ParScanThreadState), num_threads),
 _gen(gen), _next_gen(old_gen), _term(term),
 _pushes(0), _pops(0), _steals(0)
 {
 assert(num_threads > 0, "sanity check!");
 // Initialize states.
 for (int i = 0; i < num_threads; ++i) {
 new ((ParScanThreadState*)_data + i)
 ParScanThreadState(&to_space, &gen, &old_gen, i, &queue_set,
-desired_plab_sz, term);
+overflow_stack_set_, desired_plab_sz, term);
 }
 }
 inline ParScanThreadState& ParScanThreadStateSet::thread_sate(int i)
 {
 }
 for (uint i2 = 0; i2 < ParallelGCThreads; i2++)
 _task_queues->queue(i2)->initialize();
+_overflow_stacks = NEW_C_HEAP_ARRAY(GrowableArray<oop>*, ParallelGCThreads);
+guarantee(_overflow_stacks != NULL, "Overflow stack set allocation failure");
+for (uint i = 0; i < ParallelGCThreads; i++) {
+if (ParGCUseLocalOverflow) {
+_overflow_stacks[i] = new (ResourceObj::C_HEAP) GrowableArray<oop>(512, true);
+guarantee(_overflow_stacks[i] != NULL, "Overflow Stack allocation failure.");
+} else {
+_overflow_stacks[i] = NULL;
+}
+}
 if (UsePerfData) {
 EXCEPTION_MARK;
 ResourceMark rm;
 const char* cname =
 gch->save_marks();
 assert(workers != NULL, "Need parallel worker threads.");
 ParallelTaskTerminator _term(workers->total_workers(), task_queues());
 ParScanThreadStateSet thread_state_set(workers->total_workers(),
 *to(), *this, *_next_gen, *task_queues(),
-desired_plab_sz(), _term);
+_overflow_stacks, desired_plab_sz(), _term);
 ParNewGenTask tsk(this, _next_gen, reserved().end(), &thread_state_set);
 int n_workers = workers->total_workers();
 gch->set_par_threads(n_workers);
 gch->change_strong_roots_parity();
 // single global lists have their own performance disadvantages
 // as we were made painfully aware not long ago, see 6786503).
 #define BUSY (oop(0x1aff1aff))
 void ParNewGeneration::push_on_overflow_list(oop from_space_obj, ParScanThreadState* par_scan_state) {
 assert(is_in_reserved(from_space_obj), "Should be from this generation");
-if (UseCompressedOops) {
+if (ParGCUseLocalOverflow) {
 // In the case of compressed oops, we use a private, not-shared
 // overflow stack.
 par_scan_state->push_on_overflow_stack(from_space_obj);
 } else {
+assert(!UseCompressedOops, "Error");
 // if the object has been forwarded to itself, then we cannot
 // use the klass pointer for the linked list.  Instead we have
 // to allocate an oopDesc in the C-Heap and use that for the linked list.
 // XXX This is horribly inefficient when a promotion failure occurs
 // and should be fixed. XXX FIX ME !!!
 }
 bool ParNewGeneration::take_from_overflow_list(ParScanThreadState* par_scan_state) {
 bool res;
-if (UseCompressedOops) {
+if (ParGCUseLocalOverflow) {
 res = par_scan_state->take_from_overflow_stack();
 } else {
+assert(!UseCompressedOops, "Error");
 res = take_from_overflow_list_work(par_scan_state);
 }
 return res;
 }
 // How many to take?
 size_t objsFromOverflow = MIN2((size_t)(work_q->max_elems() - work_q->size())/4,
 (size_t)ParGCDesiredObjsFromOverflowList);
 assert(par_scan_state->overflow_stack() == NULL, "Error");
+assert(!UseCompressedOops, "Error");
 if (_overflow_list == NULL) return false;
 // Otherwise, there was something there; try claiming the list.
 oop prefix = (oop)Atomic::xchg_ptr(BUSY, &_overflow_list);
 // Trim off a prefix of at most objsFromOverflow items

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

comparison: src/share/vm/gc_implementation/parNew/parNewGeneration.cpp

src/share/vm/gc_implementation/parNew/parNewGeneration.cpp