hotspot/src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.hpp
author jmasa
Fri, 01 Aug 2014 15:40:12 -0700
changeset 25905 04a3d83cc752
parent 24424 2658d7834c6e
permissions -rw-r--r--
8031323: Optionally align objects copied to survivor spaces Reviewed-by: brutisso, tschatzl
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17627
diff changeset
     2
 * Copyright (c) 2005, 2014, 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: 3261
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3261
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: 3261
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: 5547
diff changeset
    25
#ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARMARKBITMAP_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    26
#define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARMARKBITMAP_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    27
7408
c04a5c989f26 7003125: precompiled.hpp is included when precompiled headers are not used
stefank
parents: 7397
diff changeset
    28
#include "memory/memRegion.hpp"
17390
f6f515533813 8014339: Improve assert and remove some dead code from parMarkBitMap.hpp/cpp
brutisso
parents: 16685
diff changeset
    29
#include "oops/oop.hpp"
f6f515533813 8014339: Improve assert and remove some dead code from parMarkBitMap.hpp/cpp
brutisso
parents: 16685
diff changeset
    30
#include "utilities/bitMap.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    31
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
class ParMarkBitMapClosure;
17390
f6f515533813 8014339: Improve assert and remove some dead code from parMarkBitMap.hpp/cpp
brutisso
parents: 16685
diff changeset
    33
class PSVirtualSpace;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 7408
diff changeset
    35
class ParMarkBitMap: public CHeapObj<mtGC>
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
  typedef BitMap::idx_t idx_t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
  // Values returned by the iterate() methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
  enum IterationStatus { incomplete, complete, full, would_overflow };
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
  inline ParMarkBitMap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
  bool initialize(MemRegion covered_region);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
  // Atomically mark an object as live.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
  bool mark_obj(HeapWord* addr, size_t size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  inline bool mark_obj(oop obj, int size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  // Return whether the specified begin or end bit is set.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  inline bool is_obj_beg(idx_t bit) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  inline bool is_obj_end(idx_t bit) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  // Traditional interface for testing whether an object is marked or not (these
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  // test only the begin bits).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  inline bool is_marked(idx_t bit)      const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  inline bool is_marked(HeapWord* addr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  inline bool is_marked(oop obj)        const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  inline bool is_unmarked(idx_t bit)      const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  inline bool is_unmarked(HeapWord* addr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  inline bool is_unmarked(oop obj)        const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  // Convert sizes from bits to HeapWords and back.  An object that is n bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  // long will be bits_to_words(n) words long.  An object that is m words long
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  // will take up words_to_bits(m) bits in the bitmap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  inline static size_t bits_to_words(idx_t bits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  inline static idx_t  words_to_bits(size_t words);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  // Return the size in words of an object given a begin bit and an end bit, or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  // the equivalent beg_addr and end_addr.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  inline size_t obj_size(idx_t beg_bit, idx_t end_bit) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  inline size_t obj_size(HeapWord* beg_addr, HeapWord* end_addr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  // Return the size in words of the object (a search is done for the end bit).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  inline size_t obj_size(idx_t beg_bit)  const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  inline size_t obj_size(HeapWord* addr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  // Apply live_closure to each live object that lies completely within the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  // range [live_range_beg, live_range_end).  This is used to iterate over the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  // compacted region of the heap.  Return values:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  // incomplete         The iteration is not complete.  The last object that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  //                    begins in the range does not end in the range;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  //                    closure->source() is set to the start of that object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  // complete           The iteration is complete.  All objects in the range
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  //                    were processed and the closure is not full;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  //                    closure->source() is set one past the end of the range.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  // full               The closure is full; closure->source() is set to one
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  //                    past the end of the last object processed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  // would_overflow     The next object in the range would overflow the closure;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  //                    closure->source() is set to the start of that object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  IterationStatus iterate(ParMarkBitMapClosure* live_closure,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
                          idx_t range_beg, idx_t range_end) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  inline IterationStatus iterate(ParMarkBitMapClosure* live_closure,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
                                 HeapWord* range_beg,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
                                 HeapWord* range_end) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  // Apply live closure as above and additionally apply dead_closure to all dead
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  // space in the range [range_beg, dead_range_end).  Note that dead_range_end
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  // must be >= range_end.  This is used to iterate over the dense prefix.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  // This method assumes that if the first bit in the range (range_beg) is not
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  // marked, then dead space begins at that point and the dead_closure is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  // applied.  Thus callers must ensure that range_beg is not in the middle of a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  // live object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  IterationStatus iterate(ParMarkBitMapClosure* live_closure,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
                          ParMarkBitMapClosure* dead_closure,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
                          idx_t range_beg, idx_t range_end,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
                          idx_t dead_range_end) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  inline IterationStatus iterate(ParMarkBitMapClosure* live_closure,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
                                 ParMarkBitMapClosure* dead_closure,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
                                 HeapWord* range_beg,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
                                 HeapWord* range_end,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
                                 HeapWord* dead_range_end) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
