GC overhead limit exceeded填坑心得

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

bool print_gc_overhead_limit_would_be_exceeded = false;

if (is_full_gc) {

  if (gc_cost() > gc_cost_limit &&

    free_in_old_gen < (size_t) mem_free_old_limit &&

    free_in_eden < (size_t) mem_free_eden_limit) {

    // Collections, on average, are taking too much time, and

    //      gc_cost() > gc_cost_limit

    // we have too little space available after a full gc.

    //      total_free_limit < mem_free_limit

    // where

    //   total_free_limit is the free space available in

    //     both generations

    //   total_mem is the total space available for allocation

    //     in both generations (survivor spaces are not included

    //     just as they are not included in eden_limit).

    //   mem_free_limit is a fraction of total_mem judged to be an

    //     acceptable amount that is still unused.

    // The heap can ask for the value of this variable when deciding

    // whether to thrown an OutOfMemory error.

    // Note that the gc time limit test only works for the collections

    // of the young gen + tenured gen and not for collections of the

    // permanent gen.  That is because the calculation of the space

    // freed by the collection is the free space in the young gen +

    // tenured gen.

    // At this point the GC overhead limit is being exceeded.

    inc_gc_overhead_limit_count();

    if (UseGCOverheadLimit) {

      if (gc_overhead_limit_count() >=

          AdaptiveSizePolicyGCTimeLimitThreshold){

        // All conditions have been met for throwing an out-of-memory

        set_gc_overhead_limit_exceeded(true);

        // Avoid consecutive OOM due to the gc time limit by resetting

        // the counter.

        reset_gc_overhead_limit_count();

      } else {

        // The required consecutive collections which exceed the

        // GC time limit may or may not have been reached. We

        // are approaching that condition and so as not to

        // throw an out-of-memory before all SoftRef‘s have been

        // cleared, set _should_clear_all_soft_refs in CollectorPolicy.

        // The clearing will be done on the next GC.

        bool near_limit = gc_overhead_limit_near();

        if (near_limit) {

          collector_policy->set_should_clear_all_soft_refs(true);

          if (PrintGCDetails && Verbose) {

            gclog_or_tty->print_cr("  Nearing GC overhead limit, "

              "will be clearing all SoftReference");

          }

        }

      }

    }

    // Set this even when the overhead limit will not

    // cause an out-of-memory.  Diagnostic message indicating

    // that the overhead limit is being exceeded is sometimes

    // printed.

    print_gc_overhead_limit_would_be_exceeded = true;

  } else {

    // Did not exceed overhead limits

    reset_gc_overhead_limit_count();

  }

}