jdk8-mips64-public/hotspot: src/share/vm/gc_implementation/g1/g1SATBCardTableModRefBS.hpp@29e7d79232b9

6819065: G1: eliminate high serial card table clearing time
Reviewed-by: iveresov, tonyp

     1 /*

     2  * Copyright 2001-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    25 #ifndef SERIALGC

    27 class DirtyCardQueueSet;

    29 // This barrier is specialized to use a logging barrier to support

    30 // snapshot-at-the-beginning marking.

    32 class G1SATBCardTableModRefBS: public CardTableModRefBSForCTRS {

    33 private:

    34   // Add "pre_val" to a set of objects that may have been disconnected from the

    35   // pre-marking object graph.

    36   static void enqueue(oop pre_val);

    38 public:

    39   G1SATBCardTableModRefBS(MemRegion whole_heap,

    40                           int max_covered_regions);

    42   bool is_a(BarrierSet::Name bsn) {

    43     return bsn == BarrierSet::G1SATBCT || CardTableModRefBS::is_a(bsn);

    44   }

    46   virtual bool has_write_ref_pre_barrier() { return true; }

    48   // This notes that we don't need to access any BarrierSet data

    49   // structures, so this can be called from a static context.

    50   static void write_ref_field_pre_static(void* field, oop newVal) {

    51     assert(!UseCompressedOops, "Else needs to be templatized");

    52     oop preVal = *((oop*)field);

    53     if (preVal != NULL) {

    54       enqueue(preVal);

    55     }

    56   }

    58   // When we know the current java thread:

    59   static void write_ref_field_pre_static(void* field, oop newVal,

    60                                          JavaThread* jt);

    62   // We export this to make it available in cases where the static

    63   // type of the barrier set is known.  Note that it is non-virtual.

    64   inline void inline_write_ref_field_pre(void* field, oop newVal) {

    65     write_ref_field_pre_static(field, newVal);

    66   }

    68   // This is the more general virtual version.

    69   void write_ref_field_pre_work(void* field, oop new_val) {

    70     inline_write_ref_field_pre(field, new_val);

    71   }

    73   virtual void write_ref_array_pre(MemRegion mr);

    75 };

    77 // Adds card-table logging to the post-barrier.

    78 // Usual invariant: all dirty cards are logged in the DirtyCardQueueSet.

    79 class G1SATBCardTableLoggingModRefBS: public G1SATBCardTableModRefBS {

    80  private:

    81   DirtyCardQueueSet& _dcqs;

    82  public:

    83   G1SATBCardTableLoggingModRefBS(MemRegion whole_heap,

    84                                  int max_covered_regions);

    86   bool is_a(BarrierSet::Name bsn) {

    87     return bsn == BarrierSet::G1SATBCTLogging ||

    88       G1SATBCardTableModRefBS::is_a(bsn);

    89   }

    91   void write_ref_field_work(void* field, oop new_val);

    93   // Can be called from static contexts.

    94   static void write_ref_field_static(void* field, oop new_val);

    96   // NB: if you do a whole-heap invalidation, the "usual invariant" defined

    97   // above no longer applies.

    98   void invalidate(MemRegion mr, bool whole_heap = false);

   100   void write_region_work(MemRegion mr)    { invalidate(mr); }

   101   void write_ref_array_work(MemRegion mr) { invalidate(mr); }

   104 };

   107 #endif // SERIALGC

Mercurial > jdk8-mips64-public > hotspot / file revision