test/hotspot/gtest/gc/g1/test_g1IHOPControl.cpp

*** 1,7 ****
  /*
!  * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
--- 1,7 ----
  /*
!  * Copyright (c) 2016, 2020, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
*** 22,39 ****
   */
  
  #include "precompiled.hpp"
  #include "gc/g1/g1CollectedHeap.inline.hpp"
  #include "gc/g1/g1IHOPControl.hpp"
  #include "gc/g1/g1Predictions.hpp"
  #include "unittest.hpp"
  
! static void test_update(G1IHOPControl* ctrl, double alloc_time,
!                         size_t alloc_amount, size_t young_size,
!                         double mark_time) {
    for (int i = 0; i < 100; i++) {
!     ctrl->update_allocation_info(alloc_time, alloc_amount, young_size);
      ctrl->update_marking_length(mark_time);
    }
  }
  
  // @requires UseG1GC
--- 22,48 ----
   */
  
  #include "precompiled.hpp"
  #include "gc/g1/g1CollectedHeap.inline.hpp"
  #include "gc/g1/g1IHOPControl.hpp"
+ #include "gc/g1/g1OldGenAllocationTracker.hpp"
  #include "gc/g1/g1Predictions.hpp"
  #include "unittest.hpp"
  
! static void test_update_allocation_tracker(G1OldGenAllocationTracker* alloc_tracker,
!                                            double alloc_time, size_t alloc_amount) {
!   alloc_tracker->add_allocated_bytes_since_last_gc(alloc_amount);
!   alloc_tracker->reset_after_young_gc(alloc_time, (size_t)0);
! }
! 
! static void test_update(G1IHOPControl* ctrl,
!                         G1OldGenAllocationTracker* alloc_tracker,
!                         double alloc_time, size_t alloc_amount,
!                         size_t young_size, double mark_time) {
    for (int i = 0; i < 100; i++) {
!     test_update_allocation_tracker(alloc_tracker, alloc_time, alloc_amount);
!     ctrl->update_allocation_info(young_size);
      ctrl->update_marking_length(mark_time);
    }
  }
  
  // @requires UseG1GC
*** 43,73 ****
      return;
    }
  
    const size_t initial_ihop = 45;
  
!   G1StaticIHOPControl ctrl(initial_ihop);
    ctrl.update_target_occupancy(100);
  
    size_t threshold = ctrl.get_conc_mark_start_threshold();
    EXPECT_EQ(initial_ihop, threshold);
  
!   ctrl.update_allocation_info(100.0, 100, 100);
    threshold = ctrl.get_conc_mark_start_threshold();
    EXPECT_EQ(initial_ihop, threshold);
  
    ctrl.update_marking_length(1000.0);
    threshold = ctrl.get_conc_mark_start_threshold();
    EXPECT_EQ(initial_ihop, threshold);
  
    // Whatever we pass, the IHOP value must stay the same.
!   test_update(&ctrl, 2, 10, 10, 3);
    threshold = ctrl.get_conc_mark_start_threshold();
  
    EXPECT_EQ(initial_ihop, threshold);
  
!   test_update(&ctrl, 12, 10, 10, 3);
    threshold = ctrl.get_conc_mark_start_threshold();
  
    EXPECT_EQ(initial_ihop, threshold);
  }
  
--- 52,84 ----
      return;
    }
  
    const size_t initial_ihop = 45;
  
!   G1OldGenAllocationTracker alloc_tracker;
!   G1StaticIHOPControl ctrl(initial_ihop, &alloc_tracker);
    ctrl.update_target_occupancy(100);
  
    size_t threshold = ctrl.get_conc_mark_start_threshold();
    EXPECT_EQ(initial_ihop, threshold);
  
!   test_update_allocation_tracker(&alloc_tracker, 100.0, 100);
!   ctrl.update_allocation_info(100);
    threshold = ctrl.get_conc_mark_start_threshold();
    EXPECT_EQ(initial_ihop, threshold);
  
    ctrl.update_marking_length(1000.0);
    threshold = ctrl.get_conc_mark_start_threshold();
    EXPECT_EQ(initial_ihop, threshold);
  
    // Whatever we pass, the IHOP value must stay the same.
!   test_update(&ctrl, &alloc_tracker, 2, 10, 10, 3);
    threshold = ctrl.get_conc_mark_start_threshold();
  
    EXPECT_EQ(initial_ihop, threshold);
  
!   test_update(&ctrl, &alloc_tracker, 12, 10, 10, 3);
    threshold = ctrl.get_conc_mark_start_threshold();
  
    EXPECT_EQ(initial_ihop, threshold);
  }
  
*** 83,94 ****
    const size_t target_size = 100;
  
    // The final IHOP value is always
    // target_size - (young_size + alloc_amount/alloc_time * marking_time)
  
    G1Predictions pred(0.95);