17390
f6f515533813 8014339: Improve assert and remove some dead code from parMarkBitMap.hpp/cpp
brutisso
parents: 16685
diff changeset
   120
  // Return the number of live words in the range [beg_addr, end_obj) due to
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  // objects that start in the range.  If a live object extends onto the range,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  // the caller must detect and account for any live words due to that object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  // If a live object extends beyond the end of the range, only the words within
17390
f6f515533813 8014339: Improve assert and remove some dead code from parMarkBitMap.hpp/cpp
brutisso
parents: 16685
diff changeset
   124
  // the range are included in the result. The end of the range must be a live object,
f6f515533813 8014339: Improve assert and remove some dead code from parMarkBitMap.hpp/cpp
brutisso
parents: 16685
diff changeset
   125
  // which is the case when updating pointers.  This allows a branch to be removed
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  // from inside the loop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  size_t live_words_in_range(HeapWord* beg_addr, oop end_obj) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  inline HeapWord* region_start() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  inline HeapWord* region_end() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  inline size_t    region_size() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  inline size_t    size() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
17627
325871034f2c 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap
tamao
parents: 17390
diff changeset
   134
  size_t reserved_byte_size() const { return _reserved_byte_size; }
325871034f2c 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap
tamao
parents: 17390
diff changeset
   135
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  // Convert a heap address to/from a bit index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  inline idx_t     addr_to_bit(HeapWord* addr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  inline HeapWord* bit_to_addr(idx_t bit) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  // Return the bit index of the first marked object that begins (or ends,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  // respectively) in the range [beg, end).  If no object is found, return end.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  inline idx_t find_obj_beg(idx_t beg, idx_t end) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  inline idx_t find_obj_end(idx_t beg, idx_t end) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  inline HeapWord* find_obj_beg(HeapWord* beg, HeapWord* end) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  inline HeapWord* find_obj_end(HeapWord* beg, HeapWord* end) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  // Clear a range of bits or the entire bitmap (both begin and end bits are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  // cleared).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  inline void clear_range(idx_t beg, idx_t end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  // Return the number of bits required to represent the specified number of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // HeapWords, or the specified region.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  static inline idx_t bits_required(size_t words);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  static inline idx_t bits_required(MemRegion covered_region);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
16685
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 13963
diff changeset
   157
  void print_on_error(outputStream* st) const {
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17627
diff changeset
   158
    st->print_cr("Marking Bits: (ParMarkBitMap*) " PTR_FORMAT, p2i(this));
16685
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 13963
diff changeset
   159
    _beg_bits.print_on_error(st, " Begin Bits: ");
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 13963
diff changeset
   160
    _end_bits.print_on_error(st, " End Bits:   ");
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 13963
diff changeset
   161
  }
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 13963
diff changeset
   162
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
#ifdef  ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  void verify_clear() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  inline void verify_bit(idx_t bit) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  inline void verify_addr(HeapWord* addr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
#endif  // #ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  // Each bit in the bitmap represents one unit of 'object granularity.' Objects
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  // are double-word aligned in 32-bit VMs, but not in 64-bit VMs, so the 32-bit
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  // granularity is 2, 64-bit is 1.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  static inline size_t obj_granularity() { return size_t(MinObjAlignment); }
2997
69cd0f7ac5d6 6814552: par compact - some compilers fail to optimize bitmap code
jcoomes
parents: 1374
diff changeset
   174
  static inline int obj_granularity_shift() { return LogMinObjAlignment; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  HeapWord*       _region_start;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  size_t          _region_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  BitMap          _beg_bits;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  BitMap          _end_bits;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  PSVirtualSpace* _virtual_space;
17627
325871034f2c 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap
tamao
parents: 17390
diff changeset
   181
  size_t          _reserved_byte_size;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
inline ParMarkBitMap::ParMarkBitMap():
17627
325871034f2c 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap
tamao
parents: 17390
diff changeset
   185
  _beg_bits(), _end_bits(), _region_start(NULL), _region_size(0), _virtual_space(NULL), _reserved_byte_size(0)
17390
f6f515533813 8014339: Improve assert and remove some dead code from parMarkBitMap.hpp/cpp
brutisso
parents: 16685
diff changeset
   186
{ }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
inline void ParMarkBitMap::clear_range(idx_t beg, idx_t end)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  _beg_bits.clear_range(beg, end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  _end_bits.clear_range(beg, 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
inline ParMarkBitMap::idx_t
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
ParMarkBitMap::bits_required(size_t words)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  // Need two bits (one begin bit, one end bit) for each unit of 'object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  // granularity' in the heap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  return words_to_bits(words * 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
inline ParMarkBitMap::idx_t
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
ParMarkBitMap::bits_required(MemRegion covered_region)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  return bits_required(covered_region.word_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
inline HeapWord*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
ParMarkBitMap::region_start() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  return _region_start;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
inline HeapWord*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
ParMarkBitMap::region_end() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  return region_start() + region_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
inline size_t
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
ParMarkBitMap::region_size() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  return _region_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
inline size_t
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
ParMarkBitMap::size() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  return _beg_bits.size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
inline bool ParMarkBitMap::is_obj_beg(idx_t bit) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  return _beg_bits.at(bit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
inline bool ParMarkBitMap::is_obj_end(idx_t bit) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  return _end_bits.at(bit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
inline bool ParMarkBitMap::is_marked(idx_t bit) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  return is_obj_beg(bit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
inline bool ParMarkBitMap::is_marked(HeapWord* addr) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  return is_marked(addr_to_bit(addr));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
inline bool ParMarkBitMap::is_marked(oop obj) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  return is_marked((HeapWord*)obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
inline bool ParMarkBitMap::is_unmarked(idx_t bit) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  return !is_marked(bit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
inline bool ParMarkBitMap::is_unmarked(HeapWord* addr) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  return !is_marked(addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
inline bool ParMarkBitMap::is_unmarked(oop obj) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  return !is_marked(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
inline size_t
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
ParMarkBitMap::bits_to_words(idx_t bits)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
{
2997
69cd0f7ac5d6 6814552: par compact - some compilers fail to optimize bitmap code
jcoomes
parents: 1374
diff changeset
   275
  return bits << obj_granularity_shift();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
inline ParMarkBitMap::idx_t
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
ParMarkBitMap::words_to_bits(size_t words)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
{
2997
69cd0f7ac5d6 6814552: par compact - some compilers fail to optimize bitmap code
jcoomes
parents: 1374
diff changeset
   281
  return words >> obj_granularity_shift();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
inline size_t ParMarkBitMap::obj_size(idx_t beg_bit, idx_t end_bit) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  DEBUG_ONLY(verify_bit(beg_bit);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  DEBUG_ONLY(verify_bit(end_bit);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  return bits_to_words(end_bit - beg_bit + 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
inline size_t
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
ParMarkBitMap::obj_size(HeapWord* beg_addr, HeapWord* end_addr) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  DEBUG_ONLY(verify_addr(beg_addr);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  DEBUG_ONLY(verify_addr(end_addr);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  return pointer_delta(end_addr, beg_addr) + obj_granularity();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
inline size_t ParMarkBitMap::obj_size(idx_t beg_bit) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
{
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   301
  const idx_t end_bit = _end_bits.get_next_one_offset_inline(beg_bit, size());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  assert(is_marked(beg_bit), "obj not marked");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  assert(end_bit < size(), "end bit missing");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  return obj_size(beg_bit, end_bit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
inline size_t ParMarkBitMap::obj_size(HeapWord* addr) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  return obj_size(addr_to_bit(addr));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
inline ParMarkBitMap::IterationStatus
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
ParMarkBitMap::iterate(ParMarkBitMapClosure* live_closure,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
                       HeapWord* range_beg,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
                       HeapWord* range_end) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  return iterate(live_closure, addr_to_bit(range_beg), addr_to_bit(range_end));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
inline ParMarkBitMap::IterationStatus
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
ParMarkBitMap::iterate(ParMarkBitMapClosure* live_closure,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
                       ParMarkBitMapClosure* dead_closure,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
                       HeapWord* range_beg,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
                       HeapWord* range_end,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
                       HeapWord* dead_range_end) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  return iterate(live_closure, dead_closure,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
                 addr_to_bit(range_beg), addr_to_bit(range_end),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
                 addr_to_bit(dead_range_end));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
inline bool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
ParMarkBitMap::mark_obj(oop obj, int size)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  return mark_obj((HeapWord*)obj, (size_t)size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
inline BitMap::idx_t
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
ParMarkBitMap::addr_to_bit(HeapWord* addr) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  DEBUG_ONLY(verify_addr(addr);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  return words_to_bits(pointer_delta(addr, region_start()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
inline HeapWord*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
ParMarkBitMap::bit_to_addr(idx_t bit) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  DEBUG_ONLY(verify_bit(bit);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  return region_start() + bits_to_words(bit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
inline ParMarkBitMap::idx_t
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
ParMarkBitMap::find_obj_beg(idx_t beg, idx_t end) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
{
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   355
  return _beg_bits.get_next_one_offset_inline_aligned_right(beg, end);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
inline ParMarkBitMap::idx_t
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
ParMarkBitMap::find_obj_end(idx_t beg, idx_t end) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
{
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   361
  return _end_bits.get_next_one_offset_inline_aligned_right(beg, end);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
inline HeapWord*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
ParMarkBitMap::find_obj_beg(HeapWord* beg, HeapWord* end) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  const idx_t beg_bit = addr_to_bit(beg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  const idx_t end_bit = addr_to_bit(end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  const idx_t search_end = BitMap::word_align_up(end_bit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  const idx_t res_bit = MIN2(find_obj_beg(beg_bit, search_end), end_bit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  return bit_to_addr(res_bit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
inline HeapWord*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
ParMarkBitMap::find_obj_end(HeapWord* beg, HeapWord* end) const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  const idx_t beg_bit = addr_to_bit(beg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  const idx_t end_bit = addr_to_bit(end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  const idx_t search_end = BitMap::word_align_up(end_bit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  const idx_t res_bit = MIN2(find_obj_end(beg_bit, search_end), end_bit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  return bit_to_addr(res_bit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
#ifdef  ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
inline void ParMarkBitMap::verify_bit(idx_t bit) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  // Allow one past the last valid bit; useful for loop bounds.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  assert(bit <= _beg_bits.size(), "bit out of range");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
inline void ParMarkBitMap::verify_addr(HeapWord* addr) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  // Allow one past the last valid address; useful for loop bounds.
17390
f6f515533813 8014339: Improve assert and remove some dead code from parMarkBitMap.hpp/cpp
brutisso
parents: 16685
diff changeset
   392
  assert(addr >= region_start(),
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17627
diff changeset
   393
      err_msg("addr too small, addr: " PTR_FORMAT " region start: " PTR_FORMAT, p2i(addr), p2i(region_start())));
17390
f6f515533813 8014339: Improve assert and remove some dead code from parMarkBitMap.hpp/cpp
brutisso
parents: 16685
diff changeset
   394
  assert(addr <= region_end(),
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17627
diff changeset
   395
      err_msg("addr too big, addr: " PTR_FORMAT " region end: " PTR_FORMAT, p2i(addr), p2i(region_end())));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
#endif  // #ifdef ASSERT
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   398
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   399
#endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PARMARKBITMAP_HPP