1 /*
  2  * Copyright (c) 2020, 2021 Amazon.com, Inc. 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 
 25 #ifndef SHARE_VM_GC_SHENANDOAH_SHENANDOAHGENERATION_HPP
 26 #define SHARE_VM_GC_SHENANDOAH_SHENANDOAHGENERATION_HPP
 27 
 28 #include "memory/allocation.hpp"
 29 #include "gc/shenandoah/heuristics/shenandoahOldHeuristics.hpp"
 30 #include "gc/shenandoah/mode/shenandoahGenerationalMode.hpp"
 31 #include "gc/shenandoah/shenandoahLock.hpp"
 32 #include "gc/shenandoah/shenandoahMarkingContext.hpp"
 33 
 34 class ShenandoahHeapRegion;
 35 class ShenandoahHeapRegionClosure;
 36 class ShenandoahReferenceProcessor;
 37 
 38 class ShenandoahGeneration : public CHeapObj<mtGC> {
 39 private:
 40   GenerationMode const _generation_mode;
 41 
 42   // Marking task queues and completeness
 43   ShenandoahObjToScanQueueSet* _task_queues;
 44   ShenandoahSharedFlag _is_marking_complete;
 45 
 46   ShenandoahReferenceProcessor* const _ref_processor;
 47 
 48 protected:
 49   // Usage
 50   size_t _affiliated_region_count;
 51   volatile size_t _used;
 52   volatile size_t _bytes_allocated_since_gc_start;
 53   size_t _max_capacity;
 54   size_t _soft_max_capacity;
 55 
 56   size_t _adjusted_capacity;
 57 
 58   ShenandoahHeuristics* _heuristics;
 59  public:
 60   ShenandoahGeneration(GenerationMode generation_mode, uint max_workers, size_t max_capacity, size_t soft_max_capacity);
 61   ~ShenandoahGeneration();
 62 
 63   inline GenerationMode generation_mode() const { return _generation_mode; }
 64 
 65   inline ShenandoahHeuristics* heuristics() const { return _heuristics; }
 66 
 67   ShenandoahReferenceProcessor* ref_processor() { return _ref_processor; }
 68 
 69   virtual const char* name() const = 0;
 70 
 71   virtual ShenandoahHeuristics* initialize_heuristics(ShenandoahMode* gc_mode);
 72 
 73   virtual size_t soft_max_capacity() const { return _soft_max_capacity; }
 74   virtual size_t max_capacity() const      { return _max_capacity; }
 75   virtual size_t used_regions() const;
 76   virtual size_t used_regions_size() const;
 77   virtual size_t free_unaffiliated_regions() const;
 78   virtual size_t used() const { return _used; }
 79   virtual size_t available() const;
 80 
 81   // During evacuation and update-refs, some memory may be shifted between generations.  In particular, memory
 82   // may be loaned by old-gen to young-gen based on the promise the loan will be promptly repaid from the memory reclaimed
 83   // when the current collection set is recycled.  The capacity adjustment also takes into consideration memory that is
 84   // set aside within each generation to hold the results of evacuation, but not promotion, into that region.  Promotions
 85   // into old-gen are bounded by adjusted_available() whereas evacuations into old-gen are pre-committed.
 86   virtual size_t adjusted_available() const;
 87 
 88   // Both of following return new value of available
 89   virtual size_t adjust_available(intptr_t adjustment);
 90   virtual size_t unadjust_available();
 91 
 92   size_t bytes_allocated_since_gc_start();
 93   void reset_bytes_allocated_since_gc_start();
 94   void increase_allocated(size_t bytes);
 95 
 96   void set_soft_max_capacity(size_t soft_max_capacity) {
 97     _soft_max_capacity = soft_max_capacity;
 98   }
 99 
100   void log_status() const;
101 
102   // Used directly by FullGC
103   void reset_mark_bitmap();
104 
105   // Used by concurrent and degenerated GC to reset remembered set.
106   void swap_remembered_set();
107 
108   // Update the read cards with the state of the write table (write table is not cleared).
109   void merge_write_table();
110 
111   // Used by concurrent and degenerated GC to reset regions.
112   void prepare_gc(bool do_old_gc_bootstrap);
113 
114   // Return true iff prepared collection set includes at least one old-gen HeapRegion.
115   virtual void prepare_regions_and_collection_set(bool concurrent);
116 
117   // Cancel marking (used by Full collect and when cancelling cycle).
118   virtual void cancel_marking();
119 
120   // Return true if this region is affiliated with this generation.
121   virtual bool contains(ShenandoahHeapRegion* region) const = 0;
122 
123   // Return true if this object is affiliated with this generation.
124   virtual bool contains(oop obj) const = 0;
125 
126   // Apply closure to all regions affiliated with this generation.
127   virtual void parallel_heap_region_iterate(ShenandoahHeapRegionClosure* cl) = 0;
128 
129   // Apply closure to all regions affiliated with this generation (single threaded).
130   virtual void heap_region_iterate(ShenandoahHeapRegionClosure* cl) = 0;
131 
132   // This is public to support cancellation of marking when a Full cycle is started.
133   virtual void set_concurrent_mark_in_progress(bool in_progress) = 0;
134 
135   // Check the bitmap only for regions belong to this generation.
136   bool is_bitmap_clear();
137 
138   // We need to track the status of marking for different generations.
139   bool is_mark_complete();
140   void set_mark_complete();
141   void set_mark_incomplete();
142 
143   ShenandoahMarkingContext* complete_marking_context();
144 
145   // Task queues
146   ShenandoahObjToScanQueueSet* task_queues() const { return _task_queues; }
147   virtual void reserve_task_queues(uint workers);
148   virtual ShenandoahObjToScanQueueSet* old_gen_task_queues() const;
149 
150   // Scan remembered set at start of concurrent young-gen marking. */
151   void scan_remembered_set();
152 
153   void increment_affiliated_region_count();
154   void decrement_affiliated_region_count();
155 
156   void clear_used();
157   void increase_used(size_t bytes);
158   void decrease_used(size_t bytes);
159 
160   virtual bool is_concurrent_mark_in_progress() = 0;
161   void confirm_heuristics_mode();
162 };
163 
164 #endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHGENERATION_HPP