src/share/vm/gc_implementation/g1/g1RegionToSpaceMapper.cpp

rev 7993 : imported patch per-comments

*** 29,50 ****
  #include "runtime/virtualspace.hpp"
  #include "services/memTracker.hpp"
  #include "utilities/bitMap.inline.hpp"
  
  G1RegionToSpaceMapper::G1RegionToSpaceMapper(ReservedSpace rs,
!                                              size_t actual_size,
!                                              size_t commit_granularity,
                                               size_t region_granularity,
                                               MemoryType type) :
!   _storage(),
!   _commit_granularity(commit_granularity),
    _region_granularity(region_granularity),
    _listener(NULL),
    _commit_map() {
!   guarantee(is_power_of_2(commit_granularity), "must be");
    guarantee(is_power_of_2(region_granularity), "must be");
-   _storage.initialize_with_granularity(rs, actual_size, commit_granularity);
  
    MemTracker::record_virtual_memory_type((address)rs.base(), type);
  }
  
  // G1RegionToSpaceMapper implementation where the region granularity is larger than
--- 29,48 ----
  #include "runtime/virtualspace.hpp"
  #include "services/memTracker.hpp"
  #include "utilities/bitMap.inline.hpp"
  
  G1RegionToSpaceMapper::G1RegionToSpaceMapper(ReservedSpace rs,
!                                              size_t used_size,
!                                              size_t page_size,
                                               size_t region_granularity,
                                               MemoryType type) :
!   _storage(rs, used_size, page_size),
    _region_granularity(region_granularity),
    _listener(NULL),
    _commit_map() {
!   guarantee(is_power_of_2(page_size), "must be");
    guarantee(is_power_of_2(region_granularity), "must be");
  
    MemTracker::record_virtual_memory_type((address)rs.base(), type);
  }
  
  // G1RegionToSpaceMapper implementation where the region granularity is larger than
*** 55,83 ****
    size_t _pages_per_region;
  
   public:
    G1RegionsLargerThanCommitSizeMapper(ReservedSpace rs,
                                        size_t actual_size,
!                                       size_t os_commit_granularity,
                                        size_t alloc_granularity,
                                        size_t commit_factor,
                                        MemoryType type) :
!     G1RegionToSpaceMapper(rs, actual_size, os_commit_granularity, alloc_granularity, type),
!     _pages_per_region(alloc_granularity / (os_commit_granularity * commit_factor)) {
  
!     guarantee(alloc_granularity >= os_commit_granularity, "allocation granularity smaller than commit granularity");
      _commit_map.resize(rs.size() * commit_factor / alloc_granularity, /* in_resource_area */ false);
    }
  
!   virtual void commit_regions(uintptr_t start_idx, size_t num_regions) {
!     bool zero_filled = _storage.commit(start_idx * _pages_per_region, num_regions * _pages_per_region);
      _commit_map.set_range(start_idx, start_idx + num_regions);
      fire_on_commit(start_idx, num_regions, zero_filled);
    }
  
!   virtual void uncommit_regions(uintptr_t start_idx, size_t num_regions) {
!     _storage.uncommit(start_idx * _pages_per_region, num_regions * _pages_per_region);
      _commit_map.clear_range(start_idx, start_idx + num_regions);
    }
  };
  
  // G1RegionToSpaceMapper implementation where the region granularity is smaller
--- 53,81 ----
    size_t _pages_per_region;
  
   public:
    G1RegionsLargerThanCommitSizeMapper(ReservedSpace rs,
                                        size_t actual_size,
!                                       size_t page_size,
                                        size_t alloc_granularity,
                                        size_t commit_factor,
                                        MemoryType type) :
!     G1RegionToSpaceMapper(rs, actual_size, page_size, alloc_granularity, type),
!     _pages_per_region(alloc_granularity / (page_size * commit_factor)) {
  
!     guarantee(alloc_granularity >= page_size, "allocation granularity smaller than commit granularity");
      _commit_map.resize(rs.size() * commit_factor / alloc_granularity, /* in_resource_area */ false);
    }
  
!   virtual void commit_regions(uint start_idx, size_t num_regions) {
!     bool zero_filled = _storage.commit((size_t)start_idx * _pages_per_region, num_regions * _pages_per_region);
      _commit_map.set_range(start_idx, start_idx + num_regions);
      fire_on_commit(start_idx, num_regions, zero_filled);
    }
  
!   virtual void uncommit_regions(uint start_idx, size_t num_regions) {
!     _storage.uncommit((size_t)start_idx * _pages_per_region, num_regions * _pages_per_region);
      _commit_map.clear_range(start_idx, start_idx + num_regions);
    }
  };
  
  // G1RegionToSpaceMapper implementation where the region granularity is smaller
*** 99,124 ****
    }
  
   public:
    G1RegionsSmallerThanCommitSizeMapper(ReservedSpace rs,
                                         size_t actual_size,
!                                        size_t os_commit_granularity,
                                         size_t alloc_granularity,
                                         size_t commit_factor,
                                         MemoryType type) :
