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

rev 49851 : imported patch 8191471-g1-varying-tlab-allocation

*** 382,407 ****
    _verifier->verify_region_sets_optional();
  
    return result;
  }
  
! HeapWord* G1CollectedHeap::allocate_new_tlab(size_t word_size) {
    assert_heap_not_locked_and_not_at_safepoint();
!   assert(!is_humongous(word_size), "we do not allow humongous TLABs");
  
!   return attempt_allocation(word_size);
  }
  
  HeapWord*
  G1CollectedHeap::mem_allocate(size_t word_size,
                                bool*  gc_overhead_limit_was_exceeded) {
    assert_heap_not_locked_and_not_at_safepoint();
  
    if (is_humongous(word_size)) {
      return attempt_allocation_humongous(word_size);
    }
!   return attempt_allocation(word_size);
  }
  
  HeapWord* G1CollectedHeap::attempt_allocation_slow(size_t word_size) {
    ResourceMark rm; // For retrieving the thread names in log messages.
  
--- 382,410 ----
    _verifier->verify_region_sets_optional();
  
    return result;
  }
  
! HeapWord* G1CollectedHeap::allocate_new_tlab(size_t min_word_size,
!                                              size_t desired_word_size,
!                                              size_t* actual_word_size) {
    assert_heap_not_locked_and_not_at_safepoint();
!   assert(!is_humongous(desired_word_size), "we do not allow humongous TLABs");
  
!   return attempt_allocation(min_word_size, desired_word_size, actual_word_size);
  }
  
  HeapWord*
  G1CollectedHeap::mem_allocate(size_t word_size,
                                bool*  gc_overhead_limit_was_exceeded) {
    assert_heap_not_locked_and_not_at_safepoint();
  
    if (is_humongous(word_size)) {
      return attempt_allocation_humongous(word_size);
    }
!   size_t dummy = 0;
!   return attempt_allocation(word_size, word_size, &dummy);
  }
  
  HeapWord* G1CollectedHeap::attempt_allocation_slow(size_t word_size) {
    ResourceMark rm; // For retrieving the thread names in log messages.
  
*** 490,501 ****
      // allocation attempt in case another thread successfully
      // performed a collection and reclaimed enough space. We do the
      // first attempt (without holding the Heap_lock) here and the
      // follow-on attempt will be at the start of the next loop
      // iteration (after taking the Heap_lock).
! 
!     result = _allocator->attempt_allocation(word_size);
      if (result != NULL) {
        return result;
      }
  
      // Give a warning if we seem to be looping forever.
--- 493,504 ----
      // allocation attempt in case another thread successfully
      // performed a collection and reclaimed enough space. We do the
      // first attempt (without holding the Heap_lock) here and the
      // follow-on attempt will be at the start of the next loop
      // iteration (after taking the Heap_lock).
!     size_t dummy = 0;
!     result = _allocator->attempt_allocation(word_size, word_size, &dummy);
      if (result != NULL) {
        return result;
      }
  
      // Give a warning if we seem to be looping forever.
*** 720,742 ****
        increase_used(fill_size * HeapWordSize);
      }
    }
  }
  
! inline HeapWord* G1CollectedHeap::attempt_allocation(size_t word_size) {
    assert_heap_not_locked_and_not_at_safepoint();
!   assert(!is_humongous(word_size), "attempt_allocation() should not "
           "be called for humongous allocation requests");
  
!   HeapWord* result = _allocator->attempt_allocation(word_size);
  
    if (result == NULL) {
!     result = attempt_allocation_slow(word_size);
    }
    assert_heap_not_locked();
    if (result != NULL) {
!     dirty_young_block(result, word_size);
    }
    return result;
  }
  
  void G1CollectedHeap::dealloc_archive_regions(MemRegion* ranges, size_t count) {
--- 723,750 ----
        increase_used(fill_size * HeapWordSize);
      }
    }
  }
  
! inline HeapWord* G1CollectedHeap::attempt_allocation(size_t min_word_size,
!                                                      size_t desired_word_size,
!                                                      size_t* actual_word_size) {
    assert_heap_not_locked_and_not_at_safepoint();
!   assert(!is_humongous(desired_word_size), "attempt_allocation() should not "
           "be called for humongous allocation requests");
  
!   HeapWord* result = _allocator->attempt_allocation(min_word_size, desired_word_size, actual_word_size);
  
    if (result == NULL) {
!     *actual_word_size = desired_word_size;
!     result = attempt_allocation_slow(desired_word_size);
    }
+ 
    assert_heap_not_locked();
    if (result != NULL) {
!     assert(*actual_word_size != 0, "Actual size must have been set here");
!     dirty_young_block(result, *actual_word_size);
    }
    return result;
  }
  
  void G1CollectedHeap::dealloc_archive_regions(MemRegion* ranges, size_t count) {