1 /*

     2  * Copyright (c) 2013, 2015, 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 #include "precompiled.hpp"

    26 #include "gc/g1/g1CardCounts.hpp"

    27 #include "gc/g1/g1CollectedHeap.inline.hpp"

    28 #include "gc/g1/g1CollectorPolicy.hpp"

    29 #include "gc/g1/g1GCPhaseTimes.hpp"

    30 #include "gc/shared/cardTableModRefBS.hpp"

    31 #include "services/memTracker.hpp"

    32 #include "utilities/copy.hpp"

    33 

    34 void G1CardCountsMappingChangedListener::on_commit(uint start_idx, size_t num_regions, bool zero_filled) {

    35   if (zero_filled) {

    36     return;

    37   }

    38   MemRegion mr(G1CollectedHeap::heap()->bottom_addr_for_region(start_idx), num_regions * HeapRegion::GrainWords);

    39   _counts->clear_range(mr);

    40 }

    41 

    42 size_t G1CardCounts::compute_size(size_t mem_region_size_in_words) {

    43   // We keep card counts for every card, so the size of the card counts table must

    44   // be the same as the card table.

    45   return G1SATBCardTableLoggingModRefBS::compute_size(mem_region_size_in_words);

    46 }

    47 

    48 size_t G1CardCounts::heap_map_factor() {

    49   // See G1CardCounts::compute_size() why we reuse the card table value.

    50   return G1SATBCardTableLoggingModRefBS::heap_map_factor();

    51 }

    52 

    53 void G1CardCounts::clear_range(size_t from_card_num, size_t to_card_num) {

    54   if (has_count_table()) {

    55     assert(from_card_num < to_card_num,

    56            err_msg("Wrong order? from: " SIZE_FORMAT ", to: "SIZE_FORMAT,

    57                    from_card_num, to_card_num));

    58     Copy::fill_to_bytes(&_card_counts[from_card_num], (to_card_num - from_card_num));

    59   }

    60 }

    61 

    62 G1CardCounts::G1CardCounts(G1CollectedHeap *g1h):

    63   _listener(), _g1h(g1h), _card_counts(NULL), _reserved_max_card_num(0) {

    64   _listener.set_cardcounts(this);

    65 }

    66 

    67 void G1CardCounts::initialize(G1RegionToSpaceMapper* mapper) {

    68   assert(_g1h->max_capacity() > 0, "initialization order");

    69   assert(_g1h->capacity() == 0, "initialization order");

    70 

    71   if (G1ConcRSHotCardLimit > 0) {

    72     // The max value we can store in the counts table is

    73     // max_jubyte. Guarantee the value of the hot

    74     // threshold limit is no more than this.

    75     guarantee(G1ConcRSHotCardLimit <= max_jubyte, "sanity");

    76 

    77     _ct_bs = _g1h->g1_barrier_set();

    78     _ct_bot = _ct_bs->byte_for_const(_g1h->reserved_region().start());

    79 

    80     _card_counts = (jubyte*) mapper->reserved().start();

    81     _reserved_max_card_num = mapper->reserved().byte_size();

    82     mapper->set_mapping_changed_listener(&_listener);

    83   }

    84 }

    85 

    86 uint G1CardCounts::add_card_count(jbyte* card_ptr) {

    87   // Returns the number of times the card has been refined.

    88   // If we failed to reserve/commit the counts table, return 0.

    89   // If card_ptr is beyond the committed end of the counts table,

    90   // return 0.

    91   // Otherwise return the actual count.

    92   // Unless G1ConcRSHotCardLimit has been set appropriately,

    93   // returning 0 will result in the card being considered

    94   // cold and will be refined immediately.

    95   uint count = 0;

    96   if (has_count_table()) {

    97     size_t card_num = ptr_2_card_num(card_ptr);

    98     assert(card_num < _reserved_max_card_num,

    99            err_msg("Card "SIZE_FORMAT" outside of card counts table (max size "SIZE_FORMAT")",

   100                    card_num, _reserved_max_card_num));

   101     count = (uint) _card_counts[card_num];

   102     if (count < G1ConcRSHotCardLimit) {

   103       _card_counts[card_num] =

   104         (jubyte)(MIN2((uintx)(_card_counts[card_num] + 1), G1ConcRSHotCardLimit));

   105     }

   106   }

   107   return count;

   108 }

   109 

   110 bool G1CardCounts::is_hot(uint count) {

   111   return (count >= G1ConcRSHotCardLimit);

   112 }

   113 

   114 void G1CardCounts::clear_region(HeapRegion* hr) {

   115   MemRegion mr(hr->bottom(), hr->end());

   116   clear_range(mr);

   117 }

   118 

   119 void G1CardCounts::clear_range(MemRegion mr) {

   120   if (has_count_table()) {

   121     const jbyte* from_card_ptr = _ct_bs->byte_for_const(mr.start());

   122     // We use the last address in the range as the range could represent the

   123     // last region in the heap. In which case trying to find the card will be an

   124     // OOB access to the card table.

   125     const jbyte* last_card_ptr = _ct_bs->byte_for_const(mr.last());

   126 

   127 #ifdef ASSERT

   128     HeapWord* start_addr = _ct_bs->addr_for(from_card_ptr);

   129     assert(start_addr == mr.start(), "MemRegion start must be aligned to a card.");

   130     HeapWord* last_addr = _ct_bs->addr_for(last_card_ptr);

   131     assert((last_addr + CardTableModRefBS::card_size_in_words) == mr.end(), "MemRegion end must be aligned to a card.");

   132 #endif // ASSERT

   133 

   134     // Clear the counts for the (exclusive) card range.

   135     size_t from_card_num = ptr_2_card_num(from_card_ptr);

   136     size_t to_card_num = ptr_2_card_num(last_card_ptr) + 1;

   137     clear_range(from_card_num, to_card_num);

   138   }

   139 }

   140 

   141 class G1CardCountsClearClosure : public HeapRegionClosure {

   142  private:

   143   G1CardCounts* _card_counts;

   144  public:

   145   G1CardCountsClearClosure(G1CardCounts* card_counts) :

   146     HeapRegionClosure(), _card_counts(card_counts) { }

   147 

   148 

   149   virtual bool doHeapRegion(HeapRegion* r) {

   150     _card_counts->clear_region(r);

   151     return false;

   152   }

   153 };

   154 

   155 void G1CardCounts::clear_all() {

   156   assert(SafepointSynchronize::is_at_safepoint(), "don't call this otherwise");

   157   G1CardCountsClearClosure cl(this);

   158   _g1h->heap_region_iterate(&cl);

   159 }