Mercurial > hg > truffle

comparison src/share/vm/memory/collectorPolicy.cpp @ 14359:f7f0c6a77d6d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8033426: Scale initial NewSize using NewRatio if not set on command line Summary: Now using NewRatio to size initial NewSize if not specified on commandline. Reviewed-by: jmasa, jwilhelm
author sjohanss
date Wed, 05 Feb 2014 11:05:13 +0100
parents 63a4eb8bcd23
children bac9ef65b71d 4ca6dc0799b6
comparison
equal deleted inserted replaced
14358:e5d78f318aec 14359:f7f0c6a77d6d
444 _min_gen0_size = max_new_size; 444 _min_gen0_size = max_new_size;
445 _initial_gen0_size = max_new_size; 445 _initial_gen0_size = max_new_size;
446 _max_gen0_size = max_new_size; 446 _max_gen0_size = max_new_size;
447 } else { 447 } else {
448 size_t desired_new_size = 0; 448 size_t desired_new_size = 0;
449 if (!FLAG_IS_DEFAULT(NewSize)) { 449 if (FLAG_IS_CMDLINE(NewSize)) {
450 // If NewSize is set ergonomically (for example by cms), it 450 // If NewSize is set on the command line, we must use it as
451 // would make sense to use it. If it is used, also use it 451 // the initial size and it also makes sense to use it as the
452 // to set the initial size. Although there is no reason 452 // lower limit.
453 // the minimum size and the initial size have to be the same,
454 // the current implementation gets into trouble during the calculation
455 // of the tenured generation sizes if they are different.
456 // Note that this makes the initial size and the minimum size
457 // generally small compared to the NewRatio calculation.
458 _min_gen0_size = NewSize; 453 _min_gen0_size = NewSize;
459 desired_new_size = NewSize; 454 desired_new_size = NewSize;
455 max_new_size = MAX2(max_new_size, NewSize);
456 } else if (FLAG_IS_ERGO(NewSize)) {
457 // If NewSize is set ergonomically, we should use it as a lower
458 // limit, but use NewRatio to calculate the initial size.
459 _min_gen0_size = NewSize;
460 desired_new_size =
461 MAX2(scale_by_NewRatio_aligned(_initial_heap_byte_size), NewSize);
460 max_new_size = MAX2(max_new_size, NewSize); 462 max_new_size = MAX2(max_new_size, NewSize);
461 } else { 463 } else {
462 // For the case where NewSize is the default, use NewRatio 464 // For the case where NewSize is the default, use NewRatio
463 // to size the minimum and initial generation sizes. 465 // to size the minimum and initial generation sizes.
464 // Use the default NewSize as the floor for these values. If 466 // Use the default NewSize as the floor for these values. If
978 _gc_policy_counters = new GCPolicyCounters("ParNew:MSC", 2, 3); 980 _gc_policy_counters = new GCPolicyCounters("ParNew:MSC", 2, 3);
979 } else { 981 } else {
980 _gc_policy_counters = new GCPolicyCounters("Copy:MSC", 2, 3); 982 _gc_policy_counters = new GCPolicyCounters("Copy:MSC", 2, 3);
981 } 983 }
982 } 984 }
985
986 /////////////// Unit tests ///////////////
987
988 #ifndef PRODUCT
989 // Testing that the NewSize flag is handled correct is hard because it
990 // depends on so many other configurable variables. This test only tries to
991 // verify that there are some basic rules for NewSize honored by the policies.
992 class TestGenCollectorPolicy {
993 public:
994 static void test() {
995 size_t flag_value;
996
997 save_flags();
998
999 // Set some limits that makes the math simple.
1000 FLAG_SET_ERGO(uintx, MaxHeapSize, 180 * M);
1001 FLAG_SET_ERGO(uintx, InitialHeapSize, 120 * M);
1002 Arguments::set_min_heap_size(40 * M);
1003
1004 // If NewSize is set on the command line, it should be used
1005 // for both min and initial young size if less than min heap.
1006 flag_value = 20 * M;
1007 FLAG_SET_CMDLINE(uintx, NewSize, flag_value);
1008 verify_min(flag_value);
1009 verify_initial(flag_value);
1010
1011 // If NewSize is set on command line, but is larger than the min
1012 // heap size, it should only be used for initial young size.
1013 flag_value = 80 * M;
1014 FLAG_SET_CMDLINE(uintx, NewSize, flag_value);
1015 verify_initial(flag_value);
1016
1017 // If NewSize has been ergonomically set, the collector policy
1018 // should use it for min but calculate the initial young size
1019 // using NewRatio.
1020 flag_value = 20 * M;
1021 FLAG_SET_ERGO(uintx, NewSize, flag_value);
1022 verify_min(flag_value);
1023 verify_scaled_initial(InitialHeapSize);
1024
1025 restore_flags();
1026
1027 }
1028
1029 static void verify_min(size_t expected) {
1030 MarkSweepPolicy msp;
1031 msp.initialize_all();
1032
1033 assert(msp.min_gen0_size() <= expected, err_msg("%zu > %zu", msp.min_gen0_size(), expected));
1034 }
1035
1036 static void verify_initial(size_t expected) {
1037 MarkSweepPolicy msp;
1038 msp.initialize_all();
1039
1040 assert(msp.initial_gen0_size() == expected, err_msg("%zu != %zu", msp.initial_gen0_size(), expected));
1041 }
1042
1043 static void verify_scaled_initial(size_t initial_heap_size) {
1044 MarkSweepPolicy msp;
1045 msp.initialize_all();
1046
1047 size_t expected = msp.scale_by_NewRatio_aligned(initial_heap_size);
1048 assert(msp.initial_gen0_size() == expected, err_msg("%zu != %zu", msp.initial_gen0_size(), expected));
1049 assert(FLAG_IS_ERGO(NewSize) && NewSize == expected,
1050 err_msg("NewSize should have been set ergonomically to %zu, but was %zu", expected, NewSize));
1051 }
1052
1053 private:
1054 static size_t original_InitialHeapSize;
1055 static size_t original_MaxHeapSize;
1056 static size_t original_MaxNewSize;
1057 static size_t original_MinHeapDeltaBytes;
1058 static size_t original_NewSize;
1059 static size_t original_OldSize;
1060
1061 static void save_flags() {
1062 original_InitialHeapSize = InitialHeapSize;
1063 original_MaxHeapSize = MaxHeapSize;
1064 original_MaxNewSize = MaxNewSize;
1065 original_MinHeapDeltaBytes = MinHeapDeltaBytes;
1066 original_NewSize = NewSize;
1067 original_OldSize = OldSize;
1068 }
1069
1070 static void restore_flags() {
1071 InitialHeapSize = original_InitialHeapSize;
1072 MaxHeapSize = original_MaxHeapSize;
1073 MaxNewSize = original_MaxNewSize;
1074 MinHeapDeltaBytes = original_MinHeapDeltaBytes;
1075 NewSize = original_NewSize;
1076 OldSize = original_OldSize;
1077 }
1078 };
1079
1080 size_t TestGenCollectorPolicy::original_InitialHeapSize = 0;
1081 size_t TestGenCollectorPolicy::original_MaxHeapSize = 0;
1082 size_t TestGenCollectorPolicy::original_MaxNewSize = 0;
1083 size_t TestGenCollectorPolicy::original_MinHeapDeltaBytes = 0;
1084 size_t TestGenCollectorPolicy::original_NewSize = 0;
1085 size_t TestGenCollectorPolicy::original_OldSize = 0;
1086
1087 void TestNewSize_test() {
1088 TestGenCollectorPolicy::test();
1089 }
1090
1091 #endif