< prev index next >

src/hotspot/share/gc/g1/g1RegionToSpaceMapper.cpp

Print this page




  29 #include "logging/log.hpp"
  30 #include "memory/allocation.inline.hpp"
  31 #include "memory/virtualspace.hpp"
  32 #include "runtime/java.hpp"
  33 #include "runtime/os.inline.hpp"
  34 #include "services/memTracker.hpp"
  35 #include "utilities/align.hpp"
  36 #include "utilities/bitMap.inline.hpp"
  37 #include "utilities/formatBuffer.hpp"
  38 #include "utilities/powerOfTwo.hpp"
  39 
  40 G1RegionToSpaceMapper::G1RegionToSpaceMapper(ReservedSpace rs,
  41                                              size_t used_size,
  42                                              size_t page_size,
  43                                              size_t region_granularity,
  44                                              size_t commit_factor,
  45                                              MemoryType type) :
  46   _listener(NULL),
  47   _storage(rs, used_size, page_size),
  48   _region_granularity(region_granularity),
  49   _commit_map(rs.size() * commit_factor / region_granularity, mtGC),
  50   _memory_type(type) {
  51   guarantee(is_power_of_2(page_size), "must be");
  52   guarantee(is_power_of_2(region_granularity), "must be");
  53 
  54   MemTracker::record_virtual_memory_type((address)rs.base(), type);
  55 }
  56 
  57 // G1RegionToSpaceMapper implementation where the region granularity is larger than
  58 // or the same as the commit granularity.
  59 // Basically, the space corresponding to one region region spans several OS pages.
  60 class G1RegionsLargerThanCommitSizeMapper : public G1RegionToSpaceMapper {
  61  private:
  62   size_t _pages_per_region;
  63 
  64  public:
  65   G1RegionsLargerThanCommitSizeMapper(ReservedSpace rs,
  66                                       size_t actual_size,
  67                                       size_t page_size,
  68                                       size_t alloc_granularity,
  69                                       size_t commit_factor,


  71     G1RegionToSpaceMapper(rs, actual_size, page_size, alloc_granularity, commit_factor, type),
  72     _pages_per_region(alloc_granularity / (page_size * commit_factor)) {
  73 
  74     guarantee(alloc_granularity >= page_size, "allocation granularity smaller than commit granularity");
  75   }
  76 
  77   virtual void commit_regions(uint start_idx, size_t num_regions, WorkGang* pretouch_gang) {
  78     const size_t start_page = (size_t)start_idx * _pages_per_region;
  79     const size_t size_in_pages = num_regions * _pages_per_region;
  80     bool zero_filled = _storage.commit(start_page, size_in_pages);
  81     if (_memory_type == mtJavaHeap) {
  82       for (uint region_index = start_idx; region_index < start_idx + num_regions; region_index++ ) {
  83         void* address = _storage.page_start(region_index * _pages_per_region);
  84         size_t size_in_bytes = _storage.page_size() * _pages_per_region;
  85         G1NUMA::numa()->request_memory_on_node(address, size_in_bytes, region_index);
  86       }
  87     }
  88     if (AlwaysPreTouch) {
  89       _storage.pretouch(start_page, size_in_pages, pretouch_gang);
  90     }
  91     _commit_map.set_range(start_idx, start_idx + num_regions);
  92     fire_on_commit(start_idx, num_regions, zero_filled);
  93   }
  94 
  95   virtual void uncommit_regions(uint start_idx, size_t num_regions) {
  96     _storage.uncommit((size_t)start_idx * _pages_per_region, num_regions * _pages_per_region);
  97     _commit_map.clear_range(start_idx, start_idx + num_regions);
  98   }
  99 };
 100 
 101 // G1RegionToSpaceMapper implementation where the region granularity is smaller
 102 // than the commit granularity.
 103 // Basically, the contents of one OS page span several regions.
 104 class G1RegionsSmallerThanCommitSizeMapper : public G1RegionToSpaceMapper {
 105  private:
 106   class CommitRefcountArray : public G1BiasedMappedArray<uint> {
 107    protected:
 108      virtual uint default_value() const { return 0; }
 109   };
 110 
 111   size_t _regions_per_page;
 112 
 113   CommitRefcountArray _refcounts;









 114 
 115   uintptr_t region_idx_to_page_idx(uint region) const {
 116     return region / _regions_per_page;





 117   }
 118 
 119  public:
 120   G1RegionsSmallerThanCommitSizeMapper(ReservedSpace rs,
 121                                        size_t actual_size,
 122                                        size_t page_size,
 123                                        size_t alloc_granularity,
 124                                        size_t commit_factor,
 125                                        MemoryType type) :
 126     G1RegionToSpaceMapper(rs, actual_size, page_size, alloc_granularity, commit_factor, type),
 127     _regions_per_page((page_size * commit_factor) / alloc_granularity), _refcounts() {
 128 
 129     guarantee((page_size * commit_factor) >= alloc_granularity, "allocation granularity smaller than commit granularity");
 130     _refcounts.initialize((HeapWord*)rs.base(), (HeapWord*)(rs.base() + align_up(rs.size(), page_size)), page_size);
 131   }
 132 
 133   virtual void commit_regions(uint start_idx, size_t num_regions, WorkGang* pretouch_gang) {





 134     size_t const NoPage = ~(size_t)0;
 135 
 136     size_t first_committed = NoPage;
 137     size_t num_committed = 0;
 138 
 139     bool all_zero_filled = true;
 140     G1NUMA* numa = G1NUMA::numa();
 141 
 142     for (uint region_idx = start_idx; region_idx < start_idx + num_regions; region_idx++) {
 143       assert(!_commit_map.at(region_idx), "Trying to commit storage at region %u that is already committed", region_idx);
 144       size_t page_idx = region_idx_to_page_idx(region_idx);
 145       uint old_refcount = _refcounts.get_by_index(page_idx);
 146 
 147       bool zero_filled = false;
 148       if (old_refcount == 0) {
 149         if (first_committed == NoPage) {
 150           first_committed = page_idx;
 151           num_committed = 1;
 152         } else {
 153           num_committed++;




 154         }
 155         zero_filled = _storage.commit(page_idx, 1);
 156         if (_memory_type == mtJavaHeap) {
 157           void* address = _storage.page_start(page_idx);
 158           size_t size_in_bytes = _storage.page_size();
 159           numa->request_memory_on_node(address, size_in_bytes, region_idx);

 160         }
 161       }
 162       all_zero_filled &= zero_filled;
 163 
 164       _refcounts.set_by_index(page_idx, old_refcount + 1);
 165       _commit_map.set_bit(region_idx);
 166     }
 167     if (AlwaysPreTouch && num_committed > 0) {
 168       _storage.pretouch(first_committed, num_committed, pretouch_gang);
 169     }

 170     fire_on_commit(start_idx, num_regions, all_zero_filled);
 171   }
 172 
 173   virtual void uncommit_regions(uint start_idx, size_t num_regions) {
 174     for (uint i = start_idx; i < start_idx + num_regions; i++) {
 175       assert(_commit_map.at(i), "Trying to uncommit storage at region %u that is not committed", i);
 176       size_t idx = region_idx_to_page_idx(i);
 177       uint old_refcount = _refcounts.get_by_index(idx);
 178       assert(old_refcount > 0, "must be");
 179       if (old_refcount == 1) {
 180         _storage.uncommit(idx, 1);










 181       }
 182       _refcounts.set_by_index(idx, old_refcount - 1);
 183       _commit_map.clear_bit(i);
 184     }
 185   }
 186 };
 187 
 188 void G1RegionToSpaceMapper::fire_on_commit(uint start_idx, size_t num_regions, bool zero_filled) {
 189   if (_listener != NULL) {
 190     _listener->on_commit(start_idx, num_regions, zero_filled);
 191   }
 192 }
 193 
 194 static bool map_nvdimm_space(ReservedSpace rs) {
 195   assert(AllocateOldGenAt != NULL, "");
 196   int _backing_fd = os::create_file_for_heap(AllocateOldGenAt);
 197   if (_backing_fd == -1) {
 198     log_error(gc, init)("Could not create file for Old generation at location %s", AllocateOldGenAt);
 199     return false;
 200   }
 201   // commit this memory in nv-dimm
 202   char* ret = os::attempt_reserve_memory_at(rs.size(), rs.base(), _backing_fd);
 203 




  29 #include "logging/log.hpp"
  30 #include "memory/allocation.inline.hpp"
  31 #include "memory/virtualspace.hpp"
  32 #include "runtime/java.hpp"
  33 #include "runtime/os.inline.hpp"
  34 #include "services/memTracker.hpp"
  35 #include "utilities/align.hpp"
  36 #include "utilities/bitMap.inline.hpp"
  37 #include "utilities/formatBuffer.hpp"
  38 #include "utilities/powerOfTwo.hpp"
  39 
  40 G1RegionToSpaceMapper::G1RegionToSpaceMapper(ReservedSpace rs,
  41                                              size_t used_size,
  42                                              size_t page_size,
  43                                              size_t region_granularity,
  44                                              size_t commit_factor,
  45                                              MemoryType type) :
  46   _listener(NULL),
  47   _storage(rs, used_size, page_size),
  48   _region_granularity(region_granularity),
  49   _region_commit_map(rs.size() * commit_factor / region_granularity, mtGC),
  50   _memory_type(type) {
  51   guarantee(is_power_of_2(page_size), "must be");
  52   guarantee(is_power_of_2(region_granularity), "must be");
  53 
  54   MemTracker::record_virtual_memory_type((address)rs.base(), type);
  55 }
  56 
  57 // G1RegionToSpaceMapper implementation where the region granularity is larger than
  58 // or the same as the commit granularity.
  59 // Basically, the space corresponding to one region region spans several OS pages.
  60 class G1RegionsLargerThanCommitSizeMapper : public G1RegionToSpaceMapper {
  61  private:
  62   size_t _pages_per_region;
  63 
  64  public:
  65   G1RegionsLargerThanCommitSizeMapper(ReservedSpace rs,
  66                                       size_t actual_size,
  67                                       size_t page_size,
  68                                       size_t alloc_granularity,
  69                                       size_t commit_factor,


  71     G1RegionToSpaceMapper(rs, actual_size, page_size, alloc_granularity, commit_factor, type),
  72     _pages_per_region(alloc_granularity / (page_size * commit_factor)) {
  73 
  74     guarantee(alloc_granularity >= page_size, "allocation granularity smaller than commit granularity");
  75   }
  76 
  77   virtual void commit_regions(uint start_idx, size_t num_regions, WorkGang* pretouch_gang) {
  78     const size_t start_page = (size_t)start_idx * _pages_per_region;
  79     const size_t size_in_pages = num_regions * _pages_per_region;
  80     bool zero_filled = _storage.commit(start_page, size_in_pages);
  81     if (_memory_type == mtJavaHeap) {
  82       for (uint region_index = start_idx; region_index < start_idx + num_regions; region_index++ ) {
  83         void* address = _storage.page_start(region_index * _pages_per_region);
  84         size_t size_in_bytes = _storage.page_size() * _pages_per_region;
  85         G1NUMA::numa()->request_memory_on_node(address, size_in_bytes, region_index);
  86       }
  87     }
  88     if (AlwaysPreTouch) {
  89       _storage.pretouch(start_page, size_in_pages, pretouch_gang);
  90     }
  91     _region_commit_map.set_range(start_idx, start_idx + num_regions);
  92     fire_on_commit(start_idx, num_regions, zero_filled);
  93   }
  94 
  95   virtual void uncommit_regions(uint start_idx, size_t num_regions) {
  96     _storage.uncommit((size_t)start_idx * _pages_per_region, num_regions * _pages_per_region);
  97     _region_commit_map.clear_range(start_idx, start_idx + num_regions);
  98   }
  99 };
 100 
 101 // G1RegionToSpaceMapper implementation where the region granularity is smaller
 102 // than the commit granularity.
 103 // Basically, the contents of one OS page span several regions.
 104 class G1RegionsSmallerThanCommitSizeMapper : public G1RegionToSpaceMapper {






 105   size_t _regions_per_page;
 106 
 107   size_t region_idx_to_page_idx(uint region_idx) const {
 108     return region_idx / _regions_per_page;
 109   }
 110 
 111   bool is_page_committed(size_t page_idx) {
 112     size_t region = page_idx * _regions_per_page;
 113     size_t region_limit = region + _regions_per_page;
 114     // Committed if there is a bit set in the range.
 115     return _region_commit_map.get_next_one_offset(region, region_limit) != region_limit;
 116   }
 117 
 118   void numa_request_on_node(size_t page_idx) {
 119     if (_memory_type == mtJavaHeap) {
 120       uint region = (uint)(page_idx * _regions_per_page);
 121       void* address = _storage.page_start(page_idx);
 122       size_t size_in_bytes = _storage.page_size();
 123       G1NUMA::numa()->request_memory_on_node(address, size_in_bytes, region);
 124     }
 125   }
 126 
 127  public:
 128   G1RegionsSmallerThanCommitSizeMapper(ReservedSpace rs,
 129                                        size_t actual_size,
 130                                        size_t page_size,
 131                                        size_t alloc_granularity,
 132                                        size_t commit_factor,
 133                                        MemoryType type) :
 134     G1RegionToSpaceMapper(rs, actual_size, page_size, alloc_granularity, commit_factor, type),
 135     _regions_per_page((page_size * commit_factor) / alloc_granularity) {
 136 
 137     guarantee((page_size * commit_factor) >= alloc_granularity, "allocation granularity smaller than commit granularity");

 138   }
 139 
 140   virtual void commit_regions(uint start_idx, size_t num_regions, WorkGang* pretouch_gang) {
 141     assert(num_regions > 0, "Must commit at least one region");
 142     assert(_region_commit_map.get_next_one_offset(start_idx, start_idx + num_regions) == start_idx + num_regions,
 143            "Should be no committed regions in the range [%u, " SIZE_FORMAT ")",
 144            start_idx, start_idx + num_regions);
 145 
 146     size_t const NoPage = ~(size_t)0;
 147 
 148     size_t first_committed = NoPage;
 149     size_t num_committed = 0;
 150 
 151     size_t start_page = region_idx_to_page_idx(start_idx);
 152     size_t end_page = region_idx_to_page_idx((uint)(start_idx + num_regions - 1));
 153 
 154     bool all_zero_filled = true;
 155     for (size_t page = start_page; page <= end_page; page++) {
 156       if (!is_page_committed(page)) {
 157         // Page not committed.
 158         if (num_committed == 0) {
 159           first_committed = page;
 160         }




 161         num_committed++;
 162 
 163         if (!_storage.commit(page, 1)) {
 164           // Found dirty region during commit.
 165           all_zero_filled = false;
 166         }
 167 
 168         // Move memory to correct NUMA node for the heap.
 169         numa_request_on_node(page);
 170       } else {
 171         // Page already committed.
 172         all_zero_filled = false;
 173       }
 174     }

 175 
 176     // Update the commit map for the given range.
 177     _region_commit_map.set_range(start_idx, start_idx + num_regions);
 178 
 179     if (AlwaysPreTouch && num_committed > 0) {
 180       _storage.pretouch(first_committed, num_committed, pretouch_gang);
 181     }
 182 
 183     fire_on_commit(start_idx, num_regions, all_zero_filled);
 184   }
 185 
 186   virtual void uncommit_regions(uint start_idx, size_t num_regions) {
 187     assert(num_regions > 0, "Must uncommit at least one region");
 188     assert(_region_commit_map.get_next_zero_offset(start_idx, start_idx + num_regions) == start_idx + num_regions,
 189            "Should only be committed regions in the range [%u, " SIZE_FORMAT ")",
 190            start_idx, start_idx + num_regions);
 191 
 192     size_t start_page = region_idx_to_page_idx(start_idx);
 193     size_t end_page = region_idx_to_page_idx((uint)(start_idx + num_regions - 1));
 194 
 195     // Clear commit map for the given range.
 196     _region_commit_map.clear_range(start_idx, start_idx + num_regions);
 197 
 198     for (size_t page = start_page; page <= end_page; page++) {
 199       // We know all pages were committed before clearing the map. If the
 200       // the page is still marked as committed after the clear we should
 201       // not uncommit it.
 202       if (!is_page_committed(page)) {
 203         _storage.uncommit(page, 1);
 204       }


 205     }
 206   }
 207 };
 208 
 209 void G1RegionToSpaceMapper::fire_on_commit(uint start_idx, size_t num_regions, bool zero_filled) {
 210   if (_listener != NULL) {
 211     _listener->on_commit(start_idx, num_regions, zero_filled);
 212   }
 213 }
 214 
 215 static bool map_nvdimm_space(ReservedSpace rs) {
 216   assert(AllocateOldGenAt != NULL, "");
 217   int _backing_fd = os::create_file_for_heap(AllocateOldGenAt);
 218   if (_backing_fd == -1) {
 219     log_error(gc, init)("Could not create file for Old generation at location %s", AllocateOldGenAt);
 220     return false;
 221   }
 222   // commit this memory in nv-dimm
 223   char* ret = os::attempt_reserve_memory_at(rs.size(), rs.base(), _backing_fd);
 224 


< prev index next >