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 #include "precompiled.hpp"
 25 #include "gc/shared/gcHeapSummary.hpp"
 26 #include "gc/z/zCollectedHeap.hpp"
 27 #include "gc/z/zGlobals.hpp"
 28 #include "gc/z/zHeap.inline.hpp"
 29 #include "gc/z/zNMethodTable.hpp"
 30 #include "gc/z/zServiceability.hpp"
 31 #include "gc/z/zStat.hpp"
 32 #include "gc/z/zUtils.inline.hpp"
 33 #include "runtime/mutexLocker.hpp"
 34 
 35 ZCollectedHeap* ZCollectedHeap::heap() {
 36   CollectedHeap* heap = Universe::heap();
 37   assert(heap != NULL, "Uninitialized access to ZCollectedHeap::heap()");
 38   assert(heap->kind() == CollectedHeap::Z, "Invalid name");
 39   return (ZCollectedHeap*)heap;
 40 }
 41 
 42 ZCollectedHeap::ZCollectedHeap(ZCollectorPolicy* policy) :
 43     _collector_policy(policy),
 44     _soft_ref_policy(),
 45     _barrier_set(),
 46     _initialize(&_barrier_set),
 47     _heap(),
 48     _director(new ZDirector()),
 49     _driver(new ZDriver()),
 50     _stat(new ZStat()),
 51     _runtime_workers() {}
 52 
 53 CollectedHeap::Name ZCollectedHeap::kind() const {
 54   return CollectedHeap::Z;
 55 }
 56 
 57 const char* ZCollectedHeap::name() const {
 58   return ZGCName;
 59 }
 60 
 61 jint ZCollectedHeap::initialize() {
 62   if (!_heap.is_initialized()) {
 63     return JNI_ENOMEM;
 64   }
 65 
 66   initialize_reserved_region((HeapWord*)ZAddressReservedStart(),
 67                              (HeapWord*)ZAddressReservedEnd());
 68 
 69   return JNI_OK;
 70 }
 71 
 72 void ZCollectedHeap::initialize_serviceability() {
 73   _heap.serviceability_initialize();
 74 }
 75 
 76 void ZCollectedHeap::stop() {
 77   _director->stop();
 78   _driver->stop();
 79   _stat->stop();
 80 }
 81 
 82 CollectorPolicy* ZCollectedHeap::collector_policy() const {
 83   return _collector_policy;
 84 }
 85 
 86 SoftRefPolicy* ZCollectedHeap::soft_ref_policy() {
 87   return &_soft_ref_policy;
 88 }
 89 
 90 size_t ZCollectedHeap::max_capacity() const {
 91   return _heap.max_capacity();
 92 }
 93 
 94 size_t ZCollectedHeap::capacity() const {
 95   return _heap.capacity();
 96 }
 97 
 98 size_t ZCollectedHeap::used() const {
 99   return _heap.used();
100 }
101 
102 bool ZCollectedHeap::is_maximal_no_gc() const {
103   // Not supported
104   ShouldNotReachHere();
105   return false;
106 }
107 
108 bool ZCollectedHeap::is_scavengable(oop obj) {
109   return false;
110 }
111 
112 bool ZCollectedHeap::is_in(const void* p) const {
113   return is_in_reserved(p) && _heap.is_in((uintptr_t)p);
114 }
115 
116 bool ZCollectedHeap::is_in_closed_subset(const void* p) const {
117   return is_in(p);
118 }
119 
120 HeapWord* ZCollectedHeap::allocate_new_tlab(size_t min_size, size_t requested_size, size_t* actual_size) {
121   const size_t size_in_bytes = ZUtils::words_to_bytes(align_object_size(requested_size));
122   const uintptr_t addr = _heap.alloc_tlab(size_in_bytes);
123 
124   if (addr != 0) {
125     *actual_size = requested_size;
126   }
127 
128   return (HeapWord*)addr;
129 }
130 
131 HeapWord* ZCollectedHeap::mem_allocate(size_t size, bool* gc_overhead_limit_was_exceeded) {
132   const size_t size_in_bytes = ZUtils::words_to_bytes(align_object_size(size));
133   return (HeapWord*)_heap.alloc_object(size_in_bytes);
134 }
135 
136 MetaWord* ZCollectedHeap::satisfy_failed_metadata_allocation(ClassLoaderData* loader_data,
137                                                              size_t size,
138                                                              Metaspace::MetadataType mdtype) {
139   MetaWord* result;
140 
141   // Start asynchronous GC
142   collect(GCCause::_metadata_GC_threshold);
143 
144   // Expand and retry allocation
145   result = loader_data->metaspace_non_null()->expand_and_allocate(size, mdtype);
146   if (result != NULL) {
147     return result;
148   }
149 
150   // Start synchronous GC
151   collect(GCCause::_metadata_GC_clear_soft_refs);
152 
153   // Retry allocation
154   result = loader_data->metaspace_non_null()->allocate(size, mdtype);
155   if (result != NULL) {
156     return result;
157   }
158 
159   // Expand and retry allocation
160   result = loader_data->metaspace_non_null()->expand_and_allocate(size, mdtype);
161   if (result != NULL) {
162     return result;
163   }
164 
165   // Out of memory
166   return NULL;
167 }
168 
169 void ZCollectedHeap::collect(GCCause::Cause cause) {
170   _driver->collect(cause);
171 }
172 
173 void ZCollectedHeap::collect_as_vm_thread(GCCause::Cause cause) {
174   // These collection requests are ignored since ZGC can't run a synchronous
175   // GC cycle from within the VM thread. This is considered benign, since the
176   // only GC causes coming in here should be heap dumper and heap inspector.
177   // However, neither the heap dumper nor the heap inspector really need a GC
178   // to happen, but the result of their heap iterations might in that case be
179   // less accurate since they might include objects that would otherwise have
180   // been collected by a GC.
181   assert(Thread::current()->is_VM_thread(), "Should be the VM thread");
182   guarantee(cause == GCCause::_heap_dump ||
183             cause == GCCause::_heap_inspection, "Invalid cause");
184 }
185 
186 void ZCollectedHeap::do_full_collection(bool clear_all_soft_refs) {
187   // Not supported
188   ShouldNotReachHere();
189 }
190 
191 bool ZCollectedHeap::supports_tlab_allocation() const {
192   return true;
193 }
194 
195 size_t ZCollectedHeap::tlab_capacity(Thread* ignored) const {
196   return _heap.tlab_capacity();
197 }
198 
199 size_t ZCollectedHeap::tlab_used(Thread* ignored) const {
200   return _heap.tlab_used();
201 }
202 
203 size_t ZCollectedHeap::max_tlab_size() const {
204   return _heap.max_tlab_size();
205 }
206 
207 size_t ZCollectedHeap::unsafe_max_tlab_alloc(Thread* ignored) const {
208   return _heap.unsafe_max_tlab_alloc();
209 }
210 
211 bool ZCollectedHeap::can_elide_tlab_store_barriers() const {
212   return false;
213 }
214 
215 bool ZCollectedHeap::can_elide_initializing_store_barrier(oop new_obj) {
216   // Not supported
217   ShouldNotReachHere();
218   return true;
219 }
220 
221 bool ZCollectedHeap::card_mark_must_follow_store() const {
222   // Not supported
223   ShouldNotReachHere();
224   return false;
225 }
226 
227 GrowableArray<GCMemoryManager*> ZCollectedHeap::memory_managers() {
228   return GrowableArray<GCMemoryManager*>(1, 1, _heap.serviceability_memory_manager());
229 }
230 
231 GrowableArray<MemoryPool*> ZCollectedHeap::memory_pools() {
232   return GrowableArray<MemoryPool*>(1, 1, _heap.serviceability_memory_pool());
233 }
234 
235 void ZCollectedHeap::object_iterate(ObjectClosure* cl) {
236   _heap.object_iterate(cl, true /* visit_referents */);
237 }
238 
239 void ZCollectedHeap::safe_object_iterate(ObjectClosure* cl) {
240   _heap.object_iterate(cl, true /* visit_referents */);
241 }
242 
243 HeapWord* ZCollectedHeap::block_start(const void* addr) const {
244   return (HeapWord*)_heap.block_start((uintptr_t)addr);
245 }
246 
247 size_t ZCollectedHeap::block_size(const HeapWord* addr) const {
248   size_t size_in_bytes = _heap.block_size((uintptr_t)addr);
249   return ZUtils::bytes_to_words(size_in_bytes);
250 }
251 
252 bool ZCollectedHeap::block_is_obj(const HeapWord* addr) const {
253   return _heap.block_is_obj((uintptr_t)addr);
254 }
255 
256 void ZCollectedHeap::register_nmethod(nmethod* nm) {
257   assert_locked_or_safepoint(CodeCache_lock);
258   ZNMethodTable::register_nmethod(nm);
259 }
260 
261 void ZCollectedHeap::unregister_nmethod(nmethod* nm) {
262   //assert_locked_or_safepoint(CodeCache_lock);
263   ZNMethodTable::unregister_nmethod(nm);
264 }
265 
266 void ZCollectedHeap::verify_nmethod(nmethod* nm) {
267   // Does nothing
268 }
269 
270 WorkGang* ZCollectedHeap::get_safepoint_workers() {
271   return _runtime_workers.workers();
272 }
273 
274 jlong ZCollectedHeap::millis_since_last_gc() {
275   return ZStatCycle::time_since_last() / MILLIUNITS;
276 }
277 
278 void ZCollectedHeap::gc_threads_do(ThreadClosure* tc) const {
279   tc->do_thread(_director);
280   tc->do_thread(_driver);
281   tc->do_thread(_stat);
282   _heap.worker_threads_do(tc);
283   _runtime_workers.threads_do(tc);
284 }
285 
286 VirtualSpaceSummary ZCollectedHeap::create_heap_space_summary() {
287   const size_t capacity_in_words = capacity() / HeapWordSize;
288   const size_t max_capacity_in_words = max_capacity() / HeapWordSize;
289   return VirtualSpaceSummary(reserved_region().start(),
290                              reserved_region().start() + capacity_in_words,
291                              reserved_region().start() + max_capacity_in_words);
292 }
293 
294 void ZCollectedHeap::prepare_for_verify() {
295   // Does nothing
296 }
297 
298 void ZCollectedHeap::print_on(outputStream* st) const {
299   _heap.print_on(st);
300 }
301 
302 void ZCollectedHeap::print_on_error(outputStream* st) const {
303   CollectedHeap::print_on_error(st);
304 
305   st->print_cr("Address Space");
306   st->print_cr( "     Start:             " PTR_FORMAT, ZAddressSpaceStart);
307   st->print_cr( "     End:               " PTR_FORMAT, ZAddressSpaceEnd);
308   st->print_cr( "     Size:              " SIZE_FORMAT_W(-15) " (" PTR_FORMAT ")", ZAddressSpaceSize, ZAddressSpaceSize);
309   st->print_cr( "Heap");
310   st->print_cr( "     GlobalPhase:       %u", ZGlobalPhase);
311   st->print_cr( "     GlobalSeqNum:      %u", ZGlobalSeqNum);
312   st->print_cr( "     Offset Max:        " SIZE_FORMAT_W(-15) " (" PTR_FORMAT ")", ZAddressOffsetMax, ZAddressOffsetMax);
313   st->print_cr( "     Page Size Small:   " SIZE_FORMAT_W(-15) " (" PTR_FORMAT ")", ZPageSizeSmall, ZPageSizeSmall);
314   st->print_cr( "     Page Size Medium:  " SIZE_FORMAT_W(-15) " (" PTR_FORMAT ")", ZPageSizeMedium, ZPageSizeMedium);
315   st->print_cr( "Metadata Bits");
316   st->print_cr( "     Good:              " PTR_FORMAT, ZAddressGoodMask);
317   st->print_cr( "     Bad:               " PTR_FORMAT, ZAddressBadMask);
318   st->print_cr( "     WeakBad:           " PTR_FORMAT, ZAddressWeakBadMask);
319   st->print_cr( "     Marked:            " PTR_FORMAT, ZAddressMetadataMarked);
320   st->print_cr( "     Remapped:          " PTR_FORMAT, ZAddressMetadataRemapped);
321 }
322 
323 void ZCollectedHeap::print_extended_on(outputStream* st) const {
324   _heap.print_extended_on(st);
325 }
326 
327 void ZCollectedHeap::print_gc_threads_on(outputStream* st) const {
328   _director->print_on(st);
329   st->cr();
330   _driver->print_on(st);
331   st->cr();
332   _stat->print_on(st);
333   st->cr();
334   _heap.print_worker_threads_on(st);
335   _runtime_workers.print_threads_on(st);
336 }
337 
338 void ZCollectedHeap::print_tracing_info() const {
339   // Does nothing
340 }
341 
342 void ZCollectedHeap::verify(VerifyOption option /* ignored */) {
343   _heap.verify();
344 }
345 
346 bool ZCollectedHeap::is_oop(oop object) const {
347   return CollectedHeap::is_oop(object) && _heap.is_oop(object);
348 }