jdk8-mips64-public/hotspot: comparison src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp

-:f90c822e73f8
+:2d8a650513c2
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */
+/*
+* This file has been modified by Loongson Technology in 2015. These
+* modifications are Copyright (c) 2015 Loongson Technology, and are made
+* available on the same license terms set forth above.
+*/
 #include "precompiled.hpp"
 #include "classfile/symbolTable.hpp"
 #include "code/codeCache.hpp"
 #include "gc_implementation/parallelScavenge/cardTableExtension.hpp"
 #include "gc_implementation/parallelScavenge/gcTaskManager.hpp"
 #include "gc_implementation/shared/gcHeapSummary.hpp"
 #include "gc_implementation/shared/gcTimer.hpp"
 #include "gc_implementation/shared/gcTrace.hpp"
 #include "gc_implementation/shared/gcTraceTime.hpp"
 #include "gc_implementation/shared/isGCActiveMark.hpp"
+#include "gc_implementation/shared/mutableNUMASpace.hpp"
 #include "gc_implementation/shared/spaceDecorator.hpp"
 #include "gc_interface/gcCause.hpp"
 #include "memory/collectorPolicy.hpp"
 #include "memory/gcLocker.inline.hpp"
 #include "memory/referencePolicy.hpp"
 PSAdaptiveSizePolicy* policy = heap->size_policy();
 IsGCActiveMark mark;
 const bool scavenge_done = PSScavenge::invoke_no_policy();
-const bool need_full_gc = !scavenge_done ||
+bool need_full_gc;
-policy->should_full_GC(heap->old_gen()->free_in_bytes());
+if(UseOldNUMA) {
+need_full_gc = !scavenge_done ||
+policy->should_full_GC(heap->old_gen()->free_in_bytes_numa());
+}
+else {
+need_full_gc = !scavenge_done ||
+policy->should_full_GC(heap->old_gen()->free_in_bytes());
+}
 bool full_gc_done = false;
 if (UsePerfData) {
 PSGCAdaptivePolicyCounters* const counters = heap->gc_policy_counters();
 const int ffs_val = need_full_gc ? full_follows_scavenge : not_skipped;
 }
 }
 return full_gc_done;
 }
+/* 2014/7/7 Liao: Add these variables to stastic detail information during GC. */
+/* Used for objects copy stastic. */
+float each_gc_copy_time[16];
+int   each_gc_copy_fre[16];
+/* Used for GC details stastic. */
+float total_gc_time = 0;
+int   total_gc_fre  = 0;
+/* Used to statstic ThreadRoots optimization. */
+int task_tag[16];
+//Used to stastic each cpu
+int each_total_num[16];
+int each_eden_total_num[3][16];
+int each_eden_aligned_num[3][16];
+//Used to stastic every GC
+int every_total_num;
+int every_eden_total_num[3];
+int every_eden_aligned_num[3];
+//Used to stastic all the time
+int all_total_num;
+int all_eden_total_num[3];
+int all_eden_aligned_num[3];
 // This method contains no policy. You should probably
 // be calling invoke() instead.
 bool PSScavenge::invoke_no_policy() {
 assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");
 if (ZapUnusedHeapArea) {
 // Save information needed to minimize mangling
 heap->record_gen_tops_before_GC();
 }
+if(UseStasticCopy) {
+for(uint i = 0; i < ParallelGCThreads; i++) {
+each_gc_copy_time[i] = 0;
+each_gc_copy_fre[i] = 0;
+}
+}
+if(UseStasticScavenge) {
+for(int j = 0; j < 3; j++) {
+for(uint i = 0; i < ParallelGCThreads; i++) {
+task_tag[i] = 0;
+each_total_num[i] = 0;
+each_eden_total_num[j][i] = 0;
+each_eden_aligned_num[j][i] = 0;
+every_total_num = 0;
+every_eden_total_num[j]  = 0;
+every_eden_aligned_num[j] = 0;
+}
+}
+}
 heap->print_heap_before_gc();
 heap->trace_heap_before_gc(&_gc_tracer);
 assert(!NeverTenure || _tenuring_threshold == markOopDesc::max_age + 1, "Sanity");
 assert(!AlwaysTenure || _tenuring_threshold == 0, "Sanity");
 GCTraceTime tm("Scavenge", false, false, &_gc_timer);
 ParallelScavengeHeap::ParStrongRootsScope psrs;
 GCTaskQueue* q = GCTaskQueue::create();
-if (!old_gen->object_space()->is_empty()) {
+if(UseOldNUMA) {
-// There are only old-to-young pointers if there are objects
+MutableSpace* sp;
-// in the old gen.
+MutableNUMASpace::LGRPSpace *ls;
-uint stripe_total = active_workers;
+MutableNUMASpace* s = (MutableNUMASpace*) old_gen->object_space();
-for(uint i=0; i < stripe_total; i++) {
+int i, j;
-q->enqueue(new OldToYoungRootsTask(old_gen, old_top, i, stripe_total));
+i = s->lgrp_spaces()->length();
+HeapWord** gen_top = (HeapWord**) malloc (i * sizeof(HeapWord));
+for(j = 0; j < i; j++) {
+ls = s->lgrp_spaces()->at(j);
+sp = ls->space();
+*(gen_top + j) = sp->top();
+}
+if (!old_gen->object_space()->is_empty()) {
+uint stripe_total = active_workers;
+for(uint i=0; i < stripe_total; i++) {
+q->enqueue(new OldToYoungRootsTask_OldNUMA(old_gen, gen_top, i, stripe_total));
+}
+}
+}
+else {
+if (!old_gen->object_space()->is_empty()) {
+// There are only old-to-young pointers if there are objects
+// in the old gen.
+uint stripe_total = active_workers;
+for(uint i=0; i < stripe_total; i++) {
+q->enqueue(new OldToYoungRootsTask(old_gen, old_top, i, stripe_total));
+}
 }
 }
 q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::universe));
 q->enqueue(new ScavengeRootsTask(ScavengeRootsTask::jni_handles));
 tty->print_cr("VM-Thread " INT64_FORMAT " " INT64_FORMAT " " INT64_FORMAT,
 scavenge_entry.ticks(), scavenge_midpoint.ticks(),
 scavenge_exit.ticks());
 gc_task_manager()->print_task_time_stamps();
 }
