Hotspot Metaspace

The new project encountered Metaspace Lack of space leads to fullgc, So I want to find out Metaspace Initial size , When is the expansion , How much capacity to expand …
First, let's explain GC In the log ,Metaspace In this line used ,capacity ,committed ,reserved What exactly does it mean ？ also class space In this line used ,capacity ,committed ,reserved What exactly does it mean ？

 Metaspace       used 13009K, capacity 13344K, committed 13568K, reserved 1060864K
  class space    used 1584K, capacity 1690K, committed 1792K, reserved 1048576K

The picture above is Metaspace.hpp In the source , I just cut a picture , This is just an expression Metaspace Which components are not explained for the parameters in the log , So I searched the official website , about Metaspace The parameters in this line are explained as follows .

The above is from from

used： The amount of space in the loaded class .
capacity： The space of the metadata of the currently allocated block .
committed： Number of space blocks .
reserved： yes jvm The size of memory reserved during startup according to parameters and operating system .

class space Yes for class The sum of memory .

Metaspace The initialization size code is as follows

void MetaspaceGC::initialize() {
  // Set the high-water mark to MaxMetapaceSize during VM initializaton since
  // we can't do a GC during initialization.
  _capacity_until_GC = MaxMetaspaceSize;
}

MaxMetaspaceSize The field is defined in globals.hpp file , As for how to initialize, I can't follow , I am also a colored pen , It also means that I don't know the initialization size .
Every time the garbage collection is completed, it will call MetaspaceGC::compute_new_size, Realize dynamic adjustment Metaspace The function of size , The following is the source code. I only copy the code on how to expand the capacity .

void MetaspaceGC::compute_new_size() {
  assert(_shrink_factor <= 100, "invalid shrink factor");
  uint current_shrink_factor = _shrink_factor;
  _shrink_factor = 0;

  const size_t used_after_gc = MetaspaceAux::committed_bytes();
  const size_t capacity_until_GC = MetaspaceGC::capacity_until_GC();
  //MinMetaspaceFreeRatio yes GC To be guaranteed after completion Metaspace The lowest percentage of free space , Default       yes 40%	
  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);

  if (PrintGCDetails && Verbose) {
    gclog_or_tty->print_cr("\nMetaspaceGC::compute_new_size: ");
    gclog_or_tty->print_cr("  "
                  "  minimum_free_percentage: %6.2f"
                  "  maximum_used_percentage: %6.2f",
                  minimum_free_percentage,
                  maximum_used_percentage);
    gclog_or_tty->print_cr("  "
                  "   used_after_gc       : %6.1fKB",
                  used_after_gc / (double) K);
  }


  size_t shrink_bytes = 0;
  // If the current capacity_until_GC Less than expected , Then expand the capacity 
  if (capacity_until_GC < minimum_desired_capacity) {
    size_t expand_bytes = minimum_desired_capacity - capacity_until_GC;
    //64 Bit system 8 Byte alignment 
    expand_bytes = align_size_up(expand_bytes, Metaspace::commit_alignment());
    //MinMetaspaceExpansion Indicates the lowest expansion value during capacity expansion , The default is 256k, Below this value, no expansion is allowed 
    if (expand_bytes >= MinMetaspaceExpansion) {
      size_t new_capacity_until_GC = 0;
      bool succeeded = MetaspaceGC::inc_capacity_until_GC(expand_bytes, &new_capacity_until_GC);
      assert(succeeded, "Should always succesfully increment HWM when at safepoint");

      Metaspace::tracer()->report_gc_threshold(capacity_until_GC,
                                               new_capacity_until_GC,
                                               MetaspaceGCThresholdUpdater::ComputeNewSize);
      if (PrintGCDetails && Verbose) {
        gclog_or_tty->print_cr("    expanding:"
                      "  minimum_desired_capacity: %6.1fKB"
                      "  expand_bytes: %6.1fKB"
                      "  MinMetaspaceExpansion: %6.1fKB"
                      "  new metaspace HWM:  %6.1fKB",
                      minimum_desired_capacity / (double) K,
                      expand_bytes / (double) K,
                      MinMetaspaceExpansion / (double) K,
                      new_capacity_until_GC / (double) K);
      }
    }
    return;
  }
 ......
 }

used_after_gc and capacity_until_GC These two variables are familiar , Corresponding to the logs mentioned above Metaspace used and capacity, The rest of the important code has been commented .