src/hotspot/share/memory/metaspace.cpp

*** 130,150 ****
    size_t value = OrderAccess::load_acquire(&_capacity_until_GC);
    assert(value >= MetaspaceSize, "Not initialized properly?");
    return value;
  }
  
! bool MetaspaceGC::inc_capacity_until_GC(size_t v, size_t* new_cap_until_GC, size_t* old_cap_until_GC) {
    assert_is_aligned(v, Metaspace::commit_alignment());
  
    size_t old_capacity_until_GC = _capacity_until_GC;
    size_t new_value = old_capacity_until_GC + v;
  
    if (new_value < old_capacity_until_GC) {
      // The addition wrapped around, set new_value to aligned max value.
      new_value = align_down(max_uintx, Metaspace::commit_alignment());
    }
  
    size_t prev_value = Atomic::cmpxchg(new_value, &_capacity_until_GC, old_capacity_until_GC);
  
    if (old_capacity_until_GC != prev_value) {
      return false;
    }
--- 130,166 ----
    size_t value = OrderAccess::load_acquire(&_capacity_until_GC);
    assert(value >= MetaspaceSize, "Not initialized properly?");
    return value;
  }
  
! // Try to increase metaspace size by v bytes. Returns true if
! // succeeded, false if not due to competing threads trying.
! // Optionally returns new and old metaspace capacity in
! // new_cap_until_GC and old_cap_until_GC respectively.
! // Optionally sets can_retry to indicate whether if there is actually
! // enough space remaining to satisfy the request.
! bool MetaspaceGC::inc_capacity_until_GC(size_t v, size_t* new_cap_until_GC, size_t* old_cap_until_GC, bool* can_retry) {
    assert_is_aligned(v, Metaspace::commit_alignment());
  
    size_t old_capacity_until_GC = _capacity_until_GC;
    size_t new_value = old_capacity_until_GC + v;
  
    if (new_value < old_capacity_until_GC) {
      // The addition wrapped around, set new_value to aligned max value.
      new_value = align_down(max_uintx, Metaspace::commit_alignment());
    }
  
+   if (new_value > MaxMetaspaceSize) {
+     if (can_retry != NULL) {
+       *can_retry = false;
+     }
+     return false;
+   }
+ 
+   if (can_retry != NULL) {
+     *can_retry = true;
+   }
    size_t prev_value = Atomic::cmpxchg(new_value, &_capacity_until_GC, old_capacity_until_GC);
  
    if (old_capacity_until_GC != prev_value) {
      return false;
    }
*** 234,244 ****
    const double minimum_free_percentage = MinMetaspaceFreeRatio / 100.0;
    const double maximum_used_percentage = 1.0 - minimum_free_percentage;
  
    const double min_tmp = used_after_gc / maximum_used_percentage;
    size_t minimum_desired_capacity =
!     (size_t)MIN2(min_tmp, double(max_uintx));
    // Don't shrink less than the initial generation size
    minimum_desired_capacity = MAX2(minimum_desired_capacity,
                                    MetaspaceSize);
  
    log_trace(gc, metaspace)("MetaspaceGC::compute_new_size: ");
--- 250,260 ----
    const double minimum_free_percentage = MinMetaspaceFreeRatio / 100.0;
    const double maximum_used_percentage = 1.0 - minimum_free_percentage;
  
    const double min_tmp = used_after_gc / maximum_used_percentage;
    size_t minimum_desired_capacity =
!     (size_t)MIN2(min_tmp, double(MaxMetaspaceSize));
    // Don't shrink less than the initial generation size
    minimum_desired_capacity = MAX2(minimum_desired_capacity,
                                    MetaspaceSize);
  
    log_trace(gc, metaspace)("MetaspaceGC::compute_new_size: ");
*** 281,291 ****
    // Should shrinking be considered?
    if (MaxMetaspaceFreeRatio < 100) {
      const double maximum_free_percentage = MaxMetaspaceFreeRatio / 100.0;
      const double minimum_used_percentage = 1.0 - maximum_free_percentage;
      const double max_tmp = used_after_gc / minimum_used_percentage;
!     size_t maximum_desired_capacity = (size_t)MIN2(max_tmp, double(max_uintx));
      maximum_desired_capacity = MAX2(maximum_desired_capacity,
                                      MetaspaceSize);
      log_trace(gc, metaspace)("    maximum_free_percentage: %6.2f  minimum_used_percentage: %6.2f",
                               maximum_free_percentage, minimum_used_percentage);
      log_trace(gc, metaspace)("    minimum_desired_capacity: %6.1fKB  maximum_desired_capacity: %6.1fKB",
--- 297,307 ----
    // Should shrinking be considered?
    if (MaxMetaspaceFreeRatio < 100) {
      const double maximum_free_percentage = MaxMetaspaceFreeRatio / 100.0;
      const double minimum_used_percentage = 1.0 - maximum_free_percentage;
      const double max_tmp = used_after_gc / minimum_used_percentage;
!     size_t maximum_desired_capacity = (size_t)MIN2(max_tmp, double(MaxMetaspaceSize));
      maximum_desired_capacity = MAX2(maximum_desired_capacity,
                                      MetaspaceSize);
      log_trace(gc, metaspace)("    maximum_free_percentage: %6.2f  minimum_used_percentage: %6.2f",
                               maximum_free_percentage, minimum_used_percentage);
      log_trace(gc, metaspace)("    minimum_desired_capacity: %6.1fKB  maximum_desired_capacity: %6.1fKB",
*** 1468,1487 ****
    size_t delta_bytes = MetaspaceGC::delta_capacity_until_GC(word_size * BytesPerWord);
    assert(delta_bytes > 0, "Must be");
  
    size_t before = 0;
    size_t after = 0;
    MetaWord* res;
    bool incremented;
  
    // Each thread increments the HWM at most once. Even if the thread fails to increment
    // the HWM, an allocation is still attempted. This is because another thread must then
    // have incremented the HWM and therefore the allocation might still succeed.
    do {
!     incremented = MetaspaceGC::inc_capacity_until_GC(delta_bytes, &after, &before);
      res = allocate(word_size, mdtype);
!   } while (!incremented && res == NULL);
  
    if (incremented) {
      Metaspace::tracer()->report_gc_threshold(before, after,
                                    MetaspaceGCThresholdUpdater::ExpandAndAllocate);
      log_trace(gc, metaspace)("Increase capacity to GC from " SIZE_FORMAT " to " SIZE_FORMAT, before, after);
--- 1484,1504 ----
    size_t delta_bytes = MetaspaceGC::delta_capacity_until_GC(word_size * BytesPerWord);
    assert(delta_bytes > 0, "Must be");
  
    size_t before = 0;
    size_t after = 0;
+   bool can_retry = true;
    MetaWord* res;
    bool incremented;
  
    // Each thread increments the HWM at most once. Even if the thread fails to increment
    // the HWM, an allocation is still attempted. This is because another thread must then
    // have incremented the HWM and therefore the allocation might still succeed.
    do {
!     incremented = MetaspaceGC::inc_capacity_until_GC(delta_bytes, &after, &before, &can_retry);
      res = allocate(word_size, mdtype);
!   } while (!incremented && res == NULL && can_retry);
  
    if (incremented) {
      Metaspace::tracer()->report_gc_threshold(before, after,
                                    MetaspaceGCThresholdUpdater::ExpandAndAllocate);
      log_trace(gc, metaspace)("Increase capacity to GC from " SIZE_FORMAT " to " SIZE_FORMAT, before, after);