1 /* 2 * Copyright (c) 2015, 2018, 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/shared/gcTimer.hpp" 28 #include "gc/z/zAllocationFlags.hpp" 29 #include "gc/z/zArray.hpp" 30 #include "gc/z/zInitialize.hpp" 31 #include "gc/z/zList.hpp" 32 #include "gc/z/zLock.hpp" 33 #include "gc/z/zMark.hpp" 34 #include "gc/z/zObjectAllocator.hpp" 35 #include "gc/z/zPage.hpp" 36 #include "gc/z/zPageAllocator.hpp" 37 #include "gc/z/zPageTable.hpp" 38 #include "gc/z/zReferenceProcessor.hpp" 39 #include "gc/z/zRelocate.hpp" 40 #include "gc/z/zRelocationSet.hpp" 41 #include "gc/z/zRelocationSetSelector.hpp" 42 #include "gc/z/zRootsIterator.hpp" 43 #include "gc/z/zWeakRootsProcessor.hpp" 44 #include "gc/z/zServiceability.hpp" 45 #include "gc/z/zWorkers.hpp" 46 #include "memory/allocation.hpp" 47 48 class ZHeap VALUE_OBJ_CLASS_SPEC { 49 friend class VMStructs; 50 51 private: 52 static ZHeap* _heap; 53 54 ZInitialize _initialize; 55 ZWorkers _workers; 56 ZObjectAllocator _object_allocator; 57 ZPageAllocator _page_allocator; 58 ZPageTable _pagetable; 59 ZMark _mark; 60 ZReferenceProcessor _reference_processor; 61 ZWeakRootsProcessor _weak_roots_processor; 62 ZRelocate _relocate; 63 ZRelocationSet _relocation_set; 64 ZServiceability _serviceability; 65 66 size_t heap_min_size() const; 67 size_t heap_max_size() const; 68 size_t heap_max_reserve_size() const; 69 70 void out_of_memory(); 71 void flip_views(); 72 void fixup_partial_loads(); 73 74 public: 75 static ZHeap* heap(); 76 77 ZHeap(); 78 79 bool is_initialized() const; 80 81 // Heap metrics 82 size_t min_capacity() const; 83 size_t max_capacity() const; 84 size_t capacity() const; 85 size_t max_reserve() const; 86 size_t used_high() const; 87 size_t used_low() const; 88 size_t used() const; 89 size_t allocated() const; 90 size_t reclaimed() const; 91 92 size_t tlab_capacity() const; 93 size_t tlab_used() const; 94 size_t max_tlab_size() const; 95 size_t unsafe_max_tlab_alloc() const; 96 97 bool is_in(uintptr_t addr) const; 98 99 // Block 100 uintptr_t block_start(uintptr_t addr) const; 101 size_t block_size(uintptr_t addr) const; 102 bool block_is_obj(uintptr_t addr) const; 103 104 // Raw pagetable exposed for barriers 105 ZPageTableEntry* pagetable_addr() const; 106 107 // Workers 108 void set_boost_worker_threads(bool boost); 109 void worker_threads_do(ThreadClosure* tc) const; 110 void print_worker_threads_on(outputStream* st) const; 111 112 // Reference processing 113 ReferenceDiscoverer* reference_discoverer(); 114 void set_soft_reference_policy(bool clear); 115 116 // Non-strong reference processing 117 void process_non_strong_references(); 118 119 // Page allocation 120 ZPage* alloc_page(uint8_t type, size_t size, ZAllocationFlags flags); 121 void undo_alloc_page(ZPage* page); 122 bool retain_page(ZPage* page); 123 void release_page(ZPage* page, bool reclaimed); 124 125 // Object allocation 126 uintptr_t alloc_tlab(size_t size); 127 uintptr_t alloc_object(size_t size); 128 uintptr_t alloc_object_for_relocation(size_t size); 129 void undo_alloc_object_for_relocation(uintptr_t addr, size_t size); 130 void check_out_of_memory(); 131 132 // Marking 133 bool is_object_live(uintptr_t addr) const; 134 bool is_object_strongly_live(uintptr_t addr) const; 135 template <bool finalizable, bool publish> void mark_object(uintptr_t addr); 136 void mark_start(); 137 void mark(); 138 void mark_flush_and_free(); 139 bool mark_end(); 140 141 // Post-marking & Pre-relocation 142 void destroy_detached_pages(); 143 144 // Relocation set 145 void select_relocation_set(); 146 void prepare_relocation_set(); 147 void reset_relocation_set(); 148 149 // Relocation 150 bool is_relocating(uintptr_t addr) const; 151 void relocate_start(); 152 uintptr_t relocate_object(uintptr_t addr); 153 uintptr_t forward_object(uintptr_t addr); 154 void relocate(); 155 156 // Iteration 157 void object_iterate(ObjectClosure* cl); 158 159 // Serviceability 160 void serviceability_initialize(); 161 GCMemoryManager* serviceability_memory_manager(); 162 MemoryPool* serviceability_memory_pool(); 163 ZServiceabilityCounters* serviceability_counters(); 164 165 // Printing 166 void print_on(outputStream* st) const; 167 void print_extended_on(outputStream* st) const; 168 169 // Verification 170 bool is_oop(oop object) const; 171 void verify(); 172 }; 173 174 #endif // SHARE_GC_Z_ZHEAP_HPP