+if(PrintGCDetails) {
+float young_gc_time;
+total_gc_fre++;
+young_gc_time = ((float)(scavenge_exit.ticks() - scavenge_entry.ticks()))/1e9;
+total_gc_time = total_gc_time + ((float)(scavenge_exit.ticks() - scavenge_entry.ticks()))/1e9;
+tty->print_cr("total_gc_fre = %d, young_gc_time = %f, total_gc_time = %f", total_gc_fre, young_gc_time, total_gc_time);
+}
+if(UseStasticCopy) {
+for(uint i = 0; i < ParallelGCThreads; i++) {
+tty->print_cr("each_gc_copy_time[%d] = %f", i, each_gc_copy_time[i]/each_gc_copy_fre[i]);
+}
+tty->print_cr("");
+for(uint i = 0; i < ParallelGCThreads; i++) {
+tty->print_cr("each_gc_copy_fre[%d] = %d", i, each_gc_copy_fre[i]);
+}
+}
+if(UseStasticScavenge) {
+for(int i = 0; i < 3; i++) {
+for(uint j = 0; j < ParallelGCThreads; j++) {
+every_eden_total_num[i] += each_eden_total_num[i][j];
+every_eden_aligned_num[i] += each_eden_aligned_num[i][j];
+}
+}
+for(uint i = 0; i < ParallelGCThreads; i++) {
+every_total_num += each_total_num[i];
+}
+all_total_num += every_total_num;
+for(int i = 0; i < 3; i++) {
+all_eden_total_num[i] +=  every_eden_total_num[i];
+all_eden_aligned_num[i] += every_eden_aligned_num[i];
+}
+tty->print_cr("============= Every GCDetails: =============");
+tty->print_cr("ThreadRootTask: prop of all = %f, prop of aligned = %f", (float)every_eden_total_num[0]/(float)every_total_num, (float)every_eden_aligned_num[0]/(float)every_eden_total_num[0]);
+tty->print_cr("OldToYoungRootTask: prop of all = %f, prop of aligned = %f", (float)every_eden_total_num[1]/(float)every_total_num, (float)every_eden_aligned_num[1]/(float)every_eden_total_num[1]);
+tty->print_cr("StealTask: prop of all = %f, prop of aligned = %f", (float)every_eden_total_num[2]/(float)every_total_num, (float)every_eden_aligned_num[2]/(float)every_eden_total_num[2]);
+tty->print_cr("");
+tty->print_cr("============= Total GCDetails: =============");
+tty->print_cr("ThreadRootTask: prop of all = %f, prop of aligned = %f", (float)all_eden_total_num[0]/(float)all_total_num, (float)all_eden_aligned_num[0]/(float)all_eden_total_num[0]);
+tty->print_cr("OldToYoungRootTask: prop of all = %f, prop of aligned = %f", (float)all_eden_total_num[1]/(float)all_total_num, (float)all_eden_aligned_num[1]/(float)all_eden_total_num[1]);
+tty->print_cr("StealTask: prop of all = %f, prop of aligned = %f", (float)all_eden_total_num[2]/(float)all_total_num, (float)all_eden_aligned_num[2]/(float)all_eden_total_num[2]);
+tty->print_cr("");
+}
 #ifdef TRACESPINNING
 ParallelTaskTerminator::print_termination_counts();
 #endif

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

comparison: src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp

src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp