1 /*
   2  * Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_GC_PARALLEL_PARMARKBITMAP_INLINE_HPP
  26 #define SHARE_GC_PARALLEL_PARMARKBITMAP_INLINE_HPP
  27 
  28 #include "gc/parallel/parMarkBitMap.hpp"
  29 #include "utilities/align.hpp"
  30 #include "utilities/bitMap.inline.hpp"
  31 
  32 inline ParMarkBitMap::ParMarkBitMap():
  33   _region_start(NULL), _region_size(0), _beg_bits(), _end_bits(), _virtual_space(NULL), _reserved_byte_size(0)
  34 { }
  35 
  36 inline void ParMarkBitMap::clear_range(idx_t beg, idx_t end) {
  37   _beg_bits.clear_range(beg, end);
  38   _end_bits.clear_range(beg, end);
  39 }
  40 
  41 inline ParMarkBitMap::idx_t ParMarkBitMap::bits_required(size_t words) {
  42   // Need two bits (one begin bit, one end bit) for each unit of 'object
  43   // granularity' in the heap.
  44   return words_to_bits(words * 2);
  45 }
  46 
  47 inline ParMarkBitMap::idx_t ParMarkBitMap::bits_required(MemRegion covered_region) {
  48   return bits_required(covered_region.word_size());
  49 }
  50 
  51 inline HeapWord* ParMarkBitMap::region_start() const {
  52   return _region_start;
  53 }
  54 
  55 inline HeapWord* ParMarkBitMap::region_end() const {
  56   return region_start() + region_size();
  57 }
  58 
  59 inline size_t ParMarkBitMap::region_size() const {
  60   return _region_size;
  61 }
  62 
  63 inline size_t ParMarkBitMap::size() const {
  64   return _beg_bits.size();
  65 }
  66 
  67 inline bool ParMarkBitMap::is_obj_beg(idx_t bit) const {
  68   return _beg_bits.at(bit);
  69 }
  70 
  71 inline bool ParMarkBitMap::is_obj_end(idx_t bit) const {
  72   return _end_bits.at(bit);
  73 }
  74 
  75 inline bool ParMarkBitMap::is_marked(idx_t bit) const {
  76   return is_obj_beg(bit);
  77 }
  78 
  79 inline bool ParMarkBitMap::is_marked(HeapWord* addr) const {
  80   return is_marked(addr_to_bit(addr));
  81 }
  82 
  83 inline bool ParMarkBitMap::is_marked(oop obj) const {
  84   return is_marked((HeapWord*)obj);
  85 }
  86 
  87 inline bool ParMarkBitMap::is_unmarked(idx_t bit) const {
  88   return !is_marked(bit);
  89 }
  90 
  91 inline bool ParMarkBitMap::is_unmarked(HeapWord* addr) const {
  92   return !is_marked(addr);
  93 }
  94 
  95 inline bool ParMarkBitMap::is_unmarked(oop obj) const {
  96   return !is_marked(obj);
  97 }
  98 
  99 inline size_t ParMarkBitMap::bits_to_words(idx_t bits) {
 100   return bits << obj_granularity_shift();
 101 }
 102 
 103 inline ParMarkBitMap::idx_t ParMarkBitMap::words_to_bits(size_t words) {
 104   return words >> obj_granularity_shift();
 105 }
 106 
 107 inline size_t ParMarkBitMap::obj_size(idx_t beg_bit, idx_t end_bit) const {
 108   DEBUG_ONLY(verify_bit(beg_bit);)
 109   DEBUG_ONLY(verify_bit(end_bit);)
 110   return bits_to_words(end_bit - beg_bit + 1);
 111 }
 112 
 113 inline size_t ParMarkBitMap::obj_size(HeapWord* beg_addr, HeapWord* end_addr) const {
 114   DEBUG_ONLY(verify_addr(beg_addr);)
 115   DEBUG_ONLY(verify_addr(end_addr);)
 116   return pointer_delta(end_addr, beg_addr) + obj_granularity();
 117 }
 118 
 119 inline size_t ParMarkBitMap::obj_size(idx_t beg_bit) const {
 120   const idx_t end_bit = _end_bits.get_next_one_offset(beg_bit, size());
 121   assert(is_marked(beg_bit), "obj not marked");
 122   assert(end_bit < size(), "end bit missing");
 123   return obj_size(beg_bit, end_bit);
 124 }
 125 
 126 inline size_t ParMarkBitMap::obj_size(HeapWord* addr) const {
 127   return obj_size(addr_to_bit(addr));
 128 }
 129 
 130 inline ParMarkBitMap::IterationStatus ParMarkBitMap::iterate(ParMarkBitMapClosure* live_closure,
 131                                                              HeapWord* range_beg,
 132                                                              HeapWord* range_end) const {
 133   return iterate(live_closure, addr_to_bit(range_beg), addr_to_bit(range_end));
 134 }
 135 
 136 inline ParMarkBitMap::IterationStatus ParMarkBitMap::iterate(ParMarkBitMapClosure* live_closure,
 137                                                              ParMarkBitMapClosure* dead_closure,
 138                                                              HeapWord* range_beg,
 139                                                              HeapWord* range_end,
 140                                                              HeapWord* dead_range_end) const {
 141   return iterate(live_closure, dead_closure,
 142                  addr_to_bit(range_beg), addr_to_bit(range_end),
 143                  addr_to_bit(dead_range_end));
 144 }
 145 
 146 inline bool ParMarkBitMap::mark_obj(oop obj, int size) {
 147   return mark_obj((HeapWord*)obj, (size_t)size);
 148 }
 149 
 150 inline ParMarkBitMap::idx_t ParMarkBitMap::addr_to_bit(HeapWord* addr) const {
 151   DEBUG_ONLY(verify_addr(addr);)
 152   return words_to_bits(pointer_delta(addr, region_start()));
 153 }
 154 
 155 inline HeapWord* ParMarkBitMap::bit_to_addr(idx_t bit) const {
 156   DEBUG_ONLY(verify_bit(bit);)
 157   return region_start() + bits_to_words(bit);
 158 }
 159 
 160 inline ParMarkBitMap::idx_t ParMarkBitMap::align_range_end(idx_t range_end) const {
 161   // size is aligned, so if range_end <= size then so is aligned result.
 162   assert(range_end <= size(), "range end out of range");
 163   return align_up(range_end, BitsPerWord);
 164 }
 165 
 166 inline ParMarkBitMap::idx_t ParMarkBitMap::find_obj_beg(idx_t beg, idx_t end) const {
 167   return _beg_bits.get_next_one_offset_aligned_right(beg, end);
 168 }
 169 
 170 inline ParMarkBitMap::idx_t ParMarkBitMap::find_obj_end(idx_t beg, idx_t end) const {
 171   return _end_bits.get_next_one_offset_aligned_right(beg, end);
 172 }
 173 
 174 inline HeapWord* ParMarkBitMap::find_obj_beg(HeapWord* beg, HeapWord* end) const {
 175   const idx_t beg_bit = addr_to_bit(beg);
 176   const idx_t end_bit = addr_to_bit(end);
 177   const idx_t search_end = align_range_end(end_bit);
 178   const idx_t res_bit = MIN2(find_obj_beg(beg_bit, search_end), end_bit);
 179   return bit_to_addr(res_bit);
 180 }
 181 
 182 inline HeapWord* ParMarkBitMap::find_obj_end(HeapWord* beg, HeapWord* end) const {
 183   const idx_t beg_bit = addr_to_bit(beg);
 184   const idx_t end_bit = addr_to_bit(end);
 185   const idx_t search_end = align_range_end(end_bit);
 186   const idx_t res_bit = MIN2(find_obj_end(beg_bit, search_end), end_bit);
 187   return bit_to_addr(res_bit);
 188 }
 189 
 190 #ifdef  ASSERT
 191 inline void ParMarkBitMap::verify_bit(idx_t bit) const {
 192   // Allow one past the last valid bit; useful for loop bounds.
 193   assert(bit <= _beg_bits.size(), "bit out of range");
 194 }
 195 
 196 inline void ParMarkBitMap::verify_addr(HeapWord* addr) const {
 197   // Allow one past the last valid address; useful for loop bounds.
 198   assert(addr >= region_start(),
 199          "addr too small, addr: " PTR_FORMAT " region start: " PTR_FORMAT, p2i(addr), p2i(region_start()));
 200   assert(addr <= region_end(),
 201          "addr too big, addr: " PTR_FORMAT " region end: " PTR_FORMAT, p2i(addr), p2i(region_end()));
 202 }
 203 #endif  // #ifdef ASSERT
 204 
 205 #endif // SHARE_GC_PARALLEL_PARMARKBITMAP_INLINE_HPP