graal-compiler: src/share/vm/gc_implementation/g1/concurrentMark.cpp comparison

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 8506:c3657d00e343

-Merge with tip

author	Christos Kotselidis <christos.kotselidis@oracle.com>
date	Thu, 21 Mar 2013 14:11:13 +0100
parents	5e401ef52ec0
children	47bc9800972c 9def4075da6d

comparison

equal deleted inserted replaced

-:dee7c8b578c7
+:c3657d00e343
 _parallel_marking_threads =       0;
 _max_parallel_marking_threads =   0;
 _sleep_factor             =     0.0;
 _marking_task_overhead    =     1.0;
 } else {
-if (ConcGCThreads > 0) {
+if (!FLAG_IS_DEFAULT(ConcGCThreads) && ConcGCThreads > 0) {
-// notice that ConcGCThreads overwrites G1MarkingOverheadPercent
+// Note: ConcGCThreads has precedence over G1MarkingOverheadPercent
 // if both are set
-_parallel_marking_threads = (uint) ConcGCThreads;
-_max_parallel_marking_threads = _parallel_marking_threads;
 _sleep_factor             = 0.0;
 _marking_task_overhead    = 1.0;
 } else if (G1MarkingOverheadPercent > 0) {
-// we will calculate the number of parallel marking threads
+// We will calculate the number of parallel marking threads based
-// based on a target overhead with respect to the soft real-time
+// on a target overhead with respect to the soft real-time goal
-// goal
 double marking_overhead = (double) G1MarkingOverheadPercent / 100.0;
 double overall_cm_overhead =
 (double) MaxGCPauseMillis * marking_overhead /
 (double) GCPauseIntervalMillis;
 double cpu_ratio = 1.0 / (double) os::processor_count();
 overall_cm_overhead / marking_thread_num *
 (double) os::processor_count();
 double sleep_factor =
 (1.0 - marking_task_overhead) / marking_task_overhead;
-_parallel_marking_threads = (uint) marking_thread_num;
+FLAG_SET_ERGO(uintx, ConcGCThreads, (uint) marking_thread_num);
-_max_parallel_marking_threads = _parallel_marking_threads;
 _sleep_factor             = sleep_factor;
 _marking_task_overhead    = marking_task_overhead;
 } else {
-_parallel_marking_threads = scale_parallel_threads((uint)ParallelGCThreads);
+// Calculate the number of parallel marking threads by scaling
-_max_parallel_marking_threads = _parallel_marking_threads;
+// the number of parallel GC threads.
+uint marking_thread_num = scale_parallel_threads((uint) ParallelGCThreads);
+FLAG_SET_ERGO(uintx, ConcGCThreads, marking_thread_num);
 _sleep_factor             = 0.0;
 _marking_task_overhead    = 1.0;
 }
+assert(ConcGCThreads > 0, "Should have been set");
+_parallel_marking_threads = (uint) ConcGCThreads;
+_max_parallel_marking_threads = _parallel_marking_threads;
 if (parallel_marking_threads() > 1) {
 _cleanup_task_overhead = 1.0;
 } else {
 _cleanup_task_overhead = marking_task_overhead();
 assert(parallel_marking_threads() <= max_parallel_marking_threads(),
 "Maximum number of marking threads exceeded");
 uint active_workers = MAX2(1U, parallel_marking_threads());
 CMRootRegionScanTask task(this);
-if (parallel_marking_threads() > 0) {
+if (use_parallel_marking_threads()) {
 _parallel_workers->set_active_workers((int) active_workers);
 _parallel_workers->run_task(&task);
 } else {
 task.work(0);
 }
 // Parallel task terminator is set in "set_phase()"
 set_phase(active_workers, true /* concurrent */);
 CMConcurrentMarkingTask markingTask(this, cmThread());
-if (parallel_marking_threads() > 0) {
+if (use_parallel_marking_threads()) {
 _parallel_workers->set_active_workers((int)active_workers);
 // Don't set _n_par_threads because it affects MT in proceess_strong_roots()
 // and the decisions on that MT processing is made elsewhere.
 assert(_parallel_workers->active_workers() > 0, "Should have been set");
 _parallel_workers->run_task(&markingTask);
 }
 }
 assert(tmp_free_list.is_empty(), "post-condition");
 }
-// Support closures for reference procssing in G1
+// Supporting Object and Oop closures for reference discovery
+// and processing in during marking
 bool G1CMIsAliveClosure::do_object_b(oop obj) {
 HeapWord* addr = (HeapWord*)obj;
 return addr != NULL &&
 (!_g1->is_in_g1_reserved(addr) || !_g1->is_obj_ill(obj));
 }
-class G1CMKeepAliveClosure: public ExtendedOopClosure {
+// 'Keep Alive' oop closure used by both serial parallel reference processing.
-G1CollectedHeap* _g1;
+// Uses the CMTask associated with a worker thread (for serial reference
-ConcurrentMark*  _cm;
+// processing the CMTask for worker 0 is used) to preserve (mark) and
-public:
+// trace referent objects.
-G1CMKeepAliveClosure(G1CollectedHeap* g1, ConcurrentMark* cm) :
+//
-_g1(g1), _cm(cm) {
+// Using the CMTask and embedded local queues avoids having the worker
-assert(Thread::current()->is_VM_thread(), "otherwise fix worker id");
+// threads operating on the global mark stack. This reduces the risk
-}
+// of overflowing the stack - which we would rather avoid at this late
+// state. Also using the tasks' local queues removes the potential
-virtual void do_oop(narrowOop* p) { do_oop_work(p); }
+// of the workers interfering with each other that could occur if
-virtual void do_oop(      oop* p) { do_oop_work(p); }
+// operating on the global stack.
-template <class T> void do_oop_work(T* p) {
+class G1CMKeepAliveAndDrainClosure: public OopClosure {
-oop obj = oopDesc::load_decode_heap_oop(p);
-HeapWord* addr = (HeapWord*)obj;
-if (_cm->verbose_high()) {
-gclog_or_tty->print_cr("\t[0] we're looking at location "
-"*"PTR_FORMAT" = "PTR_FORMAT,
-p, (void*) obj);
-}
-if (_g1->is_in_g1_reserved(addr) && _g1->is_obj_ill(obj)) {
-_cm->mark_and_count(obj);
-_cm->mark_stack_push(obj);
-}
-}
-};
-class G1CMDrainMarkingStackClosure: public VoidClosure {
-ConcurrentMark*               _cm;
-CMMarkStack*                  _markStack;
-G1CMKeepAliveClosure*         _oopClosure;
-public:
-G1CMDrainMarkingStackClosure(ConcurrentMark* cm, CMMarkStack* markStack,
-G1CMKeepAliveClosure* oopClosure) :
-_cm(cm),
-_markStack(markStack),
-_oopClosure(oopClosure) { }
-void do_void() {
-_markStack->drain(_oopClosure, _cm->nextMarkBitMap(), false);
-}
-};
-// 'Keep Alive' closure used by parallel reference processing.
-// An instance of this closure is used in the parallel reference processing
-// code rather than an instance of G1CMKeepAliveClosure. We could have used
-// the G1CMKeepAliveClosure as it is MT-safe. Also reference objects are
-// placed on to discovered ref lists once so we can mark and push with no
-// need to check whether the object has already been marked. Using the
-// G1CMKeepAliveClosure would mean, however, having all the worker threads
-// operating on the global mark stack. This means that an individual
-// worker would be doing lock-free pushes while it processes its own
-// discovered ref list followed by drain call. If the discovered ref lists
-// are unbalanced then this could cause interference with the other
-// workers. Using a CMTask (and its embedded local data structures)
-// avoids that potential interference.
-class G1CMParKeepAliveAndDrainClosure: public OopClosure {
 ConcurrentMark*  _cm;
 CMTask*          _task;
 int              _ref_counter_limit;
 int              _ref_counter;
 public:
-G1CMParKeepAliveAndDrainClosure(ConcurrentMark* cm, CMTask* task) :
+G1CMKeepAliveAndDrainClosure(ConcurrentMark* cm, CMTask* task) :
-_cm(cm), _task(task),
+_cm(cm), _task(task), _ref_counter_limit(G1RefProcDrainInterval) {
-_ref_counter_limit(G1RefProcDrainInterval) {
 assert(_ref_counter_limit > 0, "sanity");
 _ref_counter = _ref_counter_limit;
 }
 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
 _task->deal_with_reference(obj);
 _ref_counter--;
 if (_ref_counter == 0) {
-// We have dealt with _ref_counter_limit references, pushing them and objects
+// We have dealt with _ref_counter_limit references, pushing them
-// reachable from them on to the local stack (and possibly the global stack).
+// and objects reachable from them on to the local stack (and
-// Call do_marking_step() to process these entries. We call the routine in a
+// possibly the global stack). Call CMTask::do_marking_step() to
-// loop, which we'll exit if there's nothing more to do (i.e. we're done
+// process these entries.
-// with the entries that we've pushed as a result of the deal_with_reference
+//
-// calls above) or we overflow.
+// We call CMTask::do_marking_step() in a loop, which we'll exit if
-// Note: CMTask::do_marking_step() can set the CMTask::has_aborted() flag
+// there's nothing more to do (i.e. we're done with the entries that
-// while there may still be some work to do. (See the comment at the
+// were pushed as a result of the CMTask::deal_with_reference() calls
-// beginning of CMTask::do_marking_step() for those conditions - one of which
+// above) or we overflow.
-// is reaching the specified time target.) It is only when
+//
-// CMTask::do_marking_step() returns without setting the has_aborted() flag
+// Note: CMTask::do_marking_step() can set the CMTask::has_aborted()
-// that the marking has completed.
+// flag while there may still be some work to do. (See the comment at
+// the beginning of CMTask::do_marking_step() for those conditions -
+// one of which is reaching the specified time target.) It is only
+// when CMTask::do_marking_step() returns without setting the
+// has_aborted() flag that the marking step has completed.
 do {
 double mark_step_duration_ms = G1ConcMarkStepDurationMillis;
 _task->do_marking_step(mark_step_duration_ms,
 false /* do_stealing    */,
 false /* do_termination */);
 }
 }
 }
 };
-class G1CMParDrainMarkingStackClosure: public VoidClosure {
+// 'Drain' oop closure used by both serial and parallel reference processing.
+// Uses the CMTask associated with a given worker thread (for serial
+// reference processing the CMtask for worker 0 is used). Calls the
+// do_marking_step routine, with an unbelievably large timeout value,
+// to drain the marking data structures of the remaining entries
+// added by the 'keep alive' oop closure above.
+class G1CMDrainMarkingStackClosure: public VoidClosure {
 ConcurrentMark* _cm;
-CMTask* _task;
+CMTask*         _task;
+bool            _do_stealing;
+bool            _do_termination;
 public:
-G1CMParDrainMarkingStackClosure(ConcurrentMark* cm, CMTask* task) :
+G1CMDrainMarkingStackClosure(ConcurrentMark* cm, CMTask* task, bool is_par) :
-_cm(cm), _task(task) { }
+_cm(cm), _task(task) {
+assert(is_par || _task->worker_id() == 0,
+"Only task for worker 0 should be used if ref processing is single threaded");
+// We only allow stealing and only enter the termination protocol
+// in CMTask::do_marking_step() if this closure is being instantiated
+// for parallel reference processing.
+_do_stealing = _do_termination = is_par;
+}
 void do_void() {
 do {
 if (_cm->verbose_high()) {
-gclog_or_tty->print_cr("\t[%u] Drain: Calling do marking_step",
+gclog_or_tty->print_cr("\t[%u] Drain: Calling do_marking_step - "
-_task->worker_id());
+"stealing: %s, termination: %s",
+_task->worker_id(),
+BOOL_TO_STR(_do_stealing),
+BOOL_TO_STR(_do_termination));
 }
-// We call CMTask::do_marking_step() to completely drain the local and
+// We call CMTask::do_marking_step() to completely drain the local
-// global marking stacks. The routine is called in a loop, which we'll
+// and global marking stacks of entries pushed by the 'keep alive'
-// exit if there's nothing more to do (i.e. we'completely drained the
+// oop closure (an instance of G1CMKeepAliveAndDrainClosure above).
-// entries that were pushed as a result of applying the
+//
-// G1CMParKeepAliveAndDrainClosure to the entries on the discovered ref
+// CMTask::do_marking_step() is called in a loop, which we'll exit
-// lists above) or we overflow the global marking stack.
+// if there's nothing more to do (i.e. we'completely drained the
-// Note: CMTask::do_marking_step() can set the CMTask::has_aborted() flag
+// entries that were pushed as a a result of applying the 'keep alive'
-// while there may still be some work to do. (See the comment at the
+// closure to the entries on the discovered ref lists) or we overflow
-// beginning of CMTask::do_marking_step() for those conditions - one of which
+// the global marking stack.
-// is reaching the specified time target.) It is only when
+//
-// CMTask::do_marking_step() returns without setting the has_aborted() flag
+// Note: CMTask::do_marking_step() can set the CMTask::has_aborted()
-// that the marking has completed.
+// flag while there may still be some work to do. (See the comment at
+// the beginning of CMTask::do_marking_step() for those conditions -
+// one of which is reaching the specified time target.) It is only
+// when CMTask::do_marking_step() returns without setting the
+// has_aborted() flag that the marking step has completed.
 _task->do_marking_step(1000000000.0 /* something very large */,
-true /* do_stealing    */,
+_do_stealing,
-true /* do_termination */);
+_do_termination);
 } while (_task->has_aborted() && !_cm->has_overflown());
 }
 };
 // Implementation of AbstractRefProcTaskExecutor for parallel
 class G1CMRefProcTaskProxy: public AbstractGangTask {
 typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask;
 ProcessTask&     _proc_task;
 G1CollectedHeap* _g1h;
 ConcurrentMark*  _cm;
+bool             _processing_is_mt;
 public:
 G1CMRefProcTaskProxy(ProcessTask& proc_task,
 G1CollectedHeap* g1h,
 ConcurrentMark* cm) :
 AbstractGangTask("Process reference objects in parallel"),
-_proc_task(proc_task), _g1h(g1h), _cm(cm) { }
+_proc_task(proc_task), _g1h(g1h), _cm(cm) {
+ReferenceProcessor* rp = _g1h->ref_processor_cm();
+_processing_is_mt = rp->processing_is_mt();
+}
 virtual void work(uint worker_id) {
 CMTask* marking_task = _cm->task(worker_id);
 G1CMIsAliveClosure g1_is_alive(_g1h);
-G1CMParKeepAliveAndDrainClosure g1_par_keep_alive(_cm, marking_task);
+G1CMKeepAliveAndDrainClosure g1_par_keep_alive(_cm, marking_task);
-G1CMParDrainMarkingStackClosure g1_par_drain(_cm, marking_task);
+G1CMDrainMarkingStackClosure g1_par_drain(_cm, marking_task, _processing_is_mt);
 _proc_task.work(worker_id, g1_is_alive, g1_par_keep_alive, g1_par_drain);
 }
 };
 void G1CMRefProcTaskExecutor::execute(ProcessTask& proc_task) {
 assert(_workers != NULL, "Need parallel worker threads.");
+assert(_g1h->ref_processor_cm()->processing_is_mt(), "processing is not MT");
 G1CMRefProcTaskProxy proc_task_proxy(proc_task, _g1h, _cm);
 // We need to reset the phase for each task execution so that
 // the termination protocol of CMTask::do_marking_step works.
 }
 };
 void G1CMRefProcTaskExecutor::execute(EnqueueTask& enq_task) {
 assert(_workers != NULL, "Need parallel worker threads.");
+assert(_g1h->ref_processor_cm()->processing_is_mt(), "processing is not MT");
 G1CMRefEnqueueTaskProxy enq_task_proxy(enq_task);
 _g1h->set_par_threads(_active_workers);
 _workers->run_task(&enq_task_proxy);
 ReferenceProcessor* rp = g1h->ref_processor_cm();
 // See the comment in G1CollectedHeap::ref_processing_init()
 // about how reference processing currently works in G1.
-// Process weak references.
+// Set the soft reference policy
 rp->setup_policy(clear_all_soft_refs);
 assert(_markStack.isEmpty(), "mark stack should be empty");
-G1CMKeepAliveClosure g1_keep_alive(g1h, this);
+// Non-MT instances 'Keep Alive' and 'Complete GC' oop closures.
-G1CMDrainMarkingStackClosure
+G1CMKeepAliveAndDrainClosure g1_keep_alive(this, task(0));
-g1_drain_mark_stack(this, &_markStack, &g1_keep_alive);
+G1CMDrainMarkingStackClosure g1_drain_mark_stack(this, task(0), false);
-// We use the work gang from the G1CollectedHeap and we utilize all
+// We need at least one active thread. If reference processing is
-// the worker threads.
+// not multi-threaded we use the current (ConcurrentMarkThread) thread,
-uint active_workers = g1h->workers() ? g1h->workers()->active_workers() : 1U;
+// otherwise we use the work gang from the G1CollectedHeap and we
+// utilize all the worker threads we can.
+uint active_workers = (rp->processing_is_mt() && g1h->workers() != NULL
+? g1h->workers()->active_workers()
+: 1U);
 active_workers = MAX2(MIN2(active_workers, _max_worker_id), 1U);
 G1CMRefProcTaskExecutor par_task_executor(g1h, this,
 g1h->workers(), active_workers);
-if (rp->processing_is_mt()) {
+AbstractRefProcTaskExecutor* executor = (rp->processing_is_mt()
-// Set the degree of MT here.  If the discovery is done MT, there
+? &par_task_executor
-// may have been a different number of threads doing the discovery
+: NULL);
-// and a different number of discovered lists may have Ref objects.
-// That is OK as long as the Reference lists are balanced (see
+// Set the degree of MT processing here.  If the discovery was done MT,
-// balance_all_queues() and balance_queues()).
+// the number of threads involved during discovery could differ from
-rp->set_active_mt_degree(active_workers);
+// the number of active workers.  This is OK as long as the discovered
+// Reference lists are balanced (see balance_all_queues() and balance_queues()).
-rp->process_discovered_references(&g1_is_alive,
+rp->set_active_mt_degree(active_workers);
+// Process the weak references.
+rp->process_discovered_references(&g1_is_alive,
 &g1_keep_alive,
 &g1_drain_mark_stack,
-&par_task_executor);
+executor);
-// The work routines of the parallel keep_alive and drain_marking_stack
+// The do_oop work routines of the keep_alive and drain_marking_stack
-// will set the has_overflown flag if we overflow the global marking
+// oop closures will set the has_overflown flag if we overflow the
-// stack.
+// global marking stack.
-} else {
-rp->process_discovered_references(&g1_is_alive,
-&g1_keep_alive,
-&g1_drain_mark_stack,
-NULL);
-}
 assert(_markStack.overflow() || _markStack.isEmpty(),
 "mark stack should be empty (unless it overflowed)");
 if (_markStack.overflow()) {
-// Should have been done already when we tried to push an
+// This should have been done already when we tried to push an
 // entry on to the global mark stack. But let's do it again.
 set_has_overflown();
 }
-if (rp->processing_is_mt()) {
+assert(rp->num_q() == active_workers, "why not");
-assert(rp->num_q() == active_workers, "why not");
-rp->enqueue_discovered_references(&par_task_executor);
+rp->enqueue_discovered_references(executor);
-} else {
-rp->enqueue_discovered_references();
-}
 rp->verify_no_references_recorded();
 assert(!rp->discovery_enabled(), "Post condition");
 }
 cmThread()->vtime_accum(),
 cmThread()->vtime_mark_accum());
 }
 void ConcurrentMark::print_worker_threads_on(outputStream* st) const {
-_parallel_workers->print_worker_threads_on(st);
+if (use_parallel_marking_threads()) {
+_parallel_workers->print_worker_threads_on(st);
+}
 }
 // We take a break if someone is trying to stop the world.
 bool ConcurrentMark::do_yield_check(uint worker_id) {
 if (should_yield()) {
 MemRegion mr = MemRegion(_finger, _region_limit);
 if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%u] we're scanning part "
 "["PTR_FORMAT", "PTR_FORMAT") "
-"of region "PTR_FORMAT,
+"of region "HR_FORMAT,
-_worker_id, _finger, _region_limit, _curr_region);
+_worker_id, _finger, _region_limit,
+HR_FORMAT_PARAMS(_curr_region));
 }
