1 /*
   2  * Copyright (c) 2000, 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_SHARED_CARDTABLEBARRIERSET_HPP
  26 #define SHARE_GC_SHARED_CARDTABLEBARRIERSET_HPP
  27 
  28 #include "gc/shared/modRefBarrierSet.hpp"
  29 #include "utilities/align.hpp"
  30 
  31 class CardTable;
  32 
  33 // This kind of "BarrierSet" allows a "CollectedHeap" to detect and
  34 // enumerate ref fields that have been modified (since the last
  35 // enumeration.)
  36 
  37 // As it currently stands, this barrier is *imprecise*: when a ref field in
  38 // an object "o" is modified, the card table entry for the card containing
  39 // the head of "o" is dirtied, not necessarily the card containing the
  40 // modified field itself.  For object arrays, however, the barrier *is*
  41 // precise; only the card containing the modified element is dirtied.
  42 // Closures used to scan dirty cards should take these
  43 // considerations into account.
  44 
  45 class CardTableBarrierSet: public ModRefBarrierSet {
  46   // Some classes get to look at some private stuff.
  47   friend class VMStructs;
  48  protected:
  49 
  50   // Used in support of ReduceInitialCardMarks; only consulted if COMPILER2
  51   // or INCLUDE_JVMCI is being used
  52   bool       _defer_initial_card_mark;
  53   CardTable* _card_table;
  54 
  55   CardTableBarrierSet(BarrierSetAssembler* barrier_set_assembler,
  56                       BarrierSetC1* barrier_set_c1,
  57                       BarrierSetC2* barrier_set_c2,
  58                       CardTable* card_table,
  59                       const BarrierSet::FakeRtti& fake_rtti);
  60 
  61  public:
  62   CardTableBarrierSet(CardTable* card_table);
  63   ~CardTableBarrierSet();
  64 
  65   CardTable* card_table() const { return _card_table; }
  66 
  67   virtual void initialize();
  68 
  69   void write_region(MemRegion mr) {
  70     invalidate(mr);
  71   }
  72 
  73   void write_ref_array_work(MemRegion mr);
  74 
  75  public:
  76   // Record a reference update. Note that these versions are precise!
  77   // The scanning code has to handle the fact that the write barrier may be
  78   // either precise or imprecise. We make non-virtual inline variants of
  79   // these functions here for performance.
  80   template <DecoratorSet decorators, typename T>
  81   void write_ref_field_post(T* field, oop newVal);
  82 
  83   virtual void invalidate(MemRegion mr);
  84 
  85   // ReduceInitialCardMarks
  86   void initialize_deferred_card_mark_barriers();
  87 
  88   // If the CollectedHeap was asked to defer a store barrier above,
  89   // this informs it to flush such a deferred store barrier to the
  90   // remembered set.
  91   void flush_deferred_card_mark_barrier(JavaThread* thread);
  92 
  93   // If a compiler is eliding store barriers for TLAB-allocated objects,
  94   // we will be informed of a slow-path allocation by a call
  95   // to on_slowpath_allocation_exit() below. Such a call precedes the
  96   // initialization of the object itself, and no post-store-barriers will
  97   // be issued. Some heap types require that the barrier strictly follows
  98   // the initializing stores. (This is currently implemented by deferring the
  99   // barrier until the next slow-path allocation or gc-related safepoint.)
 100   // This interface answers whether a particular barrier type needs the card
 101   // mark to be thus strictly sequenced after the stores.
 102   virtual bool card_mark_must_follow_store() const;
 103 
 104   virtual void on_slowpath_allocation_exit(JavaThread* thread, oop new_obj);
 105   virtual void on_thread_detach(Thread* thread);
 106 
 107   virtual void make_parsable(JavaThread* thread) { flush_deferred_card_mark_barrier(thread); }
 108 
 109   virtual void print_on(outputStream* st) const;
 110 
 111   template <DecoratorSet decorators, typename BarrierSetT = CardTableBarrierSet>
 112   class AccessBarrier: public ModRefBarrierSet::AccessBarrier<decorators, BarrierSetT> {};
 113 };
 114 
 115 template<>
 116 struct BarrierSet::GetName<CardTableBarrierSet> {
 117   static const BarrierSet::Name value = BarrierSet::CardTableBarrierSet;
 118 };
 119 
 120 template<>
 121 struct BarrierSet::GetType<BarrierSet::CardTableBarrierSet> {
 122   typedef ::CardTableBarrierSet type;
 123 };
 124 
 125 #endif // SHARE_GC_SHARED_CARDTABLEBARRIERSET_HPP