jdk-sandbox: comparison hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp

equal deleted inserted replaced

-:af2bc14f35f8
+:fccee5238e70
 double* data) {
 double min = data[0], max = data[0];
 double total = 0.0;
 LineBuffer buf(level);
 buf.append("[%s (ms):", str);
-for (uint i = 0; i < ParallelGCThreads; ++i) {
+for (uint i = 0; i < no_of_gc_threads(); ++i) {
 double val = data[i];
 if (val < min)
 min = val;
 if (val > max)
 max = val;
 total += val;
 buf.append("  %3.1lf", val);
 }
 buf.append_and_print_cr("");
-double avg = total / (double) ParallelGCThreads;
+double avg = total / (double) no_of_gc_threads();
 buf.append_and_print_cr(" Avg: %5.1lf, Min: %5.1lf, Max: %5.1lf, Diff: %5.1lf]",
 avg, min, max, max - min);
 }
 void G1CollectorPolicy::print_par_sizes(int level,
 double* data) {
 double min = data[0], max = data[0];
 double total = 0.0;
 LineBuffer buf(level);
 buf.append("[%s :", str);
-for (uint i = 0; i < ParallelGCThreads; ++i) {
+for (uint i = 0; i < no_of_gc_threads(); ++i) {
 double val = data[i];
 if (val < min)
 min = val;
 if (val > max)
 max = val;
 total += val;
 buf.append(" %d", (int) val);
 }
 buf.append_and_print_cr("");
-double avg = total / (double) ParallelGCThreads;
+double avg = total / (double) no_of_gc_threads();
 buf.append_and_print_cr(" Sum: %d, Avg: %d, Min: %d, Max: %d, Diff: %d]",
 (int)total, (int)avg, (int)min, (int)max, (int)max - (int)min);
 }
 void G1CollectorPolicy::print_stats(int level,
 }
 double G1CollectorPolicy::avg_value(double* data) {
 if (G1CollectedHeap::use_parallel_gc_threads()) {
 double ret = 0.0;
-for (uint i = 0; i < ParallelGCThreads; ++i) {
+for (uint i = 0; i < no_of_gc_threads(); ++i) {
 ret += data[i];
 }
-return ret / (double) ParallelGCThreads;
+return ret / (double) no_of_gc_threads();
 } else {
 return data[0];
 }
 }
 double G1CollectorPolicy::max_value(double* data) {
 if (G1CollectedHeap::use_parallel_gc_threads()) {
 double ret = data[0];
-for (uint i = 1; i < ParallelGCThreads; ++i) {
+for (uint i = 1; i < no_of_gc_threads(); ++i) {
 if (data[i] > ret) {
 ret = data[i];
 }
 }
 return ret;
 }
 double G1CollectorPolicy::sum_of_values(double* data) {
 if (G1CollectedHeap::use_parallel_gc_threads()) {
 double sum = 0.0;
-for (uint i = 0; i < ParallelGCThreads; i++) {
+for (uint i = 0; i < no_of_gc_threads(); i++) {
 sum += data[i];
 }
 return sum;
 } else {
 return data[0];
 double G1CollectorPolicy::max_sum(double* data1, double* data2) {
 double ret = data1[0] + data2[0];
 if (G1CollectedHeap::use_parallel_gc_threads()) {
-for (uint i = 1; i < ParallelGCThreads; ++i) {
+for (uint i = 1; i < no_of_gc_threads(); ++i) {
 double data = data1[i] + data2[i];
 if (data > ret) {
 ret = data;
 }
 }
 }
 // Anything below that is considered to be zero
 #define MIN_TIMER_GRANULARITY 0.0000001
-void G1CollectorPolicy::record_collection_pause_end() {
+void G1CollectorPolicy::record_collection_pause_end(int no_of_gc_threads) {
 double end_time_sec = os::elapsedTime();
 double elapsed_ms = _last_pause_time_ms;
 bool parallel = G1CollectedHeap::use_parallel_gc_threads();
 assert(_cur_collection_pause_used_regions_at_start >= cset_region_length(),
 "otherwise, the subtraction below does not make sense");
 _cur_collection_pause_used_regions_at_start - cset_region_length();
 size_t cur_used_bytes = _g1->used();
 assert(cur_used_bytes == _g1->recalculate_used(), "It should!");
 bool last_pause_included_initial_mark = false;
 bool update_stats = !_g1->evacuation_failed();
+set_no_of_gc_threads(no_of_gc_threads);
 #ifndef PRODUCT
 if (G1YoungSurvRateVerbose) {
 gclog_or_tty->print_cr("");
 _short_lived_surv_rate_group->print();
 void work(int i) {
 ParKnownGarbageHRClosure parKnownGarbageCl(_hrSorted, _chunk_size, i);
 // Back to zero for the claim value.
 _g1->heap_region_par_iterate_chunked(&parKnownGarbageCl, i,
+_g1->workers()->active_workers(),
 HeapRegion::InitialClaimValue);
 jint regions_added = parKnownGarbageCl.marked_regions_added();
 _hrSorted->incNumMarkedHeapRegions(regions_added);
 if (G1PrintParCleanupStats) {
 gclog_or_tty->print_cr("     Thread %d called %d times, added %d regions to list.",
 }
 }
 };
 void
-G1CollectorPolicy::record_concurrent_mark_cleanup_end() {
+G1CollectorPolicy::record_concurrent_mark_cleanup_end(int no_of_gc_threads) {
 double start_sec;
 if (G1PrintParCleanupStats) {
 start_sec = os::elapsedTime();
 }
 (clear_marked_end_sec - start_sec) * 1000.0);
 }
 if (G1CollectedHeap::use_parallel_gc_threads()) {
 const size_t OverpartitionFactor = 4;
-const size_t MinWorkUnit = 8;
+size_t WorkUnit;
-const size_t WorkUnit =
+// The use of MinChunkSize = 8 in the original code
-MAX2(_g1->n_regions() / (ParallelGCThreads * OverpartitionFactor),
+// causes some assertion failures when the total number of
-MinWorkUnit);
+// region is less than 8.  The code here tries to fix that.
+// Should the original code also be fixed?
+if (no_of_gc_threads > 0) {
+const size_t MinWorkUnit =
+MAX2(_g1->n_regions() / no_of_gc_threads, (size_t) 1U);
+WorkUnit =
+MAX2(_g1->n_regions() / (no_of_gc_threads * OverpartitionFactor),
+MinWorkUnit);
+} else {
+assert(no_of_gc_threads > 0,
+"The active gc workers should be greater than 0");
+// In a product build do something reasonable to avoid a crash.
+const size_t MinWorkUnit =
+MAX2(_g1->n_regions() / ParallelGCThreads, (size_t) 1U);
+WorkUnit =
+MAX2(_g1->n_regions() / (ParallelGCThreads * OverpartitionFactor),
+MinWorkUnit);
+}
 _collectionSetChooser->prepareForAddMarkedHeapRegionsPar(_g1->n_regions(),
 WorkUnit);
 ParKnownGarbageTask parKnownGarbageTask(_collectionSetChooser,
 (int) WorkUnit);
 _g1->workers()->run_task(&parKnownGarbageTask);

changeset 11174	fccee5238e70
parent 11169	0cfe4d79060c
child 11175	7fde26aecbe5