1 /* 2 * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 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 #ifndef SHARE_GC_Z_ZHEAP_HPP 25 #define SHARE_GC_Z_ZHEAP_HPP 26 27 #include "gc/z/zAllocationFlags.hpp" 28 #include "gc/z/zForwardingTable.hpp" 29 #include "gc/z/zMark.hpp" 30 #include "gc/z/zObjectAllocator.hpp" 31 #include "gc/z/zPage.hpp" 32 #include "gc/z/zPageAllocator.hpp" 33 #include "gc/z/zPageTable.hpp" 34 #include "gc/z/zReferenceProcessor.hpp" 35 #include "gc/z/zRelocate.hpp" 36 #include "gc/z/zRelocationSet.hpp" 37 #include "gc/z/zWeakRootsProcessor.hpp" 38 #include "gc/z/zServiceability.hpp" 39 #include "gc/z/zUnload.hpp" 40 #include "gc/z/zWorkers.hpp" 41 42 class ThreadClosure; 43 44 class ZHeap { 45 friend class VMStructs; 46 47 private: 48 static ZHeap* _heap; 49 50 ZWorkers _workers; 51 ZObjectAllocator _object_allocator; 52 ZPageAllocator _page_allocator; 53 ZPageTable _page_table; 54 ZForwardingTable _forwarding_table; 55 ZMark _mark; 56 ZReferenceProcessor _reference_processor; 57 ZWeakRootsProcessor _weak_roots_processor; 58 ZRelocate _relocate; 59 ZRelocationSet _relocation_set; 60 ZUnload _unload; 61 ZServiceability _serviceability; 62 63 void flip_to_marked(); 64 void flip_to_remapped(); 65 66 void out_of_memory(); 67 void fixup_partial_loads(); 68 69 public: 70 static ZHeap* heap(); 71 72 ZHeap(); 73 74 bool is_initialized() const; 75 76 // Heap metrics 77 size_t min_capacity() const; 78 size_t max_capacity() const; 79 size_t soft_max_capacity() const; 80 size_t capacity() const; 81 size_t max_reserve() const; 82 size_t used_high() const; 83 size_t used_low() const; 84 size_t used() const; 85 size_t unused() const; 86 size_t allocated() const; 87 size_t reclaimed() const; 88 89 size_t tlab_capacity() const; 90 size_t tlab_used() const; 91 size_t max_tlab_size() const; 92 size_t unsafe_max_tlab_alloc() const; 93 94 bool is_in(uintptr_t addr) const; 95 uint32_t hash_oop(uintptr_t addr) const; 96 97 // Threads 98 uint nconcurrent_worker_threads() const; 99 uint nconcurrent_no_boost_worker_threads() const; 100 void set_boost_worker_threads(bool boost); 101 void threads_do(ThreadClosure* tc) const; 102 103 void run_task(AbstractGangTask* task); 104 // Reference processing 105 ReferenceDiscoverer* reference_discoverer(); 106 void set_soft_reference_policy(bool clear); 107 108 // Non-strong reference processing 109 void process_non_strong_references(); 110 111 // Page allocation 112 ZPage* alloc_page(uint8_t type, size_t size, ZAllocationFlags flags); 113 void undo_alloc_page(ZPage* page); 114 void free_page(ZPage* page, bool reclaimed); 115 116 // Object allocation 117 uintptr_t alloc_tlab(size_t size); 118 uintptr_t alloc_object(size_t size); 119 uintptr_t alloc_object_for_relocation(size_t size); 120 void undo_alloc_object_for_relocation(uintptr_t addr, size_t size); 121 bool is_alloc_stalled() const; 122 void check_out_of_memory(); 123 124 // Marking 125 bool is_object_live(uintptr_t addr) const; 126 bool is_object_strongly_live(uintptr_t addr) const; 127 template <bool follow, bool finalizable, bool publish> void mark_object(uintptr_t addr); 128 void mark_start(); 129 void mark(bool initial); 130 void mark_flush_and_free(Thread* thread); 131 bool mark_end(); 132 void keep_alive(oop obj); 133 134 // Relocation set 135 void select_relocation_set(); 136 void reset_relocation_set(); 137 138 // Relocation 139 void relocate_start(); 140 uintptr_t relocate_object(uintptr_t addr); 141 uintptr_t remap_object(uintptr_t addr); 142 void relocate(); 143 144 // Iteration 145 void object_iterate(ObjectClosure* cl, bool visit_weaks); 146 void pages_do(ZPageClosure* cl); 147 148 // Serviceability 149 void serviceability_initialize(); 150 GCMemoryManager* serviceability_memory_manager(); 151 MemoryPool* serviceability_memory_pool(); 152 ZServiceabilityCounters* serviceability_counters(); 153 154 // Printing 155 void print_on(outputStream* st) const; 156 void print_extended_on(outputStream* st) const; 157 bool print_location(outputStream* st, uintptr_t addr) const; 158 159 // Verification 160 bool is_oop(uintptr_t addr) const; 161 void verify(); 162 }; 163 164 #endif // SHARE_GC_Z_ZHEAP_HPP