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/zList.hpp"
  31 #include "gc/z/zLock.hpp"
  32 #include "gc/z/zMark.hpp"
  33 #include "gc/z/zObjectAllocator.hpp"
  34 #include "gc/z/zPage.hpp"
  35 #include "gc/z/zPageAllocator.hpp"
  36 #include "gc/z/zPageTable.hpp"
  37 #include "gc/z/zReferenceProcessor.hpp"
  38 #include "gc/z/zRelocate.hpp"
  39 #include "gc/z/zRelocationSet.hpp"
  40 #include "gc/z/zRelocationSetSelector.hpp"
  41 #include "gc/z/zRootsIterator.hpp"
  42 #include "gc/z/zWeakRootsProcessor.hpp"
  43 #include "gc/z/zServiceability.hpp"
  44 #include "gc/z/zUnload.hpp"
  45 #include "gc/z/zWorkers.hpp"
  46 #include "memory/allocation.hpp"
  47 
  48 class ZHeap {
  49   friend class VMStructs;
  50 
  51 private:
  52   static ZHeap*       _heap;
  53 
  54   ZWorkers            _workers;
  55   ZObjectAllocator    _object_allocator;
  56   ZPageAllocator      _page_allocator;
  57   ZPageTable          _pagetable;
  58   ZMark               _mark;
  59   ZReferenceProcessor _reference_processor;
  60   ZWeakRootsProcessor _weak_roots_processor;
  61   ZRelocate           _relocate;
  62   ZRelocationSet      _relocation_set;
  63   ZUnload             _unload;
  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 current_max_capacity() const;
  85   size_t capacity() const;
  86   size_t max_reserve() const;
  87   size_t used_high() const;
  88   size_t used_low() const;
  89   size_t used() const;
  90   size_t allocated() const;
  91   size_t reclaimed() const;
  92 
  93   size_t tlab_capacity() const;
  94   size_t tlab_used() const;
  95   size_t max_tlab_size() const;
  96   size_t unsafe_max_tlab_alloc() const;
  97 
  98   bool is_in(uintptr_t addr) const;
  99 
 100   // Block
 101   uintptr_t block_start(uintptr_t addr) const;
 102   bool block_is_obj(uintptr_t addr) const;
 103 
 104   // Workers
 105   uint nconcurrent_worker_threads() const;
 106   uint nconcurrent_no_boost_worker_threads() const;
 107   void set_boost_worker_threads(bool boost);
 108   void worker_threads_do(ThreadClosure* tc) const;
 109   void print_worker_threads_on(outputStream* st) const;
 110 
 111   // Reference processing
 112   ReferenceDiscoverer* reference_discoverer();
 113   void set_soft_reference_policy(bool clear);
 114 
 115   // Non-strong reference processing
 116   void process_non_strong_references();
 117 
 118   // Page allocation
 119   ZPage* alloc_page(uint8_t type, size_t size, ZAllocationFlags flags);
 120   void undo_alloc_page(ZPage* page);
 121   bool retain_page(ZPage* page);
 122   void release_page(ZPage* page, bool reclaimed);
 123 
 124   // Object allocation
 125   uintptr_t alloc_tlab(size_t size);
 126   uintptr_t alloc_object(size_t size);
 127   uintptr_t alloc_object_for_relocation(size_t size);
 128   void undo_alloc_object_for_relocation(uintptr_t addr, size_t size);
 129   bool is_alloc_stalled() const;
 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(bool initial);
 138   void mark_flush_and_free(Thread* thread);
 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, bool visit_referents);
 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