src/share/vm/gc/g1/heapRegionManager.cpp

rev 8461 : imported patch webrev1.patch
rev 8462 : [mq]: version3

@@ -276,17 +276,16 @@
          err_msg("The region at the current position %u must be available or at the end of the heap.", cur));
 #endif
   return num_regions;
 }
 
-uint HeapRegionManager::find_highest_available(bool* expanded) {
+uint HeapRegionManager::find_highest_free(bool* expanded) {
   // Loop downwards from the highest region index, looking for an
   // entry which is either free or not yet committed.  If not yet
-  // committed, expand_at that index, and set the 'expanded' output
-  // bool result to true.
+  // committed, expand_at that index.
   uint curr = max_length() - 1;
-  while (curr != 0) {
+  while (true) {
     HeapRegion *hr = _regions.get_by_index(curr);
     if (hr == NULL) {
       uint res = expand_at(curr, 1);
       if (res == 1) {
         *expanded = true;

@@ -296,13 +295,38 @@
       if (hr->is_free()) {
         *expanded = false;
         return curr;
       }
     }
+    if (curr == 0) {
+      return G1_NO_HRM_INDEX;
+    }
     curr--;
   }
-  return G1_NO_HRM_INDEX;
+}
+
+bool HeapRegionManager::allocate_containing_regions(MemRegion range, size_t* commit_count) {
+  size_t commits = 0;
+  uint start_index = (uint)_regions.get_index_by_address(range.start());
+  uint last_index = (uint)_regions.get_index_by_address(range.last());
+
+  // Ensure that each G1 region in the range is free, returning false if not.                                                        
+  // Commit those that are not yet available, and keep count.
+  for (uint curr_index = start_index; curr_index <= last_index; curr_index++) {
+    if (!is_available(curr_index)) {
+      commits++;
+      expand_at(curr_index, 1);
+    }
+    HeapRegion* curr_region  = _regions.get_by_index(curr_index);
+    if (!curr_region->is_free()) {
+      return false;
+    }
+  }
+
+  allocate_free_regions_starting_at(start_index, (last_index - start_index) + 1);
+  *commit_count = commits;
+  return true;
 }
 
 void HeapRegionManager::par_iterate(HeapRegionClosure* blk, uint worker_id, HeapRegionClaimer* hrclaimer, bool concurrent) const {
   const uint start_index = hrclaimer->start_region_for_worker(worker_id);
 

@@ -459,11 +483,11 @@
       continue;
     }
     num_committed++;
     HeapRegion* hr = _regions.get_by_index(i);
     guarantee(hr != NULL, err_msg("invariant: i: %u", i));
-    guarantee(!prev_committed || hr->bottom() == prev_end || hr->is_archive(),
+    guarantee(!prev_committed || hr->bottom() == prev_end,
               err_msg("invariant i: %u "HR_FORMAT" prev_end: "PTR_FORMAT,
                       i, HR_FORMAT_PARAMS(hr), p2i(prev_end)));
     guarantee(hr->hrm_index() == i,
               err_msg("invariant: i: %u hrm_index(): %u", i, hr->hrm_index()));
     // Asserts will fire if i is >= _length