!     G1RegionToSpaceMapper(rs, actual_size, os_commit_granularity, alloc_granularity, type),
!     _regions_per_page((os_commit_granularity * commit_factor) / alloc_granularity), _refcounts() {
  
!     guarantee((os_commit_granularity * commit_factor) >= alloc_granularity, "allocation granularity smaller than commit granularity");
!     _refcounts.initialize((HeapWord*)rs.base(), (HeapWord*)(rs.base() + align_size_up(rs.size(), os_commit_granularity)), os_commit_granularity);
      _commit_map.resize(rs.size() * commit_factor / alloc_granularity, /* in_resource_area */ false);
    }
  
!   virtual void commit_regions(uintptr_t start_idx, size_t num_regions) {
!     for (uintptr_t i = start_idx; i < start_idx + num_regions; i++) {
!       assert(!_commit_map.at(i), err_msg("Trying to commit storage at region "INTPTR_FORMAT" that is already committed", i));
!       uintptr_t idx = region_idx_to_page_idx(i);
        uint old_refcount = _refcounts.get_by_index(idx);
        bool zero_filled = false;
        if (old_refcount == 0) {
          zero_filled = _storage.commit(idx, 1);
        }
--- 97,122 ----
    }
  
   public:
    G1RegionsSmallerThanCommitSizeMapper(ReservedSpace rs,
                                         size_t actual_size,
!                                        size_t page_size,
                                         size_t alloc_granularity,
                                         size_t commit_factor,
                                         MemoryType type) :
!     G1RegionToSpaceMapper(rs, actual_size, page_size, alloc_granularity, type),
!     _regions_per_page((page_size * commit_factor) / alloc_granularity), _refcounts() {
  
!     guarantee((page_size * commit_factor) >= alloc_granularity, "allocation granularity smaller than commit granularity");
!     _refcounts.initialize((HeapWord*)rs.base(), (HeapWord*)(rs.base() + align_size_up(rs.size(), page_size)), page_size);
      _commit_map.resize(rs.size() * commit_factor / alloc_granularity, /* in_resource_area */ false);
    }
  
!   virtual void commit_regions(uint start_idx, size_t num_regions) {
!     for (uint i = start_idx; i < start_idx + num_regions; i++) {
!       assert(!_commit_map.at(i), err_msg("Trying to commit storage at region %u that is already committed", i));
!       size_t idx = region_idx_to_page_idx(i);
        uint old_refcount = _refcounts.get_by_index(idx);
        bool zero_filled = false;
        if (old_refcount == 0) {
          zero_filled = _storage.commit(idx, 1);
        }
*** 126,139 ****
        _commit_map.set_bit(i);
        fire_on_commit(i, 1, zero_filled);
      }
    }
  
!   virtual void uncommit_regions(uintptr_t start_idx, size_t num_regions) {
!     for (uintptr_t i = start_idx; i < start_idx + num_regions; i++) {
!       assert(_commit_map.at(i), err_msg("Trying to uncommit storage at region "INTPTR_FORMAT" that is not committed", i));
!       uintptr_t idx = region_idx_to_page_idx(i);
        uint old_refcount = _refcounts.get_by_index(idx);
        assert(old_refcount > 0, "must be");
        if (old_refcount == 1) {
          _storage.uncommit(idx, 1);
        }
--- 124,137 ----
        _commit_map.set_bit(i);
        fire_on_commit(i, 1, zero_filled);
      }
    }
  
!   virtual void uncommit_regions(uint start_idx, size_t num_regions) {
!     for (uint i = start_idx; i < start_idx + num_regions; i++) {
!       assert(_commit_map.at(i), err_msg("Trying to uncommit storage at region %u that is not committed", i));
!       size_t idx = region_idx_to_page_idx(i);
        uint old_refcount = _refcounts.get_by_index(idx);
        assert(old_refcount > 0, "must be");
        if (old_refcount == 1) {
          _storage.uncommit(idx, 1);
        }
*** 149,164 ****
    }
  }
  
  G1RegionToSpaceMapper* G1RegionToSpaceMapper::create_mapper(ReservedSpace rs,
                                                              size_t actual_size,
!                                                             size_t os_commit_granularity,
                                                              size_t region_granularity,
                                                              size_t commit_factor,
                                                              MemoryType type) {
  
!   if (region_granularity >= (os_commit_granularity * commit_factor)) {
!     return new G1RegionsLargerThanCommitSizeMapper(rs, actual_size, os_commit_granularity, region_granularity, commit_factor, type);
    } else {
!     return new G1RegionsSmallerThanCommitSizeMapper(rs, actual_size, os_commit_granularity, region_granularity, commit_factor, type);
    }
  }
--- 147,162 ----
    }
  }
  
  G1RegionToSpaceMapper* G1RegionToSpaceMapper::create_mapper(ReservedSpace rs,
                                                              size_t actual_size,
!                                                             size_t page_size,
                                                              size_t region_granularity,
                                                              size_t commit_factor,
                                                              MemoryType type) {
  
!   if (region_granularity >= (page_size * commit_factor)) {
!     return new G1RegionsLargerThanCommitSizeMapper(rs, actual_size, page_size, region_granularity, commit_factor, type);
    } else {
!     return new G1RegionsSmallerThanCommitSizeMapper(rs, actual_size, page_size, region_granularity, commit_factor, type);
    }
  }