src/share/vm/gc/shared/blockOffsetTable.hpp

rev 8796 : imported patch usenewfun

*** 23,35 ****
--- 23,38 ----
   */
  
  #ifndef SHARE_VM_GC_SHARED_BLOCKOFFSETTABLE_HPP
  #define SHARE_VM_GC_SHARED_BLOCKOFFSETTABLE_HPP
  
+ #include "gc/shared/memset_with_concurrent_readers.hpp"
  #include "memory/memRegion.hpp"
  #include "memory/virtualspace.hpp"
+ #include "runtime/globals.hpp"
  #include "utilities/globalDefinitions.hpp"
+ #include "utilities/macros.hpp"
  
  // The CollectedHeap type requires subtypes to implement a method
  // "block_start".  For some subtypes, notably generational
  // systems using card-table-based write barriers, the efficiency of this
  // operation may be important.  Implementations of the "BlockOffsetArray"
*** 124,133 ****
--- 127,149 ----
    // Array for keeping offsets for retrieving object start fast given an
    // address.
    VirtualSpace _vs;
    u_char* _offset_array;          // byte array keeping backwards offsets
  
+   void fill_range(size_t start, size_t num_cards, u_char offset) {
+     void* start_ptr = &_offset_array[start];
+ #if INCLUDE_ALL_GCS
+     // If collector is concurrent, special handling may be needed.
+     assert(!UseG1GC, "Shouldn't be here when using G1");
+     if (UseConcMarkSweepGC) {
+       memset_with_concurrent_readers(start_ptr, offset, num_cards);
+       return;
+     }
+ #endif // INCLUDE_ALL_GCS
+     memset(start_ptr, offset, num_cards);
+   }
+ 
   protected:
    // Bounds checking accessors:
    // For performance these have to devolve to array accesses in product builds.
    u_char offset_array(size_t index) const {
      assert(index < _vs.committed_size(), "index out of range");
*** 158,203 ****
      assert(index_for(right - 1) < _vs.committed_size(),
             "right address out of range");
      assert(left  < right, "Heap addresses out of order");
      size_t num_cards = pointer_delta(right, left) >> LogN_words;
  
!     // Below, we may use an explicit loop instead of memset()
!     // because on certain platforms memset() can give concurrent
!     // readers "out-of-thin-air," phantom zeros; see 6948537.
!     if (UseMemSetInBOT) {
!       memset(&_offset_array[index_for(left)], offset, num_cards);
!     } else {
!       size_t i = index_for(left);
!       const size_t end = i + num_cards;
!       for (; i < end; i++) {
!         // Elided until CR 6977974 is fixed properly.
!         // assert(!reducing || _offset_array[i] >= offset, "Not reducing");
!         _offset_array[i] = offset;
!       }
!     }
    }
  
    void set_offset_array(size_t left, size_t right, u_char offset, bool reducing = false) {
      check_reducing_assertion(reducing);
      assert(right < _vs.committed_size(), "right address out of range");
      assert(left  <= right, "indexes out of order");
      size_t num_cards = right - left + 1;
  
!     // Below, we may use an explicit loop instead of memset
!     // because on certain platforms memset() can give concurrent
!     // readers "out-of-thin-air," phantom zeros; see 6948537.
!     if (UseMemSetInBOT) {
!       memset(&_offset_array[left], offset, num_cards);
!     } else {
!       size_t i = left;
!       const size_t end = i + num_cards;
!       for (; i < end; i++) {
!         // Elided until CR 6977974 is fixed properly.
!         // assert(!reducing || _offset_array[i] >= offset, "Not reducing");
!         _offset_array[i] = offset;
!       }
!     }
    }
  
    void check_offset_array(size_t index, HeapWord* high, HeapWord* low) const {
      assert(index < _vs.committed_size(), "index out of range");
      assert(high >= low, "addresses out of order");
--- 174,193 ----
      assert(index_for(right - 1) < _vs.committed_size(),
             "right address out of range");
      assert(left  < right, "Heap addresses out of order");
      size_t num_cards = pointer_delta(right, left) >> LogN_words;
  
!     fill_range(index_for(left), num_cards, offset);
    }
  
    void set_offset_array(size_t left, size_t right, u_char offset, bool reducing = false) {
      check_reducing_assertion(reducing);
      assert(right < _vs.committed_size(), "right address out of range");
      assert(left  <= right, "indexes out of order");
      size_t num_cards = right - left + 1;
  
!     fill_range(left, num_cards, offset);
    }
  
    void check_offset_array(size_t index, HeapWord* high, HeapWord* low) const {
      assert(index < _vs.committed_size(), "index out of range");
      assert(high >= low, "addresses out of order");