!   G1AdaptiveIHOPControl ctrl(initial_threshold, &pred, 0, 0);
    ctrl.update_target_occupancy(target_size);
  
    // First "load".
    const size_t alloc_time1 = 2;
    const size_t alloc_amount1 = 10;
--- 94,106 ----
    const size_t target_size = 100;
  
    // The final IHOP value is always
    // target_size - (young_size + alloc_amount/alloc_time * marking_time)
  
+   G1OldGenAllocationTracker alloc_tracker;
    G1Predictions pred(0.95);
!   G1AdaptiveIHOPControl ctrl(initial_threshold, &alloc_tracker, &pred, 0, 0);
    ctrl.update_target_occupancy(target_size);
  
    // First "load".
    const size_t alloc_time1 = 2;
    const size_t alloc_amount1 = 10;
*** 100,118 ****
    threshold = ctrl.get_conc_mark_start_threshold();
  
    EXPECT_EQ(initial_threshold, threshold);
  
    for (size_t i = 0; i < G1AdaptiveIHOPNumInitialSamples - 1; i++) {
!     ctrl.update_allocation_info(alloc_time1, alloc_amount1, young_size);
      ctrl.update_marking_length(marking_time1);
      // Not enough data yet.
      threshold = ctrl.get_conc_mark_start_threshold();
  
      ASSERT_EQ(initial_threshold, threshold) << "on step " << i;
    }
  
!   test_update(&ctrl, alloc_time1, alloc_amount1, young_size, marking_time1);
  
    threshold = ctrl.get_conc_mark_start_threshold();
  
    EXPECT_EQ(settled_ihop1, threshold);
  
--- 112,131 ----
    threshold = ctrl.get_conc_mark_start_threshold();
  
    EXPECT_EQ(initial_threshold, threshold);
  
    for (size_t i = 0; i < G1AdaptiveIHOPNumInitialSamples - 1; i++) {
!     test_update_allocation_tracker(&alloc_tracker, alloc_time1, alloc_amount1);
!     ctrl.update_allocation_info(young_size);
      ctrl.update_marking_length(marking_time1);
      // Not enough data yet.
      threshold = ctrl.get_conc_mark_start_threshold();
  
      ASSERT_EQ(initial_threshold, threshold) << "on step " << i;
    }
  
!   test_update(&ctrl, &alloc_tracker, alloc_time1, alloc_amount1, young_size, marking_time1);
  
    threshold = ctrl.get_conc_mark_start_threshold();
  
    EXPECT_EQ(settled_ihop1, threshold);
  
*** 121,131 ****
    const size_t alloc_amount2 = 30;
    const size_t marking_time2 = 2;
    const size_t settled_ihop2 = target_size
            - (young_size + alloc_amount2 / alloc_time2 * marking_time2);
  
!   test_update(&ctrl, alloc_time2, alloc_amount2, young_size, marking_time2);
  
    threshold = ctrl.get_conc_mark_start_threshold();
  
    EXPECT_LT(threshold, settled_ihop1);
  
--- 134,144 ----
    const size_t alloc_amount2 = 30;
    const size_t marking_time2 = 2;
    const size_t settled_ihop2 = target_size
            - (young_size + alloc_amount2 / alloc_time2 * marking_time2);
  
!   test_update(&ctrl, &alloc_tracker, alloc_time2, alloc_amount2, young_size, marking_time2);
  
    threshold = ctrl.get_conc_mark_start_threshold();
  
    EXPECT_LT(threshold, settled_ihop1);
  
*** 133,149 ****
    const size_t alloc_time3 = 1;
    const size_t alloc_amount3 = 50;
    const size_t marking_time3 = 2;
    const size_t settled_ihop3 = 0;
  
!   test_update(&ctrl, alloc_time3, alloc_amount3, young_size, marking_time3);
    threshold = ctrl.get_conc_mark_start_threshold();
  
    EXPECT_EQ(settled_ihop3, threshold);
  
    // And back to some arbitrary value.
!   test_update(&ctrl, alloc_time2, alloc_amount2, young_size, marking_time2);
  
    threshold = ctrl.get_conc_mark_start_threshold();
  
    EXPECT_GT(threshold, settled_ihop3);
  }
--- 146,162 ----
    const size_t alloc_time3 = 1;
    const size_t alloc_amount3 = 50;
    const size_t marking_time3 = 2;
    const size_t settled_ihop3 = 0;
  
!   test_update(&ctrl, &alloc_tracker, alloc_time3, alloc_amount3, young_size, marking_time3);
    threshold = ctrl.get_conc_mark_start_threshold();
  
    EXPECT_EQ(settled_ihop3, threshold);
  
    // And back to some arbitrary value.
!   test_update(&ctrl, &alloc_tracker, alloc_time2, alloc_amount2, young_size, marking_time2);
  
    threshold = ctrl.get_conc_mark_start_threshold();
  
    EXPECT_GT(threshold, settled_ihop3);
  }