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 
  68 public:
  69   static ZHeap* heap();
  70 
  71   ZHeap();
  72 
  73   bool is_initialized() const;
  74 
  75   // Heap metrics
  76   size_t min_capacity() const;
  77   size_t max_capacity() const;
  78   size_t soft_max_capacity() const;
  79   size_t capacity() const;
  80   size_t max_reserve() const;
  81   size_t used_high() const;
  82   size_t used_low() const;
  83   size_t used() const;
  84   size_t unused() const;
  85   size_t allocated() const;
  86   size_t reclaimed() const;
  87 
  88   size_t tlab_capacity() const;
  89   size_t tlab_used() const;
  90   size_t max_tlab_size() const;
  91   size_t unsafe_max_tlab_alloc() const;
  92 
  93   bool is_in(uintptr_t addr) const;
  94   uint32_t hash_oop(uintptr_t addr) const;
  95 
  96   // Threads
  97   uint nconcurrent_worker_threads() const;
  98   uint nconcurrent_no_boost_worker_threads() const;
  99   void set_boost_worker_threads(bool boost);
 100   void threads_do(ThreadClosure* tc) const;
 101 
 102   // Reference processing
 103   ReferenceDiscoverer* reference_discoverer();
 104   void set_soft_reference_policy(bool clear);
 105 
 106   // Non-strong reference processing
 107   void process_non_strong_references();
 108 
 109   // Page allocation
 110   ZPage* alloc_page(uint8_t type, size_t size, ZAllocationFlags flags);
 111   void undo_alloc_page(ZPage* page);
 112   void free_page(ZPage* page, bool reclaimed);
 113 
 114   // Object allocation
 115   uintptr_t alloc_tlab(size_t size);
 116   uintptr_t alloc_object(size_t size);
 117   uintptr_t alloc_object_for_relocation(size_t size);
 118   void undo_alloc_object_for_relocation(uintptr_t addr, size_t size);
 119   bool is_alloc_stalled() const;
 120   void check_out_of_memory();
 121 
 122   // Marking
 123   bool is_object_live(uintptr_t addr) const;
 124   bool is_object_strongly_live(uintptr_t addr) const;
 125   template <bool follow, bool finalizable, bool publish> void mark_object(uintptr_t addr);
 126   void mark_start();
 127   void mark(bool initial);
 128   void mark_flush_and_free(Thread* thread);
 129   bool mark_end();
 130   void keep_alive(oop obj);
 131 
 132   // Relocation set
 133   void select_relocation_set();
 134   void reset_relocation_set();
 135 
 136   // Relocation
 137   void relocate_start();
 138   uintptr_t relocate_object(uintptr_t addr);
 139   uintptr_t remap_object(uintptr_t addr);
 140   void relocate();
 141 
 142   // Iteration
 143   void object_iterate(ObjectClosure* cl, bool visit_weaks);
 144   void pages_do(ZPageClosure* cl);
 145 
 146   // Serviceability
 147   void serviceability_initialize();
 148   GCMemoryManager* serviceability_memory_manager();
 149   MemoryPool* serviceability_memory_pool();
 150   ZServiceabilityCounters* serviceability_counters();
 151 
 152   // Printing
 153   void print_on(outputStream* st) const;
 154   void print_extended_on(outputStream* st) const;
 155   bool print_location(outputStream* st, uintptr_t addr) const;
 156 
 157   // Verification
 158   bool is_oop(uintptr_t addr) const;
 159   void verify();
 160 };
 161 
 162 #endif // SHARE_GC_Z_ZHEAP_HPP