// Values set on the command line win over any ergonomically
// set command line parameters.
// Ergonomic choice of parameters are done before this
// method is called.  Values for command line parameters such as NewSize
// and MaxNewSize feed those ergonomic choices into this method.
// This method makes the final generation sizings consistent with
// themselves and with overall heap sizings.
// In the absence of explicitly set command line flags, policies
// such as the use of NewRatio are used to size the generation.

void GenCollectorPolicy::initialize_size_info() {

  {- -------------------------------------------
  (1) 
      ---------------------------------------- -}

      CollectorPolicy::initialize_size_info();

  {- -------------------------------------------
  (1) 
      ---------------------------------------- -}

      // min_alignment() is used for alignment within a generation.
      // There is additional alignment done down stream for some
      // collectors that sometimes causes unwanted rounding up of
      // generations sizes.

      // Determine maximum size of gen0

      size_t max_new_size = 0;
      if (FLAG_IS_CMDLINE(MaxNewSize) || FLAG_IS_ERGO(MaxNewSize)) {
        if (MaxNewSize < min_alignment()) {
          max_new_size = min_alignment();
        }
        if (MaxNewSize >= max_heap_byte_size()) {
          max_new_size = align_size_down(max_heap_byte_size() - min_alignment(),
                                         min_alignment());
          warning("MaxNewSize (" SIZE_FORMAT "k) is equal to or "
            "greater than the entire heap (" SIZE_FORMAT "k).  A "
            "new generation size of " SIZE_FORMAT "k will be used.",
            MaxNewSize/K, max_heap_byte_size()/K, max_new_size/K);
        } else {
          max_new_size = align_size_down(MaxNewSize, min_alignment());
        }

      // The case for FLAG_IS_ERGO(MaxNewSize) could be treated
      // specially at this point to just use an ergonomically set
      // MaxNewSize to set max_new_size.  For cases with small
      // heaps such a policy often did not work because the MaxNewSize
      // was larger than the entire heap.  The interpretation given
      // to ergonomically set flags is that the flags are set
      // by different collectors for their own special needs but
      // are not allowed to badly shape the heap.  This allows the
      // different collectors to decide what's best for themselves
      // without having to factor in the overall heap shape.  It
      // can be the case in the future that the collectors would
      // only make "wise" ergonomics choices and this policy could
      // just accept those choices.  The choices currently made are
      // not always "wise".
      } else {
        max_new_size = scale_by_NewRatio_aligned(max_heap_byte_size());
        // Bound the maximum size by NewSize below (since it historically
        // would have been NewSize and because the NewRatio calculation could
        // yield a size that is too small) and bound it by MaxNewSize above.
        // Ergonomics plays here by previously calculating the desired
        // NewSize and MaxNewSize.
        max_new_size = MIN2(MAX2(max_new_size, NewSize), MaxNewSize);
      }
      assert(max_new_size > 0, "All paths should set max_new_size");

      // Given the maximum gen0 size, determine the initial and
      // minimum gen0 sizes.

      if (max_heap_byte_size() == min_heap_byte_size()) {
        // The maximum and minimum heap sizes are the same so
        // the generations minimum and initial must be the
        // same as its maximum.
        set_min_gen0_size(max_new_size);
        set_initial_gen0_size(max_new_size);
        set_max_gen0_size(max_new_size);
      } else {
        size_t desired_new_size = 0;
        if (!FLAG_IS_DEFAULT(NewSize)) {
          // If NewSize is set ergonomically (for example by cms), it
          // would make sense to use it.  If it is used, also use it
          // to set the initial size.  Although there is no reason
          // the minimum size and the initial size have to be the same,
          // the current implementation gets into trouble during the calculation
          // of the tenured generation sizes if they are different.
          // Note that this makes the initial size and the minimum size
          // generally small compared to the NewRatio calculation.
          _min_gen0_size = NewSize;
          desired_new_size = NewSize;
          max_new_size = MAX2(max_new_size, NewSize);
        } else {
          // For the case where NewSize is the default, use NewRatio
          // to size the minimum and initial generation sizes.
          // Use the default NewSize as the floor for these values.  If
          // NewRatio is overly large, the resulting sizes can be too
          // small.
          _min_gen0_size = MAX2(scale_by_NewRatio_aligned(min_heap_byte_size()),
                              NewSize);
          desired_new_size =
            MAX2(scale_by_NewRatio_aligned(initial_heap_byte_size()),
                 NewSize);
        }

        assert(_min_gen0_size > 0, "Sanity check");
        set_initial_gen0_size(desired_new_size);
        set_max_gen0_size(max_new_size);

        // At this point the desirable initial and minimum sizes have been
        // determined without regard to the maximum sizes.

        // Bound the sizes by the corresponding overall heap sizes.
        set_min_gen0_size(
          bound_minus_alignment(_min_gen0_size, min_heap_byte_size()));
        set_initial_gen0_size(
          bound_minus_alignment(_initial_gen0_size, initial_heap_byte_size()));
        set_max_gen0_size(
          bound_minus_alignment(_max_gen0_size, max_heap_byte_size()));

        // At this point all three sizes have been checked against the
        // maximum sizes but have not been checked for consistency
        // among the three.

        // Final check min <= initial <= max
        set_min_gen0_size(MIN2(_min_gen0_size, _max_gen0_size));
        set_initial_gen0_size(
          MAX2(MIN2(_initial_gen0_size, _max_gen0_size), _min_gen0_size));
        set_min_gen0_size(MIN2(_min_gen0_size, _initial_gen0_size));
      }

  {- -------------------------------------------
  (1) (トレース出力)
      ---------------------------------------- -}

      if (PrintGCDetails && Verbose) {
        gclog_or_tty->print_cr("1: Minimum gen0 " SIZE_FORMAT "  Initial gen0 "
          SIZE_FORMAT "  Maximum gen0 " SIZE_FORMAT,
          min_gen0_size(), initial_gen0_size(), max_gen0_size());
      }
    }