Lines Matching defs:work
16 * 2 along with this work; if not, write to the Free Software Foundation,
88 // phases of the CMS thread's work do not block out the VM thread
434 // We add "gc0_period" to the "work" calculation
441 double work = cms_duration() + gc0_period();
445 if (work > deadline) {
454 return work - deadline;
1595 // which works, even if not optimum in terms of concurrent work.
1596 // As a work around for too eagerly collecting, use the flag
1932 // A work method used by foreground collection to determine
1970 // that there's little point in saving that work. Compaction
1994 // A work method used by the foreground collector to do
2105 // A work method used by the foreground collector to do
2128 // it is not done concurrently and there is extra work
2639 // some "local" work to a worker method in the individual generations
2641 // work common to all generations it's responsible for. A similar
2665 // ignore it since all relevant work has already been done.
2742 // ignore it since all relevant work has already been done.
3531 // CMS work
3760 // "queue_set" is a set of work queues of other threads.
3797 // The per thread work queues, available here for stealing
3841 void work(uint worker_id);
3852 assert(_global_finger >= _cms_space->end(), "Postcondition of ::work(i)");
3853 assert(_global_finger >= _perm_space->end(), "Postcondition of ::work(i)");
3899 // . else push on work-queue
3901 // . local work-queue overflow causes stuff to be pushed on
3903 // . always first empty local work queue
3904 // . then get a batch of oops from global work queue if any
3905 // . then do work stealing
3907 // and local work queue empty,
3914 void CMSConcMarkingTask::work(uint worker_id) {
3921 // Before we begin work, our work queue should be empty
3944 // ... do work stealing
3950 gclog_or_tty->print_cr("Finished work stealing in %dth thread: %3.3f sec",
3993 // Grab up to 1/4 the size of the work queue
4080 // Do the marking work within a non-empty span --
4135 // Grey object scanning during work stealing phase --
4152 // push on work queue (grey set)
4202 // workers from interfering with the work done below.
4225 // Can't assert below because the work obtained from the
4491 // If we are doing little work each iteration, we should
4494 // Sleep for some time, waiting for work to accumulate
4683 return cumNumCards; // as a measure of useful work done
5045 // If we encountered any (marking stack / work queue) overflow
5117 // The per-thread work queues, available here for stealing.
5123 // workers to be taken from the active workers in the work gang.
5143 void work(uint worker_id);
5155 // ... work stealing for the above
5164 void CMSParRemarkTask::work(uint worker_id) {
5180 // work first.
5203 "Finished young gen rescan work in %dth thread: %3.3f sec",
5225 "Finished remaining root rescan work in %dth thread: %3.3f sec",
5241 "Finished dirty card rescan work in %dth thread: %3.3f sec",
5245 // ---------- steal work from other threads ...
5253 "Finished work stealing in %dth thread: %3.3f sec",
5326 // the work method dirty_range_iterate_clear() in that it has
5335 // If the work code below is ever reorganized into a more chaotic
5336 // work-partitioning form than the current "sequential tasks"
5339 // bug 4756801 work on which should examine this code to make
5344 // more work chunks. Such objects would potentially be scanned
5413 // Completely finish any left over work from (an) earlier round(s)
5417 // Now check if there's any work in the overflow list
5419 // only affects the number of attempts made to get work from the
5426 // not yet ready to go stealing work from others.
5428 // because we just took work from the overflow list,
5434 // Verify that we have no work before we resort to stealing
5435 assert(work_q->size() == 0, "Have work, shouldn't steal");
5436 // Try to steal from other queues that have work
5441 // Do scanning work
5443 // Loop around, finish this work, and try to steal some more
5454 "Else our work is not yet done");
5547 // Set up the space's par_seq_tasks structure for work claiming
5622 // Set up for parallel process_strong_roots work.
5630 // The young gen rescan work will not be done as part of
5641 // The dirty card rescan work is broken up into a "sequence"
5647 // It turns out that even when we're using 1 thread, doing the work in a
5661 tsk.work(0);
5807 virtual void work(uint worker_id);
5810 void CMSRefProcTaskProxy::work(uint worker_id) {
5821 _task.work(worker_id, is_alive_closure, par_keep_alive, par_drain_stack);
5840 virtual void work(uint worker_id)
5842 _task.work(worker_id);
5868 // Completely finish any left over work from (an) earlier round(s)
5872 // Now check if there's any work in the overflow list
5874 // only affects the number of attempts made to get work from the
5881 // not yet ready to go stealing work from others.
5883 // because we just took work from the overflow list,
5888 // Verify that we have no work before we resort to stealing
5889 assert(work_q->size() == 0, "Have work, shouldn't steal");
5890 // Try to steal from other queues that have work
5895 // Do scanning work
5897 // Loop around, finish this work, and try to steal some more
6034 // work queue overflow
6462 assert(size >= 3, "Necessary for Printezis marks to work");
6475 assert(size >= 3, "Necessary for Printezis marks to work");
6886 // to the work queue (or overflow list).
6914 // We yielded for some foreground stop-world work,
6949 assert(size >= 3, "Necessary for Printezis marks to work");
7380 // Should we assert that our work queue is empty or
7471 // A variant of the above used for verifying CMS marking work.
7644 // workers from interfering with the work done below.
7706 // -- else push on work queue
7869 // push on work queue (grey set)
7999 // Assertion checking only: no useful work in product mode --
8233 // All the work is done in
8412 assert(size >= 3, "Necessary for Printezis marks to work");
8707 // The work queues are private to each closure (thread),
8920 assert(work_q->size() == 0, "First empty local work queue");
9115 // until all work's been completed. Because we