gc/cms/concurrentMarkSweepGeneration.cpp

16  * 2 along with this work; if not, write to the Free Software Foundation,
102 // phases of the CMS thread's work do not block out the VM thread
393   // We add "gc0_period" to the "work" calculation
400   double work = cms_duration() + gc0_period();
404   if (work > deadline) {
409   return work - deadline;
1228 // which works, even if not optimum in terms of concurrent work.
1229 // As a work around for too eagerly collecting, use the flag
1518 // A work method used by the foreground collector to do
1981 // some "local" work to a worker method in the individual generations
1983 // work common to all generations it's responsible for. A similar
2007     // ignore it since all relevant work has already been done.
2098     // ignore it since all relevant work has already been done.
2333   // Get a clear set of claim bits for the roots processing to work with.
2403   // Get a clear set of claim bits for the roots processing to work with.
2771 // CMS work
2796   void work(uint worker_id);
2888         tsk.work(0);
2994   // "queue_set" is a set of work queues of other threads.
3029   // The per thread work queues, available here for stealing
3068   void work(uint worker_id);
3078     assert(_global_finger >= _cms_space->end(),  "Postcondition of ::work(i)");
3123 //    . else push on work-queue
3125 //    . local work-queue overflow causes stuff to be pushed on
3127 //    . always first empty local work queue
3128 //    . then get a batch of oops from global work queue if any
3129 //    . then do work stealing
3131 //    and local work queue empty,
3138 void CMSConcMarkingTask::work(uint worker_id) {
3145   // Before we begin work, our work queue should be empty
3153   // ... do work stealing
3158   log_trace(gc, task)("Finished work stealing in %dth thread: %3.3f sec", worker_id, _timer.seconds());
3202   // Grab up to 1/4 the size of the work queue
3287         // Do the marking work within a non-empty span --
3344 // Grey object scanning during work stealing phase --
3361       // push on work queue (grey set)
3407   // workers from interfering with the work done below.
3429       // Can't assert below because the work obtained from the
3680       // If we are doing little work each iteration, we should
3683         // Sleep for some time, waiting for work to accumulate
3857   return cumNumCards;   // as a measure of useful work done
4208   // If we encountered any (marking stack / work queue) overflow
4257 void CMSParInitialMarkTask::work(uint worker_id) {
4271     log_trace(gc, task)("Finished young gen initial mark scan work in %dth thread: %3.3f sec", worker_id, _timer.seconds());
4290   log_trace(gc, task)("Finished remaining root initial mark scan work in %dth thread: %3.3f sec", worker_id, _timer.seconds());
4297   // The per-thread work queues, available here for stealing.
4304   // workers to be taken from the active workers in the work gang.
4324   void work(uint worker_id);
4331   // ... work stealing for the above
4382 void CMSParRemarkTask::work(uint worker_id) {
4398   // work first.
4403     log_trace(gc, task)("Finished young gen rescan work in %dth thread: %3.3f sec", worker_id, _timer.seconds());
4420   log_trace(gc, task)("Finished remaining root rescan work in %dth thread: %3.3f sec",  worker_id, _timer.seconds());
4439     log_trace(gc, task)("Finished unhandled CLD scanning work in %dth thread: %3.3f sec", worker_id, _timer.seconds());
4452     log_trace(gc, task)("Finished dirty klass scanning work in %dth thread: %3.3f sec", worker_id, _timer.seconds());
4470   log_trace(gc, task)("Finished dirty card rescan work in %dth thread: %3.3f sec", worker_id, _timer.seconds());
4472   // ---------- steal work from other threads ...
4478   log_trace(gc, task)("Finished work stealing in %dth thread: %3.3f sec", worker_id, _timer.seconds());
4550   // the work method dirty_range_iterate_clear() in that it has
4559   // If the work code below is ever reorganized into a more chaotic
4560   // work-partitioning form than the current "sequential tasks"
4563   // bug 4756801 work on which should examine this code to make
4568   // more work chunks. Such objects would potentially be scanned
4633     // Completely finish any left over work from (an) earlier round(s)
4637     // Now check if there's any work in the overflow list
4639     // only affects the number of attempts made to get work from the
4646       // not yet ready to go stealing work from others.
4648       // because we just took work from the overflow list,
4654     // Verify that we have no work before we resort to stealing
4655     assert(work_q->size() == 0, "Have work, shouldn't steal");
4656     // Try to steal from other queues that have work
4661       // Do scanning work
4663       // Loop around, finish this work, and try to steal some more
4670          "Else our work is not yet done");
4786 // Set up the space's par_seq_tasks structure for work claiming
4860   // The young gen rescan work will not be done as part of
4871   // The dirty card rescan work is broken up into a "sequence"
4876   // It turns out that even when we're using 1 thread, doing the work in a
4888     tsk.work(0);
5054   virtual void work(uint worker_id);
5057 void CMSRefProcTaskProxy::work(uint worker_id) {
5068   _task.work(worker_id, is_alive_closure, par_keep_alive, par_drain_stack);
5087   virtual void work(uint worker_id)
5089     _task.work(worker_id);
5113     // Completely finish any left over work from (an) earlier round(s)
5117     // Now check if there's any work in the overflow list
5119     // only affects the number of attempts made to get work from the
5126       // not yet ready to go stealing work from others.
5128       // because we just took work from the overflow list,
5133     // Verify that we have no work before we resort to stealing
5134     assert(work_q->size() == 0, "Have work, shouldn't steal");
5135     // Try to steal from other queues that have work
5140       // Do scanning work
5142       // Loop around, finish this work, and try to steal some more
5258   // work queue overflow
5602   assert(size >= 3, "Necessary for Printezis marks to work");
5615     assert(size >= 3, "Necessary for Printezis marks to work");
6035       // to the work queue (or overflow list).
6063     // We yielded for some foreground stop-world work,
6088         assert(size >= 3, "Necessary for Printezis marks to work");
6484   // Should we assert that our work queue is empty or
6568 // A variant of the above used for verifying CMS marking work.
6738   // workers from interfering with the work done below.
6797     // -- else push on work queue
6948       // push on work queue (grey set)
7057 // Assertion checking only:  no useful work in product mode --
7279     // All the work is done in
7360     assert(size >= 3, "Necessary for Printezis marks to work");
7638 // The work queues are private to each closure (thread),
7850   assert(work_q->size() == 0, "First empty local work queue");
8045 // until all work's been completed. Because we