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   void run_task(AbstractGangTask* task);
 102 
 103   // Reference processing
 104   ReferenceDiscoverer* reference_discoverer();
 105   void set_soft_reference_policy(bool clear);
 106 
 107   // Non-strong reference processing
 108   void process_non_strong_references();
 109 
 110   // Page allocation
 111   ZPage* alloc_page(uint8_t type, size_t size, ZAllocationFlags flags);
 112   void undo_alloc_page(ZPage* page);
 113   void free_page(ZPage* page, bool reclaimed);
 114 
 115   // Object allocation
 116   uintptr_t alloc_tlab(size_t size);
 117   uintptr_t alloc_object(size_t size);
 118   uintptr_t alloc_object_for_relocation(size_t size);
 119   void undo_alloc_object_for_relocation(uintptr_t addr, size_t size);
 120   bool is_alloc_stalled() const;
 121   void check_out_of_memory();
 122 
 123   // Marking
 124   bool is_object_live(uintptr_t addr) const;
 125   bool is_object_strongly_live(uintptr_t addr) const;
 126   template <bool follow, bool finalizable, bool publish> void mark_object(uintptr_t addr);
 127   void mark_start();
 128   void mark(bool initial);
 129   void mark_flush_and_free(Thread* thread);
 130   bool mark_end();
 131   void keep_alive(oop obj);
 132 
 133   // Relocation set
 134   void select_relocation_set();
 135   void reset_relocation_set();
 136 
 137   // Relocation
 138   void relocate_start();
 139   uintptr_t relocate_object(uintptr_t addr);
 140   uintptr_t remap_object(uintptr_t addr);
 141   void relocate();
 142 
 143   // Iteration
 144   void object_iterate(ObjectClosure* cl, bool visit_weaks);
 145   void pages_do(ZPageClosure* cl);
 146 
 147   // Serviceability
 148   void serviceability_initialize();
 149   GCMemoryManager* serviceability_memory_manager();
 150   MemoryPool* serviceability_memory_pool();
 151   ZServiceabilityCounters* serviceability_counters();
 152 
 153   // Printing
 154   void print_on(outputStream* st) const;
 155   void print_extended_on(outputStream* st) const;
 156   bool print_location(outputStream* st, uintptr_t addr) const;
 157 
 158   // Verification
 159   bool is_oop(uintptr_t addr) const;
 160   void verify();
 161 };
 162 
 163 #endif // SHARE_GC_Z_ZHEAP_HPP