9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
11 * version 2 for more details (a copy is included in the LICENSE file that
12 * accompanied this code).
13 *
14 * You should have received a copy of the GNU General Public License version
15 * 2 along with this work; if not, write to the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
17 *
18 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
19 * or visit www.oracle.com if you need additional information or have any
20 * questions.
21 *
22 */
23
24 #include "precompiled.hpp"
25 #include "aot/aotLoader.hpp"
26 #include "classfile/classLoaderDataGraph.hpp"
27 #include "classfile/stringTable.hpp"
28 #include "code/codeCache.hpp"
29 #include "gc/parallel/gcTaskManager.hpp"
30 #include "gc/parallel/parallelScavengeHeap.hpp"
31 #include "gc/parallel/psAdaptiveSizePolicy.hpp"
32 #include "gc/parallel/psClosure.inline.hpp"
33 #include "gc/parallel/psCompactionManager.hpp"
34 #include "gc/parallel/psMarkSweepProxy.hpp"
35 #include "gc/parallel/psParallelCompact.inline.hpp"
36 #include "gc/parallel/psPromotionManager.inline.hpp"
37 #include "gc/parallel/psRootType.inline.hpp"
38 #include "gc/parallel/psScavenge.inline.hpp"
39 #include "gc/shared/gcCause.hpp"
40 #include "gc/shared/gcHeapSummary.hpp"
41 #include "gc/shared/gcId.hpp"
42 #include "gc/shared/gcLocker.hpp"
43 #include "gc/shared/gcTimer.hpp"
44 #include "gc/shared/gcTrace.hpp"
45 #include "gc/shared/gcTraceTime.inline.hpp"
46 #include "gc/shared/isGCActiveMark.hpp"
47 #include "gc/shared/referencePolicy.hpp"
48 #include "gc/shared/referenceProcessor.hpp"
|
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
11 * version 2 for more details (a copy is included in the LICENSE file that
12 * accompanied this code).
13 *
14 * You should have received a copy of the GNU General Public License version
15 * 2 along with this work; if not, write to the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
17 *
18 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
19 * or visit www.oracle.com if you need additional information or have any
20 * questions.
21 *
22 */
23
24 #include "precompiled.hpp"
25 #include "aot/aotLoader.hpp"
26 #include "classfile/classLoaderDataGraph.hpp"
27 #include "classfile/stringTable.hpp"
28 #include "code/codeCache.hpp"
29 #include "gc/parallel/parallelScavengeHeap.hpp"
30 #include "gc/parallel/psAdaptiveSizePolicy.hpp"
31 #include "gc/parallel/psClosure.inline.hpp"
32 #include "gc/parallel/psCompactionManager.hpp"
33 #include "gc/parallel/psMarkSweepProxy.hpp"
34 #include "gc/parallel/psParallelCompact.inline.hpp"
35 #include "gc/parallel/psPromotionManager.inline.hpp"
36 #include "gc/parallel/psRootType.inline.hpp"
37 #include "gc/parallel/psScavenge.inline.hpp"
38 #include "gc/shared/gcCause.hpp"
39 #include "gc/shared/gcHeapSummary.hpp"
40 #include "gc/shared/gcId.hpp"
41 #include "gc/shared/gcLocker.hpp"
42 #include "gc/shared/gcTimer.hpp"
43 #include "gc/shared/gcTrace.hpp"
44 #include "gc/shared/gcTraceTime.inline.hpp"
45 #include "gc/shared/isGCActiveMark.hpp"
46 #include "gc/shared/referencePolicy.hpp"
47 #include "gc/shared/referenceProcessor.hpp"
|
534
535 reference_processor()->enable_discovery();
536 reference_processor()->setup_policy(false);
537
538 PreGCValues pre_gc_values(heap);
539
540 // Reset our survivor overflow.
541 set_survivor_overflow(false);
542
543 // We need to save the old top values before
544 // creating the promotion_manager. We pass the top
545 // values to the card_table, to prevent it from
546 // straying into the promotion labs.
547 HeapWord* old_top = old_gen->object_space()->top();
548
549 uint active_workers = ParallelScavengeHeap::heap()->workers().update_active_workers(WorkerPolicy::calc_active_workers(
550 ParallelScavengeHeap::heap()->workers().total_workers(),
551 ParallelScavengeHeap::heap()->workers().active_workers(),
552 Threads::number_of_non_daemon_threads()));
553
554 // Release all previously held resources
555 gc_task_manager()->release_all_resources();
556
557 // Set the number of GC threads to be used in this collection
558 gc_task_manager()->set_active_gang();
559 gc_task_manager()->task_idle_workers();
560
561 assert(active_workers == gc_task_manager()->active_workers(), "sanity, taskmanager and workgang ought to agree");
562
563 PSPromotionManager::pre_scavenge();
564
565 // We'll use the promotion manager again later.
566 PSPromotionManager* promotion_manager = PSPromotionManager::vm_thread_promotion_manager();
567 {
568 GCTraceTime(Debug, gc, phases) tm("Scavenge", &_gc_timer);
569
570 ScavengeRootsTask task(old_gen, old_top, active_workers, old_gen->object_space()->is_empty());
571 ParallelScavengeHeap::heap()->workers().run_task(&task);
572 }
573
574 scavenge_midpoint.update();
575
576 // Process reference objects discovered during scavenge
577 {
578 GCTraceTime(Debug, gc, phases) tm("Reference Processing", &_gc_timer);
579
580 reference_processor()->setup_policy(false); // not always_clear
581 reference_processor()->set_active_mt_degree(active_workers);
|
533
534 reference_processor()->enable_discovery();
535 reference_processor()->setup_policy(false);
536
537 PreGCValues pre_gc_values(heap);
538
539 // Reset our survivor overflow.
540 set_survivor_overflow(false);
541
542 // We need to save the old top values before
543 // creating the promotion_manager. We pass the top
544 // values to the card_table, to prevent it from
545 // straying into the promotion labs.
546 HeapWord* old_top = old_gen->object_space()->top();
547
548 uint active_workers = ParallelScavengeHeap::heap()->workers().update_active_workers(WorkerPolicy::calc_active_workers(
549 ParallelScavengeHeap::heap()->workers().total_workers(),
550 ParallelScavengeHeap::heap()->workers().active_workers(),
551 Threads::number_of_non_daemon_threads()));
552
553 PSPromotionManager::pre_scavenge();
554
555 // We'll use the promotion manager again later.
556 PSPromotionManager* promotion_manager = PSPromotionManager::vm_thread_promotion_manager();
557 {
558 GCTraceTime(Debug, gc, phases) tm("Scavenge", &_gc_timer);
559
560 ScavengeRootsTask task(old_gen, old_top, active_workers, old_gen->object_space()->is_empty());
561 ParallelScavengeHeap::heap()->workers().run_task(&task);
562 }
563
564 scavenge_midpoint.update();
565
566 // Process reference objects discovered during scavenge
567 {
568 GCTraceTime(Debug, gc, phases) tm("Reference Processing", &_gc_timer);
569
570 reference_processor()->setup_policy(false); // not always_clear
571 reference_processor()->set_active_mt_degree(active_workers);
|
764
765 // Verify all old -> young cards are now precise
766 if (VerifyRememberedSets) {
767 // Precise verification will give false positives. Until this is fixed,
768 // use imprecise verification.
769 // heap->card_table()->verify_all_young_refs_precise();
770 heap->card_table()->verify_all_young_refs_imprecise();
771 }
772
773 if (log_is_enabled(Debug, gc, heap, exit)) {
774 accumulated_time()->stop();
775 }
776
777 young_gen->print_used_change(pre_gc_values.young_gen_used());
778 old_gen->print_used_change(pre_gc_values.old_gen_used());
779 MetaspaceUtils::print_metaspace_change(pre_gc_values.metadata_used());
780
781 // Track memory usage and detect low memory
782 MemoryService::track_memory_usage();
783 heap->update_counters();
784
785 gc_task_manager()->release_idle_workers();
786 }
787
788 if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) {
789 HandleMark hm; // Discard invalid handles created during verification
790 Universe::verify("After GC");
791 }
792
793 heap->print_heap_after_gc();
794 heap->trace_heap_after_gc(&_gc_tracer);
795
796 scavenge_exit.update();
797
798 log_debug(gc, task, time)("VM-Thread " JLONG_FORMAT " " JLONG_FORMAT " " JLONG_FORMAT,
799 scavenge_entry.ticks(), scavenge_midpoint.ticks(),
800 scavenge_exit.ticks());
801 gc_task_manager()->print_task_time_stamps();
802
803 #ifdef TRACESPINNING
804 ParallelTaskTerminator::print_termination_counts();
805 #endif
806
807 AdaptiveSizePolicyOutput::print(size_policy, heap->total_collections());
808
809 _gc_timer.register_gc_end();
810
811 _gc_tracer.report_gc_end(_gc_timer.gc_end(), _gc_timer.time_partitions());
812
813 return !promotion_failure_occurred;
814 }
815
816 // This method iterates over all objects in the young generation,
817 // removing all forwarding references. It then restores any preserved marks.
818 void PSScavenge::clean_up_failed_promotion() {
819 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
820 PSYoungGen* young_gen = heap->young_gen();
|
754
755 // Verify all old -> young cards are now precise
756 if (VerifyRememberedSets) {
757 // Precise verification will give false positives. Until this is fixed,
758 // use imprecise verification.
759 // heap->card_table()->verify_all_young_refs_precise();
760 heap->card_table()->verify_all_young_refs_imprecise();
761 }
762
763 if (log_is_enabled(Debug, gc, heap, exit)) {
764 accumulated_time()->stop();
765 }
766
767 young_gen->print_used_change(pre_gc_values.young_gen_used());
768 old_gen->print_used_change(pre_gc_values.old_gen_used());
769 MetaspaceUtils::print_metaspace_change(pre_gc_values.metadata_used());
770
771 // Track memory usage and detect low memory
772 MemoryService::track_memory_usage();
773 heap->update_counters();
774 }
775
776 if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) {
777 HandleMark hm; // Discard invalid handles created during verification
778 Universe::verify("After GC");
779 }
780
781 heap->print_heap_after_gc();
782 heap->trace_heap_after_gc(&_gc_tracer);
783
784 scavenge_exit.update();
785
786 log_debug(gc, task, time)("VM-Thread " JLONG_FORMAT " " JLONG_FORMAT " " JLONG_FORMAT,
787 scavenge_entry.ticks(), scavenge_midpoint.ticks(),
788 scavenge_exit.ticks());
789
790 #ifdef TRACESPINNING
791 ParallelTaskTerminator::print_termination_counts();
792 #endif
793
794 AdaptiveSizePolicyOutput::print(size_policy, heap->total_collections());
795
796 _gc_timer.register_gc_end();
797
798 _gc_tracer.report_gc_end(_gc_timer.gc_end(), _gc_timer.time_partitions());
799
800 return !promotion_failure_occurred;
801 }
802
803 // This method iterates over all objects in the young generation,
804 // removing all forwarding references. It then restores any preserved marks.
805 void PSScavenge::clean_up_failed_promotion() {
806 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
807 PSYoungGen* young_gen = heap->young_gen();
|
857 size_t promotion_estimate = MIN2(avg_promoted, young_gen->used_in_bytes());
858 bool result = promotion_estimate < old_gen->free_in_bytes();
859
860 log_trace(ergo)("%s scavenge: average_promoted " SIZE_FORMAT " padded_average_promoted " SIZE_FORMAT " free in old gen "
861 result ? "Do" : "Skip", (size_t) policy->average_promoted_in_bytes(),
862 (size_t) policy->padded_average_promoted_in_bytes(),
863 old_gen->free_in_bytes());
864 if (young_gen->used_in_bytes() < (size_t) policy->padded_average_promoted_in_bytes()) {
865 log_trace(ergo)(" padded_promoted_average is greater than maximum promotion = " SIZE_FORMAT, young_gen->used_in_bytes()
866 }
867
868 if (result) {
869 _consecutive_skipped_scavenges = 0;
870 } else {
871 _consecutive_skipped_scavenges++;
872 if (UsePerfData) {
873 counters->update_scavenge_skipped(promoted_too_large);
874 }
875 }
876 return result;
877 }
878
879 // Used to add tasks
880 GCTaskManager* const PSScavenge::gc_task_manager() {
881 assert(ParallelScavengeHeap::gc_task_manager() != NULL,
882 "shouldn't return NULL");
883 return ParallelScavengeHeap::gc_task_manager();
884 }
885
886 // Adaptive size policy support. When the young generation/old generation
887 // boundary moves, _young_generation_boundary must be reset
888 void PSScavenge::set_young_generation_boundary(HeapWord* v) {
889 _young_generation_boundary = v;
890 if (UseCompressedOops) {
891 _young_generation_boundary_compressed = (uintptr_t)CompressedOops::encode((oop)v);
892 }
893 }
894
895 void PSScavenge::initialize() {
896 // Arguments must have been parsed
897
898 if (AlwaysTenure || NeverTenure) {
899 assert(MaxTenuringThreshold == 0 || MaxTenuringThreshold == markOopDesc::max_age + 1,
900 "MaxTenuringThreshold should be 0 or markOopDesc::max_age + 1, but is %d", (int) MaxTenuringThreshold);
901 _tenuring_threshold = MaxTenuringThreshold;
902 } else {
|
844 size_t promotion_estimate = MIN2(avg_promoted, young_gen->used_in_bytes());
845 bool result = promotion_estimate < old_gen->free_in_bytes();
846
847 log_trace(ergo)("%s scavenge: average_promoted " SIZE_FORMAT " padded_average_promoted " SIZE_FORMAT " free in old gen "
848 result ? "Do" : "Skip", (size_t) policy->average_promoted_in_bytes(),
849 (size_t) policy->padded_average_promoted_in_bytes(),
850 old_gen->free_in_bytes());
851 if (young_gen->used_in_bytes() < (size_t) policy->padded_average_promoted_in_bytes()) {
852 log_trace(ergo)(" padded_promoted_average is greater than maximum promotion = " SIZE_FORMAT, young_gen->used_in_bytes()
853 }
854
855 if (result) {
856 _consecutive_skipped_scavenges = 0;
857 } else {
858 _consecutive_skipped_scavenges++;
859 if (UsePerfData) {
860 counters->update_scavenge_skipped(promoted_too_large);
861 }
862 }
863 return result;
864 }
865
866 // Adaptive size policy support. When the young generation/old generation
867 // boundary moves, _young_generation_boundary must be reset
868 void PSScavenge::set_young_generation_boundary(HeapWord* v) {
869 _young_generation_boundary = v;
870 if (UseCompressedOops) {
871 _young_generation_boundary_compressed = (uintptr_t)CompressedOops::encode((oop)v);
872 }
873 }
874
875 void PSScavenge::initialize() {
876 // Arguments must have been parsed
877
878 if (AlwaysTenure || NeverTenure) {
879 assert(MaxTenuringThreshold == 0 || MaxTenuringThreshold == markOopDesc::max_age + 1,
880 "MaxTenuringThreshold should be 0 or markOopDesc::max_age + 1, but is %d", (int) MaxTenuringThreshold);
881 _tenuring_threshold = MaxTenuringThreshold;
882 } else {
|