1 /*
   2  * Copyright (c) 2005, 2019, 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 
  25 #ifndef SHARE_GC_PARALLEL_PSCOMPACTIONMANAGER_HPP
  26 #define SHARE_GC_PARALLEL_PSCOMPACTIONMANAGER_HPP
  27 
  28 #include "gc/shared/taskqueue.hpp"
  29 #include "memory/allocation.hpp"
  30 #include "utilities/stack.hpp"
  31 
  32 class MutableSpace;
  33 class PSOldGen;
  34 class ParCompactionManager;
  35 class ObjectStartArray;
  36 class ParallelCompactData;
  37 class ParMarkBitMap;
  38 
  39 class ParCompactionManager : public CHeapObj<mtGC> {
  40   friend class ParallelTaskTerminator;
  41   friend class ParMarkBitMap;
  42   friend class PSParallelCompact;
  43   friend class CompactionWithStealingTask;
  44   friend class UpdateAndFillClosure;
  45   friend class RefProcTaskExecutor;
  46   friend class PCRefProcTask;
  47   friend class MarkFromRootsTask;
  48   friend class UpdateDensePrefixAndCompactionTask;
  49 
  50  public:
  51 
  52 // ------------------------  Don't putback if not needed
  53   // Actions that the compaction manager should take.
  54   enum Action {
  55     Update,
  56     Copy,
  57     UpdateAndCopy,
  58     CopyAndUpdate,
  59     NotValid
  60   };
  61 // ------------------------  End don't putback if not needed
  62 
  63  private:
  64   // 32-bit:  4K * 8 = 32KiB; 64-bit:  8K * 16 = 128KiB
  65   #define QUEUE_SIZE (1 << NOT_LP64(12) LP64_ONLY(13))
  66   typedef OverflowTaskQueue<ObjArrayTask, mtGC, QUEUE_SIZE> ObjArrayTaskQueue;
  67   typedef GenericTaskQueueSet<ObjArrayTaskQueue, mtGC>      ObjArrayTaskQueueSet;
  68   #undef QUEUE_SIZE
  69 
  70   static ParCompactionManager** _manager_array;
  71   static OopTaskQueueSet*       _stack_array;
  72   static ObjArrayTaskQueueSet*  _objarray_queues;
  73   static ObjectStartArray*      _start_array;
  74   static RegionTaskQueueSet*    _region_array;
  75   static PSOldGen*              _old_gen;
  76 
  77 private:
  78   OverflowTaskQueue<oop, mtGC>        _marking_stack;
  79   ObjArrayTaskQueue             _objarray_stack;
  80 
  81   // Is there a way to reuse the _marking_stack for the
  82   // saving empty regions?  For now just create a different
  83   // type of TaskQueue.
  84   RegionTaskQueue              _region_stack;
  85 
  86   static ParMarkBitMap* _mark_bitmap;
  87 
  88   Action _action;
  89 
  90   HeapWord* _last_query_beg;
  91   oop _last_query_obj;
  92   size_t _last_query_ret;
  93 
  94   static PSOldGen* old_gen()             { return _old_gen; }
  95   static ObjectStartArray* start_array() { return _start_array; }
  96   static OopTaskQueueSet* stack_array()  { return _stack_array; }
  97 
  98   static void initialize(ParMarkBitMap* mbm);
  99 
 100  protected:
 101   // Array of tasks.  Needed by the ParallelTaskTerminator.
 102   static RegionTaskQueueSet* region_array()      { return _region_array; }
 103   OverflowTaskQueue<oop, mtGC>*  marking_stack()       { return &_marking_stack; }
 104 
 105   // Pushes onto the marking stack.  If the marking stack is full,
 106   // pushes onto the overflow stack.
 107   void stack_push(oop obj);
 108   // Do not implement an equivalent stack_pop.  Deal with the
 109   // marking stack and overflow stack directly.
 110 
 111  public:
 112   void reset_bitmap_query_cache() {
 113     _last_query_beg = NULL;
 114     _last_query_obj = NULL;
 115     _last_query_ret = 0;
 116   }
 117 
 118   Action action() { return _action; }
 119   void set_action(Action v) { _action = v; }
 120 
 121   // Bitmap query support, cache last query and result
 122   HeapWord* last_query_begin() { return _last_query_beg; }
 123   oop last_query_object() { return _last_query_obj; }
 124   size_t last_query_return() { return _last_query_ret; }
 125 
 126   void set_last_query_begin(HeapWord *new_beg) { _last_query_beg = new_beg; }
 127   void set_last_query_object(oop new_obj) { _last_query_obj = new_obj; }
 128   void set_last_query_return(size_t new_ret) { _last_query_ret = new_ret; }
 129 
 130   static void reset_all_bitmap_query_caches();
 131 
 132   RegionTaskQueue* region_stack()                { return &_region_stack; }
 133 
 134   inline static ParCompactionManager* manager_array(uint index);
 135 
 136   ParCompactionManager();
 137 
 138   // Pushes onto the region stack at the given index.  If the
 139   // region stack is full,
 140   // pushes onto the region overflow stack.
 141   static void verify_region_list_empty(uint stack_index);
 142   ParMarkBitMap* mark_bitmap() { return _mark_bitmap; }
 143 
 144   // void drain_stacks();
 145 
 146   bool should_update();
 147   bool should_copy();
 148 
 149   // Save for later processing.  Must not fail.
 150   inline void push(oop obj);
 151   inline void push_objarray(oop objarray, size_t index);
 152   inline void push_region(size_t index);
 153 
 154   // Check mark and maybe push on marking stack.
 155   template <typename T> inline void mark_and_push(T* p);
 156 
 157   inline void follow_klass(Klass* klass);
 158 
 159   void follow_class_loader(ClassLoaderData* klass);
 160 
 161   // Access function for compaction managers
 162   static ParCompactionManager* gc_thread_compaction_manager(uint index);
 163 
 164   static bool steal(int queue_num, oop& t);
 165   static bool steal_objarray(int queue_num, ObjArrayTask& t);
 166   static bool steal(int queue_num, size_t& region);
 167 
 168   // Process tasks remaining on any marking stack
 169   void follow_marking_stacks();
 170   inline bool marking_stacks_empty() const;
 171 
 172   // Process tasks remaining on any stack
 173   void drain_region_stacks();
 174 
 175   void follow_contents(oop obj);
 176   void follow_array(objArrayOop array, int index);
 177 
 178   void update_contents(oop obj);
 179 
 180   class FollowStackClosure: public VoidClosure {
 181    private:
 182     ParCompactionManager* _compaction_manager;
 183    public:
 184     FollowStackClosure(ParCompactionManager* cm) : _compaction_manager(cm) { }
 185     virtual void do_void();
 186   };
 187 };
 188 
 189 inline ParCompactionManager* ParCompactionManager::manager_array(uint index) {
 190   assert(_manager_array != NULL, "access of NULL manager_array");
 191   assert(index <= ParallelGCThreads, "out of range manager_array access");
 192   return _manager_array[index];
 193 }
 194 
 195 bool ParCompactionManager::marking_stacks_empty() const {
 196   return _marking_stack.is_empty() && _objarray_stack.is_empty();
 197 }
 198 
 199 #endif // SHARE_GC_PARALLEL_PSCOMPACTIONMANAGER_HPP