< prev index next >

src/hotspot/share/gc/g1/g1BlockOffsetTable.inline.hpp

Print this page




  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_G1_G1BLOCKOFFSETTABLE_INLINE_HPP
  26 #define SHARE_GC_G1_G1BLOCKOFFSETTABLE_INLINE_HPP
  27 
  28 #include "gc/g1/g1BlockOffsetTable.hpp"
  29 #include "gc/g1/heapRegion.hpp"
  30 #include "gc/shared/memset_with_concurrent_readers.hpp"
  31 #include "gc/shared/space.hpp"
  32 #include "runtime/atomic.hpp"
  33 
  34 inline HeapWord* G1BlockOffsetTablePart::block_start(const void* addr) {
  35   if (addr >= _space->bottom() && addr < _space->end()) {
  36     HeapWord* q = block_at_or_preceding(addr, true, _next_offset_index-1);
  37     return forward_to_block_containing_addr(q, addr);
  38   } else {
  39     return NULL;
  40   }
  41 }
  42 
  43 inline HeapWord* G1BlockOffsetTablePart::block_start_const(const void* addr) const {
  44   if (addr >= _space->bottom() && addr < _space->end()) {
  45     HeapWord* q = block_at_or_preceding(addr, true, _next_offset_index-1);
  46     HeapWord* n = q + block_size(q);
  47     return forward_to_block_containing_addr_const(q, n, addr);
  48   } else {
  49     return NULL;
  50   }
  51 }
  52 
  53 u_char G1BlockOffsetTable::offset_array(size_t index) const {
  54   check_index(index, "index out of range");
  55   return Atomic::load(&_offset_array[index]);
  56 }
  57 
  58 void G1BlockOffsetTable::set_offset_array_raw(size_t index, u_char offset) {
  59   Atomic::store(offset, &_offset_array[index]);
  60 }
  61 
  62 void G1BlockOffsetTable::set_offset_array(size_t index, u_char offset) {
  63   check_index(index, "index out of range");
  64   set_offset_array_raw(index, offset);
  65 }
  66 
  67 void G1BlockOffsetTable::set_offset_array(size_t index, HeapWord* high, HeapWord* low) {
  68   check_index(index, "index out of range");
  69   assert(high >= low, "addresses out of order");
  70   size_t offset = pointer_delta(high, low);
  71   check_offset(offset, "offset too large");
  72   set_offset_array(index, (u_char)offset);
  73 }
  74 
  75 void G1BlockOffsetTable::set_offset_array(size_t left, size_t right, u_char offset) {
  76   check_index(right, "right index out of range");
  77   assert(left <= right, "indexes out of order");
  78   size_t num_cards = right - left + 1;
  79   memset_with_concurrent_readers
  80     (const_cast<u_char*> (&_offset_array[left]), offset, num_cards);
  81 }
  82 
  83 // Variant of index_for that does not check the index for validity.
  84 inline size_t G1BlockOffsetTable::index_for_raw(const void* p) const {
  85   return pointer_delta((char*)p, _reserved.start(), sizeof(char)) >> BOTConstants::LogN;
  86 }
  87 
  88 inline size_t G1BlockOffsetTable::index_for(const void* p) const {
  89   char* pc = (char*)p;
  90   assert(pc >= (char*)_reserved.start() &&
  91          pc <  (char*)_reserved.end(),
  92          "p (" PTR_FORMAT ") not in reserved [" PTR_FORMAT ", " PTR_FORMAT ")",
  93          p2i(p), p2i(_reserved.start()), p2i(_reserved.end()));
  94   size_t result = index_for_raw(p);
  95   check_index(result, "bad index from address");
  96   return result;
  97 }
  98 
  99 inline HeapWord* G1BlockOffsetTable::address_for_index(size_t index) const {
 100   check_index(index, "index out of range");




  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_G1_G1BLOCKOFFSETTABLE_INLINE_HPP
  26 #define SHARE_GC_G1_G1BLOCKOFFSETTABLE_INLINE_HPP
  27 
  28 #include "gc/g1/g1BlockOffsetTable.hpp"
  29 #include "gc/g1/heapRegion.hpp"
  30 #include "gc/shared/memset_with_concurrent_readers.hpp"
  31 #include "gc/shared/space.hpp"

  32 
  33 inline HeapWord* G1BlockOffsetTablePart::block_start(const void* addr) {
  34   if (addr >= _space->bottom() && addr < _space->end()) {
  35     HeapWord* q = block_at_or_preceding(addr, true, _next_offset_index-1);
  36     return forward_to_block_containing_addr(q, addr);
  37   } else {
  38     return NULL;
  39   }
  40 }
  41 
  42 inline HeapWord* G1BlockOffsetTablePart::block_start_const(const void* addr) const {
  43   if (addr >= _space->bottom() && addr < _space->end()) {
  44     HeapWord* q = block_at_or_preceding(addr, true, _next_offset_index-1);
  45     HeapWord* n = q + block_size(q);
  46     return forward_to_block_containing_addr_const(q, n, addr);
  47   } else {
  48     return NULL;
  49   }
  50 }
  51 
  52 u_char G1BlockOffsetTable::offset_array(size_t index) const {
  53   check_index(index, "index out of range");
  54   return _offset_array[index];




  55 }
  56 
  57 void G1BlockOffsetTable::set_offset_array(size_t index, u_char offset) {
  58   check_index(index, "index out of range");
  59   set_offset_array_raw(index, offset);
  60 }
  61 
  62 void G1BlockOffsetTable::set_offset_array(size_t index, HeapWord* high, HeapWord* low) {
  63   check_index(index, "index out of range");
  64   assert(high >= low, "addresses out of order");
  65   size_t offset = pointer_delta(high, low);
  66   check_offset(offset, "offset too large");
  67   set_offset_array(index, (u_char)offset);
  68 }
  69 
  70 void G1BlockOffsetTable::set_offset_array(size_t left, size_t right, u_char offset) {
  71   check_index(right, "right index out of range");
  72   assert(left <= right, "indexes out of order");
  73   size_t num_cards = right - left + 1;
  74   memset_with_concurrent_readers(&_offset_array[left], offset, num_cards);

  75 }
  76 
  77 // Variant of index_for that does not check the index for validity.
  78 inline size_t G1BlockOffsetTable::index_for_raw(const void* p) const {
  79   return pointer_delta((char*)p, _reserved.start(), sizeof(char)) >> BOTConstants::LogN;
  80 }
  81 
  82 inline size_t G1BlockOffsetTable::index_for(const void* p) const {
  83   char* pc = (char*)p;
  84   assert(pc >= (char*)_reserved.start() &&
  85          pc <  (char*)_reserved.end(),
  86          "p (" PTR_FORMAT ") not in reserved [" PTR_FORMAT ", " PTR_FORMAT ")",
  87          p2i(p), p2i(_reserved.start()), p2i(_reserved.end()));
  88   size_t result = index_for_raw(p);
  89   check_index(result, "bad index from address");
  90   return result;
  91 }
  92 
  93 inline HeapWord* G1BlockOffsetTable::address_for_index(size_t index) const {
  94   check_index(index, "index out of range");


< prev index next >