-// Let's iterate over the bitmap of the part of the
+assert(!_curr_region->isHumongous() || mr.start() == _curr_region->bottom(),
-// region that is left.
+"humongous regions should go around loop once only");
-if (mr.is_empty() || _nextMarkBitMap->iterate(&bitmap_closure, mr)) {
-// We successfully completed iterating over the region. Now,
+// Some special cases:
-// let's give up the region.
+// If the memory region is empty, we can just give up the region.
+// If the current region is humongous then we only need to check
+// the bitmap for the bit associated with the start of the object,
+// scan the object if it's live, and give up the region.
+// Otherwise, let's iterate over the bitmap of the part of the region
+// that is left.
+// If the iteration is successful, give up the region.
+if (mr.is_empty()) {
+giveup_current_region();
+regular_clock_call();
+} else if (_curr_region->isHumongous() && mr.start() == _curr_region->bottom()) {
+if (_nextMarkBitMap->isMarked(mr.start())) {
+// The object is marked - apply the closure
+BitMap::idx_t offset = _nextMarkBitMap->heapWordToOffset(mr.start());
+bitmap_closure.do_bit(offset);
+}
+// Even if this task aborted while scanning the humongous object
+// we can (and should) give up the current region.
+giveup_current_region();
+regular_clock_call();
+} else if (_nextMarkBitMap->iterate(&bitmap_closure, mr)) {
 giveup_current_region();
 regular_clock_call();
 } else {
 assert(has_aborted(), "currently the only way to do so");
 // The only way to abort the bitmap iteration is to return

Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 8506:c3657d00e343