hotspot/src/share/vm/memory/cardTableModRefBS.cpp
author tonyp
Tue, 08 Nov 2011 00:41:28 -0500
changeset 10997 0be4b3be7197
parent 9624 c3657c3324ee
child 11174 fccee5238e70
permissions -rw-r--r--
7099849: G1: include heap region information in hs_err files Reviewed-by: johnc, brutisso, poonam
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
9183
3d0e0687fe28 7036482: clear argument is redundant and unused in cardtable methods
ysr
parents: 7397
diff changeset
     2
 * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4461
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4461
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4461
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5892
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5892
diff changeset
    26
#include "memory/allocation.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5892
diff changeset
    27
#include "memory/cardTableModRefBS.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5892
diff changeset
    28
#include "memory/cardTableRS.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5892
diff changeset
    29
#include "memory/sharedHeap.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5892
diff changeset
    30
#include "memory/space.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5892
diff changeset
    31
#include "memory/space.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5892
diff changeset
    32
#include "memory/universe.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5892
diff changeset
    33
#include "runtime/java.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5892
diff changeset
    34
#include "runtime/mutexLocker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5892
diff changeset
    35
#include "runtime/virtualspace.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5892
diff changeset
    36
#ifdef COMPILER1
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5892
diff changeset
    37
#include "c1/c1_LIR.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5892
diff changeset
    38
#include "c1/c1_LIRGenerator.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5892
diff changeset
    39
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5892
diff changeset
    40
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// This kind of "BarrierSet" allows a "CollectedHeap" to detect and
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
// enumerate ref fields that have been modified (since the last
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
// enumeration.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
size_t CardTableModRefBS::cards_required(size_t covered_words)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
  // Add one for a guard card, used to detect errors.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  const size_t words = align_size_up(covered_words, card_size_in_words);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  return words / card_size_in_words + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
size_t CardTableModRefBS::compute_byte_map_size()
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  assert(_guard_index == cards_required(_whole_heap.word_size()) - 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
                                        "unitialized, check declaration order");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  assert(_page_size != 0, "unitialized, check declaration order");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  const size_t granularity = os::vm_allocation_granularity();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  return align_size_up(_guard_index + 1, MAX2(_page_size, granularity));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
