16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "code/codeCache.hpp"
27 #include "gc/parallel/adjoiningGenerations.hpp"
28 #include "gc/parallel/adjoiningVirtualSpaces.hpp"
29 #include "gc/parallel/cardTableExtension.hpp"
30 #include "gc/parallel/gcTaskManager.hpp"
31 #include "gc/parallel/generationSizer.hpp"
32 #include "gc/parallel/objectStartArray.inline.hpp"
33 #include "gc/parallel/parallelScavengeHeap.inline.hpp"
34 #include "gc/parallel/psAdaptiveSizePolicy.hpp"
35 #include "gc/parallel/psMarkSweep.hpp"
36 #include "gc/parallel/psParallelCompact.inline.hpp"
37 #include "gc/parallel/psPromotionManager.hpp"
38 #include "gc/parallel/psScavenge.hpp"
39 #include "gc/parallel/vmPSOperations.hpp"
40 #include "gc/shared/gcHeapSummary.hpp"
41 #include "gc/shared/gcLocker.inline.hpp"
42 #include "gc/shared/gcWhen.hpp"
43 #include "logging/log.hpp"
44 #include "oops/oop.inline.hpp"
45 #include "runtime/handles.inline.hpp"
46 #include "runtime/java.hpp"
47 #include "runtime/vmThread.hpp"
48 #include "services/memTracker.hpp"
49 #include "utilities/vmError.hpp"
50
51 PSYoungGen* ParallelScavengeHeap::_young_gen = NULL;
52 PSOldGen* ParallelScavengeHeap::_old_gen = NULL;
53 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
54 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
55 GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL;
56
57 jint ParallelScavengeHeap::initialize() {
58 CollectedHeap::pre_initialize();
59
60 const size_t heap_size = _collector_policy->max_heap_byte_size();
61
62 ReservedSpace heap_rs = Universe::reserve_heap(heap_size, _collector_policy->heap_alignment());
63
64 os::trace_page_sizes("Heap",
65 _collector_policy->min_heap_byte_size(),
66 heap_size,
67 generation_alignment(),
657 if (ZapUnusedHeapArea) {
658 young_gen()->eden_space()->mangle_unused_area();
659 young_gen()->to_space()->mangle_unused_area();
660 young_gen()->from_space()->mangle_unused_area();
661 old_gen()->object_space()->mangle_unused_area();
662 }
663 }
664 #endif
665
666 bool ParallelScavengeHeap::is_scavengable(oop obj) {
667 return is_in_young(obj);
668 }
669
670 void ParallelScavengeHeap::register_nmethod(nmethod* nm) {
671 CodeCache::register_scavenge_root_nmethod(nm);
672 }
673
674 void ParallelScavengeHeap::verify_nmethod(nmethod* nm) {
675 CodeCache::verify_scavenge_root_nmethod(nm);
676 }
|
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "code/codeCache.hpp"
27 #include "gc/parallel/adjoiningGenerations.hpp"
28 #include "gc/parallel/adjoiningVirtualSpaces.hpp"
29 #include "gc/parallel/cardTableExtension.hpp"
30 #include "gc/parallel/gcTaskManager.hpp"
31 #include "gc/parallel/generationSizer.hpp"
32 #include "gc/parallel/objectStartArray.inline.hpp"
33 #include "gc/parallel/parallelScavengeHeap.inline.hpp"
34 #include "gc/parallel/psAdaptiveSizePolicy.hpp"
35 #include "gc/parallel/psMarkSweep.hpp"
36 #include "gc/parallel/psMemoryPool.hpp"
37 #include "gc/parallel/psParallelCompact.inline.hpp"
38 #include "gc/parallel/psPromotionManager.hpp"
39 #include "gc/parallel/psScavenge.hpp"
40 #include "gc/parallel/vmPSOperations.hpp"
41 #include "gc/shared/gcHeapSummary.hpp"
42 #include "gc/shared/gcLocker.inline.hpp"
43 #include "gc/shared/gcWhen.hpp"
44 #include "logging/log.hpp"
45 #include "oops/oop.inline.hpp"
46 #include "runtime/handles.inline.hpp"
47 #include "runtime/java.hpp"
48 #include "runtime/vmThread.hpp"
49 #include "services/memoryManager.hpp"
50 #include "services/memTracker.hpp"
51 #include "utilities/vmError.hpp"
52
53 PSYoungGen* ParallelScavengeHeap::_young_gen = NULL;
54 PSOldGen* ParallelScavengeHeap::_old_gen = NULL;
55 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
56 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
57 GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL;
58
59 jint ParallelScavengeHeap::initialize() {
60 CollectedHeap::pre_initialize();
61
62 const size_t heap_size = _collector_policy->max_heap_byte_size();
63
64 ReservedSpace heap_rs = Universe::reserve_heap(heap_size, _collector_policy->heap_alignment());
65
66 os::trace_page_sizes("Heap",
67 _collector_policy->min_heap_byte_size(),
68 heap_size,
69 generation_alignment(),
659 if (ZapUnusedHeapArea) {
660 young_gen()->eden_space()->mangle_unused_area();
661 young_gen()->to_space()->mangle_unused_area();
662 young_gen()->from_space()->mangle_unused_area();
663 old_gen()->object_space()->mangle_unused_area();
664 }
665 }
666 #endif
667
668 bool ParallelScavengeHeap::is_scavengable(oop obj) {
669 return is_in_young(obj);
670 }
671
672 void ParallelScavengeHeap::register_nmethod(nmethod* nm) {
673 CodeCache::register_scavenge_root_nmethod(nm);
674 }
675
676 void ParallelScavengeHeap::verify_nmethod(nmethod* nm) {
677 CodeCache::verify_scavenge_root_nmethod(nm);
678 }
679
680 class PSScavengeMemoryManager : public GCMemoryManager {
681 private:
682 public:
683 PSScavengeMemoryManager() : GCMemoryManager() {}
684
685 const char* name() { return "PS Scavenge"; }
686 virtual const char* gc_end_message() { return "end of minor GC"; }
687 };
688
689 class PSMarkSweepMemoryManager : public GCMemoryManager {
690 private:
691 public:
692 PSMarkSweepMemoryManager() : GCMemoryManager() {}
693
694 const char* name() { return "PS MarkSweep"; }
695 virtual const char* gc_end_message() { return "end of major GC"; }
696 };
697
698 GrowableArray<MemoryManager*> ParallelScavengeHeap::memory_managers() {
699 _minor_mgr = new PSScavengeMemoryManager();
700 _major_mgr = new PSMarkSweepMemoryManager();
701 GrowableArray<MemoryManager*> mem_mgrs;
702 mem_mgrs.append(_minor_mgr);
703 mem_mgrs.append(_major_mgr);
704 return mem_mgrs;
705 }
706
707 GrowableArray<MemoryPool*> ParallelScavengeHeap::memory_pools() {
708 PSYoungGen* young = young_gen();
709 EdenMutableSpacePool* eden = new EdenMutableSpacePool(young,
710 young->eden_space(),
711 "PS Eden Space",
712 MemoryPool::Heap,
713 false /* support_usage_threshold */);
714
715 SurvivorMutableSpacePool* survivor = new SurvivorMutableSpacePool(young,
716 "PS Survivor Space",
717 MemoryPool::Heap,
718 false /* support_usage_threshold */);
719
720 PSGenerationPool* old_gen_pool = new PSGenerationPool(old_gen(),
721 "PS Old Gen",
722 MemoryPool::Heap,
723 true /* support_usage_threshold */);
724
725 _major_mgr->add_pool(eden);
726 _major_mgr->add_pool(survivor);
727 _major_mgr->add_pool(old_gen_pool);
728
729 _minor_mgr->add_pool(eden);
730 _minor_mgr->add_pool(survivor);
731
732 GrowableArray<MemoryPool*> mem_pools;
733 mem_pools.append(eden);
734 mem_pools.append(survivor);
735 mem_pools.append(old_gen_pool);
736 return mem_pools;
737 }
738
|