CardTableModRefBS::CardTableModRefBS(MemRegion whole_heap,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
                                     int max_covered_regions):
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  ModRefBarrierSet(max_covered_regions),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  _whole_heap(whole_heap),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  _guard_index(cards_required(whole_heap.word_size()) - 1),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  _last_valid_index(_guard_index - 1),
194
8cdd3d9a4c99 6635560: segv in reference processor on t1000
jcoomes
parents: 1
diff changeset
    67
  _page_size(os::vm_page_size()),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  _byte_map_size(compute_byte_map_size())
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  _kind = BarrierSet::CardTableModRef;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  HeapWord* low_bound  = _whole_heap.start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  HeapWord* high_bound = _whole_heap.end();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  assert((uintptr_t(low_bound)  & (card_size - 1))  == 0, "heap must start at card boundary");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  assert((uintptr_t(high_bound) & (card_size - 1))  == 0, "heap must end at card boundary");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  assert(card_size <= 512, "card_size must be less than 512"); // why?
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  _covered   = new MemRegion[max_covered_regions];
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  _committed = new MemRegion[max_covered_regions];
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  if (_covered == NULL || _committed == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
    vm_exit_during_initialization("couldn't alloc card table covered region set.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  for (i = 0; i < max_covered_regions; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
    _covered[i].set_word_size(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
    _committed[i].set_word_size(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  _cur_covered_regions = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  const size_t rs_align = _page_size == (size_t) os::vm_page_size() ? 0 :
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
    MAX2(_page_size, (size_t) os::vm_allocation_granularity());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  ReservedSpace heap_rs(_byte_map_size, rs_align, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  os::trace_page_sizes("card table", _guard_index + 1, _guard_index + 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
                       _page_size, heap_rs.base(), heap_rs.size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  if (!heap_rs.is_reserved()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
    vm_exit_during_initialization("Could not reserve enough space for the "
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
                                  "card marking array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  // The assember store_check code will do an unsigned shift of the oop,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  // then add it to byte_map_base, i.e.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  //   _byte_map = byte_map_base + (uintptr_t(low_bound) >> card_shift)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  _byte_map = (jbyte*) heap_rs.base();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  byte_map_base = _byte_map - (uintptr_t(low_bound) >> card_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  assert(byte_for(low_bound) == &_byte_map[0], "Checking start of map");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  assert(byte_for(high_bound-1) <= &_byte_map[_last_valid_index], "Checking end of map");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  jbyte* guard_card = &_byte_map[_guard_index];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  uintptr_t guard_page = align_size_down((uintptr_t)guard_card, _page_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  _guard_region = MemRegion((HeapWord*)guard_page, _page_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  if (!os::commit_memory((char*)guard_page, _page_size, _page_size)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
    // Do better than this for Merlin
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
    vm_exit_out_of_memory(_page_size, "card table last card");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  *guard_card = last_card;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
   _lowest_non_clean =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
    NEW_C_HEAP_ARRAY(CardArr, max_covered_regions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  _lowest_non_clean_chunk_size =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
    NEW_C_HEAP_ARRAY(size_t, max_covered_regions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  _lowest_non_clean_base_chunk_index =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
    NEW_C_HEAP_ARRAY(uintptr_t, max_covered_regions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  _last_LNC_resizing_collection =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
    NEW_C_HEAP_ARRAY(int, max_covered_regions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  if (_lowest_non_clean == NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
      || _lowest_non_clean_chunk_size == NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
      || _lowest_non_clean_base_chunk_index == NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
      || _last_LNC_resizing_collection == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
    vm_exit_during_initialization("couldn't allocate an LNC array.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  for (i = 0; i < max_covered_regions; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
    _lowest_non_clean[i] = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
    _lowest_non_clean_chunk_size[i] = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
    _last_LNC_resizing_collection[i] = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  if (TraceCardTableModRefBS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
    gclog_or_tty->print_cr("CardTableModRefBS::CardTableModRefBS: ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
    gclog_or_tty->print_cr("  "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
                  "  &_byte_map[0]: " INTPTR_FORMAT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
                  "  &_byte_map[_last_valid_index]: " INTPTR_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
                  &_byte_map[0],
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
                  &_byte_map[_last_valid_index]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
    gclog_or_tty->print_cr("  "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
                  "  byte_map_base: " INTPTR_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
                  byte_map_base);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
int CardTableModRefBS::find_covering_region_by_base(HeapWord* base) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  for (i = 0; i < _cur_covered_regions; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
    if (_covered[i].start() == base) return i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
    if (_covered[i].start() > base) break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  // If we didn't find it, create a new one.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  assert(_cur_covered_regions < _max_covered_regions,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
         "too many covered regions");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  // Move the ones above up, to maintain sorted order.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  for (int j = _cur_covered_regions; j > i; j--) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
    _covered[j] = _covered[j-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
    _committed[j] = _committed[j-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  int res = i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  _cur_covered_regions++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  _covered[res].set_start(base);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  _covered[res].set_word_size(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  jbyte* ct_start = byte_for(base);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  uintptr_t ct_start_aligned = align_size_down((uintptr_t)ct_start, _page_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  _committed[res].set_start((HeapWord*)ct_start_aligned);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  _committed[res].set_word_size(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  return res;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
int CardTableModRefBS::find_covering_region_containing(HeapWord* addr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  for (int i = 0; i < _cur_covered_regions; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
    if (_covered[i].contains(addr)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
      return i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  assert(0, "address outside of heap?");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
HeapWord* CardTableModRefBS::largest_prev_committed_end(int ind) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  HeapWord* max_end = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  for (int j = 0; j < ind; j++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
    HeapWord* this_end = _committed[j].end();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
    if (this_end > max_end) max_end = this_end;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  return max_end;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
MemRegion CardTableModRefBS::committed_unique_to_self(int self,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
                                                      MemRegion mr) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  MemRegion result = mr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  for (int r = 0; r < _cur_covered_regions; r += 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
    if (r != self) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
      result = result.minus(_committed[r]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  // Never include the guard page.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  result = result.minus(_guard_region);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
void CardTableModRefBS::resize_covered_region(MemRegion new_region) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  // We don't change the start of a region, only the end.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  assert(_whole_heap.contains(new_region),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
           "attempt to cover area not in reserved area");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  debug_only(verify_guard();)
754
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   212
  // collided is true if the expansion would push into another committed region
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   213
  debug_only(bool collided = false;)
179
59e3abf83f72 6624765: Guarantee failure "Unexpected dirty card found"
jmasa
parents: 1
diff changeset
   214
  int const ind = find_covering_region_by_base(new_region.start());
59e3abf83f72 6624765: Guarantee failure "Unexpected dirty card found"
jmasa
parents: 1
diff changeset
   215
  MemRegion const old_region = _covered[ind];
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  assert(old_region.start() == new_region.start(), "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  if (new_region.word_size() != old_region.word_size()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
    // Commit new or uncommit old pages, if necessary.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
    MemRegion cur_committed = _committed[ind];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
    // Extend the end of this _commited region
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
    // to cover the end of any lower _committed regions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
    // This forms overlapping regions, but never interior regions.
179
59e3abf83f72 6624765: Guarantee failure "Unexpected dirty card found"
jmasa
parents: 1
diff changeset
   223
    HeapWord* const max_prev_end = largest_prev_committed_end(ind);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
    if (max_prev_end > cur_committed.end()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
      cur_committed.set_end(max_prev_end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
    // Align the end up to a page size (starts are already aligned).
179
59e3abf83f72 6624765: Guarantee failure "Unexpected dirty card found"
jmasa
parents: 1
diff changeset
   228
    jbyte* const new_end = byte_after(new_region.last());
754
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   229
    HeapWord* new_end_aligned =
179
59e3abf83f72 6624765: Guarantee failure "Unexpected dirty card found"
jmasa
parents: 1
diff changeset
   230
      (HeapWord*) align_size_up((uintptr_t)new_end, _page_size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
    assert(new_end_aligned >= (HeapWord*) new_end,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
           "align up, but less");
2107
338528868274 6786346: intermittent Internal Error (src/share/vm/memory/cardTableModRefBS.cpp:226)
jmasa
parents: 1676
diff changeset
   233
    // Check the other regions (excludes "ind") to ensure that
338528868274 6786346: intermittent Internal Error (src/share/vm/memory/cardTableModRefBS.cpp:226)
jmasa
parents: 1676
diff changeset
   234
    // the new_end_aligned does not intrude onto the committed
338528868274 6786346: intermittent Internal Error (src/share/vm/memory/cardTableModRefBS.cpp:226)
jmasa
parents: 1676
diff changeset
   235
    // space of another region.
754
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   236
    int ri = 0;
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   237
    for (ri = 0; ri < _cur_covered_regions; ri++) {
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   238
      if (ri != ind) {
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   239
        if (_committed[ri].contains(new_end_aligned)) {
2107
338528868274 6786346: intermittent Internal Error (src/share/vm/memory/cardTableModRefBS.cpp:226)
jmasa
parents: 1676
diff changeset
   240
          // The prior check included in the assert
338528868274 6786346: intermittent Internal Error (src/share/vm/memory/cardTableModRefBS.cpp:226)
jmasa
parents: 1676
diff changeset
   241
          // (new_end_aligned >= _committed[ri].start())
338528868274 6786346: intermittent Internal Error (src/share/vm/memory/cardTableModRefBS.cpp:226)
jmasa
parents: 1676
diff changeset
   242
          // is redundant with the "contains" test.
338528868274 6786346: intermittent Internal Error (src/share/vm/memory/cardTableModRefBS.cpp:226)
jmasa
parents: 1676
diff changeset
   243
          // Any region containing the new end
338528868274 6786346: intermittent Internal Error (src/share/vm/memory/cardTableModRefBS.cpp:226)
jmasa
parents: 1676
diff changeset
   244
          // should start at or beyond the region found (ind)
338528868274 6786346: intermittent Internal Error (src/share/vm/memory/cardTableModRefBS.cpp:226)
jmasa
parents: 1676
diff changeset
   245
          // for the new end (committed regions are not expected to
338528868274 6786346: intermittent Internal Error (src/share/vm/memory/cardTableModRefBS.cpp:226)
jmasa
parents: 1676
diff changeset
   246
          // be proper subsets of other committed regions).
338528868274 6786346: intermittent Internal Error (src/share/vm/memory/cardTableModRefBS.cpp:226)
jmasa
parents: 1676
diff changeset
   247
          assert(_committed[ri].start() >= _committed[ind].start(),
754
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   248
                 "New end of committed region is inconsistent");
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   249
          new_end_aligned = _committed[ri].start();
2107
338528868274 6786346: intermittent Internal Error (src/share/vm/memory/cardTableModRefBS.cpp:226)
jmasa
parents: 1676
diff changeset
   250
          // new_end_aligned can be equal to the start of its
338528868274 6786346: intermittent Internal Error (src/share/vm/memory/cardTableModRefBS.cpp:226)
jmasa
parents: 1676
diff changeset
   251
          // committed region (i.e., of "ind") if a second
338528868274 6786346: intermittent Internal Error (src/share/vm/memory/cardTableModRefBS.cpp:226)
jmasa
parents: 1676
diff changeset
   252
          // region following "ind" also start at the same location
338528868274 6786346: intermittent Internal Error (src/share/vm/memory/cardTableModRefBS.cpp:226)
jmasa
parents: 1676
diff changeset
   253
          // as "ind".
338528868274 6786346: intermittent Internal Error (src/share/vm/memory/cardTableModRefBS.cpp:226)
jmasa
parents: 1676
diff changeset
   254
          assert(new_end_aligned >= _committed[ind].start(),
754
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   255
            "New end of committed region is before start");
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   256
          debug_only(collided = true;)
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   257
          // Should only collide with 1 region
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   258
          break;
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   259
        }
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   260
      }
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   261
    }
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   262
#ifdef ASSERT
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   263
    for (++ri; ri < _cur_covered_regions; ri++) {
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   264
      assert(!_committed[ri].contains(new_end_aligned),
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   265
        "New end of committed region is in a second committed region");
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   266
    }
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   267
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
    // The guard page is always committed and should not be committed over.
3587
0140e816d000 6843292: "Expect to be beyond new region unless impacting another region" assertion too strong
jmasa
parents: 2154
diff changeset
   269
    // "guarded" is used for assertion checking below and recalls the fact
0140e816d000 6843292: "Expect to be beyond new region unless impacting another region" assertion too strong
jmasa
parents: 2154
diff changeset
   270
    // that the would-be end of the new committed region would have
0140e816d000 6843292: "Expect to be beyond new region unless impacting another region" assertion too strong
jmasa
parents: 2154
diff changeset
   271
    // penetrated the guard page.
0140e816d000 6843292: "Expect to be beyond new region unless impacting another region" assertion too strong
jmasa
parents: 2154
diff changeset
   272
    HeapWord* new_end_for_commit = new_end_aligned;
0140e816d000 6843292: "Expect to be beyond new region unless impacting another region" assertion too strong
jmasa
parents: 2154
diff changeset
   273
0140e816d000 6843292: "Expect to be beyond new region unless impacting another region" assertion too strong
jmasa
parents: 2154
diff changeset
   274
    DEBUG_ONLY(bool guarded = false;)
0140e816d000 6843292: "Expect to be beyond new region unless impacting another region" assertion too strong
jmasa
parents: 2154
diff changeset
   275
    if (new_end_for_commit > _guard_region.start()) {
0140e816d000 6843292: "Expect to be beyond new region unless impacting another region" assertion too strong
jmasa
parents: 2154
diff changeset
   276
      new_end_for_commit = _guard_region.start();
0140e816d000 6843292: "Expect to be beyond new region unless impacting another region" assertion too strong
jmasa
parents: 2154
diff changeset
   277
      DEBUG_ONLY(guarded = true;)
0140e816d000 6843292: "Expect to be beyond new region unless impacting another region" assertion too strong
jmasa
parents: 2154
diff changeset
   278
    }
754
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   279
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
    if (new_end_for_commit > cur_committed.end()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
      // Must commit new pages.
179
59e3abf83f72 6624765: Guarantee failure "Unexpected dirty card found"
jmasa
parents: 1
diff changeset
   282
      MemRegion const new_committed =
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
        MemRegion(cur_committed.end(), new_end_for_commit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
      assert(!new_committed.is_empty(), "Region should not be empty here");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
      if (!os::commit_memory((char*)new_committed.start(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
                             new_committed.byte_size(), _page_size)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
        // Do better than this for Merlin
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
        vm_exit_out_of_memory(new_committed.byte_size(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
                "card table expansion");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
    // Use new_end_aligned (as opposed to new_end_for_commit) because
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
    // the cur_committed region may include the guard region.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
    } else if (new_end_aligned < cur_committed.end()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
      // Must uncommit pages.
179
59e3abf83f72 6624765: Guarantee failure "Unexpected dirty card found"
jmasa
parents: 1
diff changeset
   296
      MemRegion const uncommit_region =
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
        committed_unique_to_self(ind, MemRegion(new_end_aligned,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
                                                cur_committed.end()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
      if (!uncommit_region.is_empty()) {
5892
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   300
        // It is not safe to uncommit cards if the boundary between
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   301
        // the generations is moving.  A shrink can uncommit cards
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   302
        // owned by generation A but being used by generation B.
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   303
        if (!UseAdaptiveGCBoundary) {
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   304
          if (!os::uncommit_memory((char*)uncommit_region.start(),
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   305
                                   uncommit_region.byte_size())) {
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   306
            assert(false, "Card table contraction failed");
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   307
            // The call failed so don't change the end of the
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   308
            // committed region.  This is better than taking the
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   309
            // VM down.
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   310
            new_end_aligned = _committed[ind].end();
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   311
          }
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   312
        } else {
754
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   313
          new_end_aligned = _committed[ind].end();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
    // In any case, we can reset the end of the current committed entry.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
    _committed[ind].set_end(new_end_aligned);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
5892
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   320
#ifdef ASSERT
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   321
    // Check that the last card in the new region is committed according
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   322
    // to the tables.
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   323
    bool covered = false;
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   324
    for (int cr = 0; cr < _cur_covered_regions; cr++) {
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   325
      if (_committed[cr].contains(new_end - 1)) {
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   326
        covered = true;
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   327
        break;
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   328
      }
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   329
    }
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   330
    assert(covered, "Card for end of new region not committed");
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   331
#endif
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   332
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
    // The default of 0 is not necessarily clean cards.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
    jbyte* entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
    if (old_region.last() < _whole_heap.start()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
      entry = byte_for(_whole_heap.start());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
      entry = byte_after(old_region.last());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
    }
1676
d80e69372634 6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents: 1388
diff changeset
   340
    assert(index_for(new_region.last()) <  _guard_index,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
      "The guard card will be overwritten");
754
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   342
    // This line commented out cleans the newly expanded region and
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   343
    // not the aligned up expanded region.
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   344
    // jbyte* const end = byte_after(new_region.last());
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   345
    jbyte* const end = (jbyte*) new_end_for_commit;
3587
0140e816d000 6843292: "Expect to be beyond new region unless impacting another region" assertion too strong
jmasa
parents: 2154
diff changeset
   346
    assert((end >= byte_after(new_region.last())) || collided || guarded,
754
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   347
      "Expect to be beyond new region unless impacting another region");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
    // do nothing if we resized downward.
754
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   349
#ifdef ASSERT
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   350
    for (int ri = 0; ri < _cur_covered_regions; ri++) {
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   351
      if (ri != ind) {
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   352
        // The end of the new committed region should not
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   353
        // be in any existing region unless it matches
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   354
        // the start of the next region.
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   355
        assert(!_committed[ri].contains(end) ||
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   356
               (_committed[ri].start() == (HeapWord*) end),
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   357
               "Overlapping committed regions");
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   358
      }
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   359
    }
fb9904179b42 6688799: Second fix for Guarantee failure "Unexpected dirty card found"
jmasa
parents: 360
diff changeset
   360
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
    if (entry < end) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
      memset(entry, clean_card, pointer_delta(end, entry, sizeof(jbyte)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  // In any case, the covered size changes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  _covered[ind].set_word_size(new_region.word_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  if (TraceCardTableModRefBS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
    gclog_or_tty->print_cr("CardTableModRefBS::resize_covered_region: ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
    gclog_or_tty->print_cr("  "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
                  "  _covered[%d].start(): " INTPTR_FORMAT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
                  "  _covered[%d].last(): " INTPTR_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
                  ind, _covered[ind].start(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
                  ind, _covered[ind].last());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
    gclog_or_tty->print_cr("  "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
                  "  _committed[%d].start(): " INTPTR_FORMAT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
                  "  _committed[%d].last(): " INTPTR_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
                  ind, _committed[ind].start(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
                  ind, _committed[ind].last());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
    gclog_or_tty->print_cr("  "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
                  "  byte_for(start): " INTPTR_FORMAT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
                  "  byte_for(last): " INTPTR_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
                  byte_for(_covered[ind].start()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
                  byte_for(_covered[ind].last()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
    gclog_or_tty->print_cr("  "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
                  "  addr_for(start): " INTPTR_FORMAT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
                  "  addr_for(last): " INTPTR_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
                  addr_for((jbyte*) _committed[ind].start()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
                  addr_for((jbyte*) _committed[ind].last()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  }
5892
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   390
  // Touch the last card of the covered region to show that it
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   391
  // is committed (or SEGV).
477b32b9d021 6952853: SIGSEGV with UseAdaptiveGCBoundary on 64b linux running jvm2008
jmasa
parents: 5547
diff changeset
   392
  debug_only(*byte_for(_covered[ind].last());)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  debug_only(verify_guard();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
// Note that these versions are precise!  The scanning code has to handle the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
// fact that the write barrier may be either precise or imprecise.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 219
diff changeset
   399
void CardTableModRefBS::write_ref_field_work(void* field, oop newVal) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  inline_write_ref_field(field, newVal);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
2142
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   403
/*
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   404
   Claimed and deferred bits are used together in G1 during the evacuation
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   405
   pause. These bits can have the following state transitions:
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   406
   1. The claimed bit can be put over any other card state. Except that
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   407
      the "dirty -> dirty and claimed" transition is checked for in
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   408
      G1 code and is not used.
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   409
   2. Deferred bit can be set only if the previous state of the card
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   410
      was either clean or claimed. mark_card_deferred() is wait-free.
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   411
      We do not care if the operation is be successful because if
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   412
      it does not it will only result in duplicate entry in the update
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   413
      buffer because of the "cache-miss". So it's not worth spinning.
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   414
 */
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   415
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   417
bool CardTableModRefBS::claim_card(size_t card_index) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   418
  jbyte val = _byte_map[card_index];
2142
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   419
  assert(val != dirty_card_val(), "Shouldn't claim a dirty card");
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   420
  while (val == clean_card_val() ||
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   421
         (val & (clean_card_mask_val() | claimed_card_val())) != claimed_card_val()) {
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   422
    jbyte new_val = val;
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   423
    if (val == clean_card_val()) {
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   424
      new_val = (jbyte)claimed_card_val();
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   425
    } else {
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   426
      new_val = val | (jbyte)claimed_card_val();
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   427
    }
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   428
    jbyte res = Atomic::cmpxchg(new_val, &_byte_map[card_index], val);
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   429
    if (res == val) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   430
      return true;
2142
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   431
    }
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   432
    val = res;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   433
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   434
  return false;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   435
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   436
2142
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   437
bool CardTableModRefBS::mark_card_deferred(size_t card_index) {
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   438
  jbyte val = _byte_map[card_index];
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   439
  // It's already processed
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   440
  if ((val & (clean_card_mask_val() | deferred_card_val())) == deferred_card_val()) {
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   441
    return false;
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   442
  }
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   443
  // Cached bit can be installed either on a clean card or on a claimed card.
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   444
  jbyte new_val = val;
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   445
  if (val == clean_card_val()) {
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   446
    new_val = (jbyte)deferred_card_val();
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   447
  } else {
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   448
    if (val & claimed_card_val()) {
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   449
      new_val = val | (jbyte)deferred_card_val();
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   450
    }
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   451
  }
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   452
  if (new_val != val) {
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   453
    Atomic::cmpxchg(new_val, &_byte_map[card_index], val);
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   454
  }
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   455
  return true;
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   456
}
032f4652700c 6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents: 2107
diff changeset
   457
9336
413920193f83 7037276: Unnecessary double traversal of dirty card windows
ysr
parents: 9183
diff changeset
   458
void CardTableModRefBS::non_clean_card_iterate_possibly_parallel(Space* sp,
413920193f83 7037276: Unnecessary double traversal of dirty card windows
ysr
parents: 9183
diff changeset
   459
                                                                 MemRegion mr,
9624
c3657c3324ee 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents: 9418
diff changeset
   460
                                                                 OopsInGenClosure* cl,
c3657c3324ee 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents: 9418
diff changeset
   461
                                                                 CardTableRS* ct) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  if (!mr.is_empty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
    int n_threads = SharedHeap::heap()->n_par_threads();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
    if (n_threads > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
#ifndef SERIALGC
9624
c3657c3324ee 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents: 9418
diff changeset
   466
      non_clean_card_iterate_parallel_work(sp, mr, cl, ct, n_threads);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
#else  // SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
      fatal("Parallel gc not supported here.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
#endif // SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
    } else {
9336
413920193f83 7037276: Unnecessary double traversal of dirty card windows
ysr
parents: 9183
diff changeset
   471
      // We do not call the non_clean_card_iterate_serial() version below because
413920193f83 7037276: Unnecessary double traversal of dirty card windows
ysr
parents: 9183
diff changeset
   472
      // we want to clear the cards (which non_clean_card_iterate_serial() does not
9624
c3657c3324ee 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents: 9418
diff changeset
   473
      // do for us): clear_cl here does the work of finding contiguous dirty ranges
c3657c3324ee 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents: 9418
diff changeset
   474
      // of cards to process and clear.
c3657c3324ee 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents: 9418
diff changeset
   475
c3657c3324ee 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents: 9418
diff changeset
   476
      DirtyCardToOopClosure* dcto_cl = sp->new_dcto_cl(cl, precision(),
c3657c3324ee 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents: 9418
diff changeset
   477
                                                       cl->gen_boundary());
c3657c3324ee 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents: 9418
diff changeset
   478
      ClearNoncleanCardWrapper clear_cl(dcto_cl, ct);
c3657c3324ee 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents: 9418
diff changeset
   479
c3657c3324ee 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents: 9418
diff changeset
   480
      clear_cl.do_MemRegion(mr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
9336
413920193f83 7037276: Unnecessary double traversal of dirty card windows
ysr
parents: 9183
diff changeset
   485
// The iterator itself is not MT-aware, but
413920193f83 7037276: Unnecessary double traversal of dirty card windows
ysr
parents: 9183
diff changeset
   486
// MT-aware callers and closures can use this to
413920193f83 7037276: Unnecessary double traversal of dirty card windows
ysr
parents: 9183
diff changeset
   487
// accomplish dirty card iteration in parallel. The
413920193f83 7037276: Unnecessary double traversal of dirty card windows
ysr
parents: 9183
diff changeset
   488
// iterator itself does not clear the dirty cards, or
413920193f83 7037276: Unnecessary double traversal of dirty card windows
ysr
parents: 9183
diff changeset
   489
// change their values in any manner.
413920193f83 7037276: Unnecessary double traversal of dirty card windows
ysr
parents: 9183
diff changeset
   490
void CardTableModRefBS::non_clean_card_iterate_serial(MemRegion mr,
413920193f83 7037276: Unnecessary double traversal of dirty card windows
ysr
parents: 9183
diff changeset
   491
                                                      MemRegionClosure* cl) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  for (int i = 0; i < _cur_covered_regions; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
    MemRegion mri = mr.intersection(_covered[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
    if (mri.word_size() > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
      jbyte* cur_entry = byte_for(mri.last());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
      jbyte* limit = byte_for(mri.start());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
      while (cur_entry >= limit) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
        jbyte* next_entry = cur_entry - 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
        if (*cur_entry != clean_card) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
          size_t non_clean_cards = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
          // Should the next card be included in this range of dirty cards.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
          while (next_entry >= limit && *next_entry != clean_card) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
            non_clean_cards++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
            cur_entry = next_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
            next_entry--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
          // The memory region may not be on a card boundary.  So that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
          // objects beyond the end of the region are not processed, make
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
          // cur_cards precise with regard to the end of the memory region.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
          MemRegion cur_cards(addr_for(cur_entry),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
                              non_clean_cards * card_size_in_words);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
          MemRegion dirty_region = cur_cards.intersection(mri);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
          cl->do_MemRegion(dirty_region);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
        cur_entry = next_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
void CardTableModRefBS::dirty_MemRegion(MemRegion mr) {
4461
c17c526d36ef 6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents: 3695
diff changeset
   522
  assert((HeapWord*)align_size_down((uintptr_t)mr.start(), HeapWordSize) == mr.start(), "Unaligned start");
c17c526d36ef 6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents: 3695
diff changeset
   523
  assert((HeapWord*)align_size_up  ((uintptr_t)mr.end(),   HeapWordSize) == mr.end(),   "Unaligned end"  );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  jbyte* cur  = byte_for(mr.start());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  jbyte* last = byte_after(mr.last());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  while (cur < last) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
    *cur = dirty_card;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
    cur++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   532
void CardTableModRefBS::invalidate(MemRegion mr, bool whole_heap) {
4461
c17c526d36ef 6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents: 3695
diff changeset
   533
  assert((HeapWord*)align_size_down((uintptr_t)mr.start(), HeapWordSize) == mr.start(), "Unaligned start");
c17c526d36ef 6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents: 3695
diff changeset
   534
  assert((HeapWord*)align_size_up  ((uintptr_t)mr.end(),   HeapWordSize) == mr.end(),   "Unaligned end"  );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  for (int i = 0; i < _cur_covered_regions; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
    MemRegion mri = mr.intersection(_covered[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
    if (!mri.is_empty()) dirty_MemRegion(mri);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
void CardTableModRefBS::clear_MemRegion(MemRegion mr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  // Be conservative: only clean cards entirely contained within the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  // region.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  jbyte* cur;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  if (mr.start() == _whole_heap.start()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
    cur = byte_for(mr.start());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
    assert(mr.start() > _whole_heap.start(), "mr is not covered.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
    cur = byte_after(mr.start() - 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  jbyte* last = byte_after(mr.last());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  memset(cur, clean_card, pointer_delta(last, cur, sizeof(jbyte)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
void CardTableModRefBS::clear(MemRegion mr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  for (int i = 0; i < _cur_covered_regions; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
    MemRegion mri = mr.intersection(_covered[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
    if (!mri.is_empty()) clear_MemRegion(mri);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   562
void CardTableModRefBS::dirty(MemRegion mr) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   563
  jbyte* first = byte_for(mr.start());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   564
  jbyte* last  = byte_after(mr.last());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   565
  memset(first, dirty_card, last-first);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   566
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   567
9183
3d0e0687fe28 7036482: clear argument is redundant and unused in cardtable methods
ysr
parents: 7397
diff changeset
   568
// Unlike several other card table methods, dirty_card_iterate()
3d0e0687fe28 7036482: clear argument is redundant and unused in cardtable methods
ysr
parents: 7397
diff changeset
   569
// iterates over dirty cards ranges in increasing address order.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
void CardTableModRefBS::dirty_card_iterate(MemRegion mr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
                                           MemRegionClosure* cl) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  for (int i = 0; i < _cur_covered_regions; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
    MemRegion mri = mr.intersection(_covered[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
    if (!mri.is_empty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
      jbyte *cur_entry, *next_entry, *limit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
      for (cur_entry = byte_for(mri.start()), limit = byte_for(mri.last());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
           cur_entry <= limit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
           cur_entry  = next_entry) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
        next_entry = cur_entry + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
        if (*cur_entry == dirty_card) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
          size_t dirty_cards;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
          // Accumulate maximal dirty card range, starting at cur_entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
          for (dirty_cards = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
               next_entry <= limit && *next_entry == dirty_card;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
               dirty_cards++, next_entry++);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
          MemRegion cur_cards(addr_for(cur_entry),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
                              dirty_cards*card_size_in_words);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
          cl->do_MemRegion(cur_cards);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   595
MemRegion CardTableModRefBS::dirty_card_range_after_reset(MemRegion mr,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   596
                                                          bool reset,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   597
                                                          int reset_val) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  for (int i = 0; i < _cur_covered_regions; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
    MemRegion mri = mr.intersection(_covered[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
    if (!mri.is_empty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
      jbyte* cur_entry, *next_entry, *limit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
      for (cur_entry = byte_for(mri.start()), limit = byte_for(mri.last());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
           cur_entry <= limit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
           cur_entry  = next_entry) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
        next_entry = cur_entry + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
        if (*cur_entry == dirty_card) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
          size_t dirty_cards;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
          // Accumulate maximal dirty card range, starting at cur_entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
          for (dirty_cards = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
               next_entry <= limit && *next_entry == dirty_card;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
               dirty_cards++, next_entry++);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
          MemRegion cur_cards(addr_for(cur_entry),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
                              dirty_cards*card_size_in_words);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   614
          if (reset) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   615
            for (size_t i = 0; i < dirty_cards; i++) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   616
              cur_entry[i] = reset_val;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   617
            }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
          return cur_cards;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
  return MemRegion(mr.end(), mr.end());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
// Set all the dirty cards in the given region to "precleaned" state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
void CardTableModRefBS::preclean_dirty_cards(MemRegion mr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
  for (int i = 0; i < _cur_covered_regions; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
    MemRegion mri = mr.intersection(_covered[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
    if (!mri.is_empty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
      jbyte *cur_entry, *limit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
      for (cur_entry = byte_for(mri.start()), limit = byte_for(mri.last());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
           cur_entry <= limit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
           cur_entry++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
        if (*cur_entry == dirty_card) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
          *cur_entry = precleaned_card;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
uintx CardTableModRefBS::ct_max_alignment_constraint() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
  return card_size * os::vm_page_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
void CardTableModRefBS::verify_guard() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  // For product build verification
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
  guarantee(_byte_map[_guard_index] == last_card,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
            "card table guard has been modified");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
void CardTableModRefBS::verify() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
  verify_guard();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
#ifndef PRODUCT
9418
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   659
void CardTableModRefBS::verify_region(MemRegion mr,
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   660
                                      jbyte val, bool val_equals) {
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   661
  jbyte* start    = byte_for(mr.start());
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   662
  jbyte* end      = byte_for(mr.last());
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   663
  bool   failures = false;
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   664
  for (jbyte* curr = start; curr <= end; ++curr) {
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   665
    jbyte curr_val = *curr;
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   666
    bool failed = (val_equals) ? (curr_val != val) : (curr_val == val);
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   667
    if (failed) {
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   668
      if (!failures) {
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   669
        tty->cr();
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   670
        tty->print_cr("== CT verification failed: ["PTR_FORMAT","PTR_FORMAT"]");
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   671
        tty->print_cr("==   %sexpecting value: %d",
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   672
                      (val_equals) ? "" : "not ", val);
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   673
        failures = true;
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   674
      }
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   675
      tty->print_cr("==   card "PTR_FORMAT" ["PTR_FORMAT","PTR_FORMAT"], "
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   676
                    "val: %d", curr, addr_for(curr),
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   677
                    (HeapWord*) (((size_t) addr_for(curr)) + card_size),
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   678
                    (int) curr_val);
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   679
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
  }
9418
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   681
  guarantee(!failures, "there should not have been any failures");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
}
3695
421cfcc8843c 6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents: 3587
diff changeset
   683
9418
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   684
void CardTableModRefBS::verify_not_dirty_region(MemRegion mr) {
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   685
  verify_region(mr, dirty_card, false /* val_equals */);
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   686
}
3695
421cfcc8843c 6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents: 3587
diff changeset
   687
421cfcc8843c 6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents: 3587
diff changeset
   688
void CardTableModRefBS::verify_dirty_region(MemRegion mr) {
9418
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9336
diff changeset
   689
  verify_region(mr, dirty_card, true /* val_equals */);
3695
421cfcc8843c 6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents: 3587
diff changeset
   690
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
bool CardTableModRefBSForCTRS::card_will_be_scanned(jbyte cv) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
  return
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
    CardTableModRefBS::card_will_be_scanned(cv) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
    _rs->is_prev_nonclean_card_val(cv);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
bool CardTableModRefBSForCTRS::card_may_have_been_dirty(jbyte cv) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
  return
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
    cv != clean_card &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
    (CardTableModRefBS::card_may_have_been_dirty(cv) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
     CardTableRS::youngergen_may_have_been_dirty(cv));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
};