1042 }
1043
1044 void VirtualSpace::print_on(outputStream* out) {
1045 out->print ("Virtual space:");
1046 if (special()) out->print(" (pinned in memory)");
1047 out->cr();
1048 out->print_cr(" - committed: " SIZE_FORMAT, committed_size());
1049 out->print_cr(" - reserved: " SIZE_FORMAT, reserved_size());
1050 out->print_cr(" - [low, high]: [" INTPTR_FORMAT ", " INTPTR_FORMAT "]", p2i(low()), p2i(high()));
1051 out->print_cr(" - [low_b, high_b]: [" INTPTR_FORMAT ", " INTPTR_FORMAT "]", p2i(low_boundary()), p2i(high_boundary()));
1052 }
1053
1054 void VirtualSpace::print() {
1055 print_on(tty);
1056 }
1057
1058 /////////////// Unit tests ///////////////
1059
1060 #ifndef PRODUCT
1061
1062 #define test_log(...) \
1063 do {\
1064 if (VerboseInternalVMTests) { \
1065 tty->print_cr(__VA_ARGS__); \
1066 tty->flush(); \
1067 }\
1068 } while (false)
1069
1070 class TestReservedSpace : AllStatic {
1071 public:
1072 static void small_page_write(void* addr, size_t size) {
1073 size_t page_size = os::vm_page_size();
1074
1075 char* end = (char*)addr + size;
1076 for (char* p = (char*)addr; p < end; p += page_size) {
1077 *p = 1;
1078 }
1079 }
1080
1081 static void release_memory_for_test(ReservedSpace rs) {
1082 if (rs.special()) {
1083 guarantee(os::release_memory_special(rs.base(), rs.size()), "Shouldn't fail");
1084 } else {
1085 guarantee(os::release_memory(rs.base(), rs.size()), "Shouldn't fail");
1086 }
1087 }
1088
1089 static void test_reserved_space1(size_t size, size_t alignment) {
1090 test_log("test_reserved_space1(%p)", (void*) (uintptr_t) size);
1091
1092 assert(is_aligned(size, alignment), "Incorrect input parameters");
1093
1094 ReservedSpace rs(size, // size
1095 alignment, // alignment
1096 UseLargePages, // large
1097 (char *)NULL); // requested_address
1098
1099 test_log(" rs.special() == %d", rs.special());
1100
1101 assert(rs.base() != NULL, "Must be");
1102 assert(rs.size() == size, "Must be");
1103
1104 assert(is_aligned(rs.base(), alignment), "aligned sizes should always give aligned addresses");
1105 assert(is_aligned(rs.size(), alignment), "aligned sizes should always give aligned addresses");
1106
1107 if (rs.special()) {
1108 small_page_write(rs.base(), size);
1109 }
1110
1111 release_memory_for_test(rs);
1112 }
1113
1114 static void test_reserved_space2(size_t size) {
1115 test_log("test_reserved_space2(%p)", (void*)(uintptr_t)size);
1116
1117 assert(is_aligned(size, os::vm_allocation_granularity()), "Must be at least AG aligned");
1118
1119 ReservedSpace rs(size);
1120
1121 test_log(" rs.special() == %d", rs.special());
1122
1123 assert(rs.base() != NULL, "Must be");
1124 assert(rs.size() == size, "Must be");
1125
1126 if (rs.special()) {
1127 small_page_write(rs.base(), size);
1128 }
1129
1130 release_memory_for_test(rs);
1131 }
1132
1133 static void test_reserved_space3(size_t size, size_t alignment, bool maybe_large) {
1134 test_log("test_reserved_space3(%p, %p, %d)",
1135 (void*)(uintptr_t)size, (void*)(uintptr_t)alignment, maybe_large);
1136
1137 if (size < alignment) {
1138 // Tests might set -XX:LargePageSizeInBytes=<small pages> and cause unexpected input arguments for this test.
1139 assert((size_t)os::vm_page_size() == os::large_page_size(), "Test needs further refinement");
1140 return;
1141 }
1142
1143 assert(is_aligned(size, os::vm_allocation_granularity()), "Must be at least AG aligned");
1144 assert(is_aligned(size, alignment), "Must be at least aligned against alignment");
1145
1146 bool large = maybe_large && UseLargePages && size >= os::large_page_size();
1147
1148 ReservedSpace rs(size, alignment, large, false);
1149
1150 test_log(" rs.special() == %d", rs.special());
1151
1152 assert(rs.base() != NULL, "Must be");
1153 assert(rs.size() == size, "Must be");
1154
1155 if (rs.special()) {
1156 small_page_write(rs.base(), size);
1157 }
1158
1159 release_memory_for_test(rs);
1160 }
1161
1162
1163 static void test_reserved_space1() {
1164 size_t size = 2 * 1024 * 1024;
1165 size_t ag = os::vm_allocation_granularity();
1166
1167 test_reserved_space1(size, ag);
1168 test_reserved_space1(size * 2, ag);
1169 test_reserved_space1(size * 10, ag);
1170 }
1171
|
1042 }
1043
1044 void VirtualSpace::print_on(outputStream* out) {
1045 out->print ("Virtual space:");
1046 if (special()) out->print(" (pinned in memory)");
1047 out->cr();
1048 out->print_cr(" - committed: " SIZE_FORMAT, committed_size());
1049 out->print_cr(" - reserved: " SIZE_FORMAT, reserved_size());
1050 out->print_cr(" - [low, high]: [" INTPTR_FORMAT ", " INTPTR_FORMAT "]", p2i(low()), p2i(high()));
1051 out->print_cr(" - [low_b, high_b]: [" INTPTR_FORMAT ", " INTPTR_FORMAT "]", p2i(low_boundary()), p2i(high_boundary()));
1052 }
1053
1054 void VirtualSpace::print() {
1055 print_on(tty);
1056 }
1057
1058 /////////////// Unit tests ///////////////
1059
1060 #ifndef PRODUCT
1061
1062 class TestReservedSpace : AllStatic {
1063 public:
1064 static void small_page_write(void* addr, size_t size) {
1065 size_t page_size = os::vm_page_size();
1066
1067 char* end = (char*)addr + size;
1068 for (char* p = (char*)addr; p < end; p += page_size) {
1069 *p = 1;
1070 }
1071 }
1072
1073 static void release_memory_for_test(ReservedSpace rs) {
1074 if (rs.special()) {
1075 guarantee(os::release_memory_special(rs.base(), rs.size()), "Shouldn't fail");
1076 } else {
1077 guarantee(os::release_memory(rs.base(), rs.size()), "Shouldn't fail");
1078 }
1079 }
1080
1081 static void test_reserved_space1(size_t size, size_t alignment) {
1082 assert(is_aligned(size, alignment), "Incorrect input parameters");
1083
1084 ReservedSpace rs(size, // size
1085 alignment, // alignment
1086 UseLargePages, // large
1087 (char *)NULL); // requested_address
1088
1089 assert(rs.base() != NULL, "Must be");
1090 assert(rs.size() == size, "Must be");
1091
1092 assert(is_aligned(rs.base(), alignment), "aligned sizes should always give aligned addresses");
1093 assert(is_aligned(rs.size(), alignment), "aligned sizes should always give aligned addresses");
1094
1095 if (rs.special()) {
1096 small_page_write(rs.base(), size);
1097 }
1098
1099 release_memory_for_test(rs);
1100 }
1101
1102 static void test_reserved_space2(size_t size) {
1103 assert(is_aligned(size, os::vm_allocation_granularity()), "Must be at least AG aligned");
1104
1105 ReservedSpace rs(size);
1106
1107 assert(rs.base() != NULL, "Must be");
1108 assert(rs.size() == size, "Must be");
1109
1110 if (rs.special()) {
1111 small_page_write(rs.base(), size);
1112 }
1113
1114 release_memory_for_test(rs);
1115 }
1116
1117 static void test_reserved_space3(size_t size, size_t alignment, bool maybe_large) {
1118 if (size < alignment) {
1119 // Tests might set -XX:LargePageSizeInBytes=<small pages> and cause unexpected input arguments for this test.
1120 assert((size_t)os::vm_page_size() == os::large_page_size(), "Test needs further refinement");
1121 return;
1122 }
1123
1124 assert(is_aligned(size, os::vm_allocation_granularity()), "Must be at least AG aligned");
1125 assert(is_aligned(size, alignment), "Must be at least aligned against alignment");
1126
1127 bool large = maybe_large && UseLargePages && size >= os::large_page_size();
1128
1129 ReservedSpace rs(size, alignment, large, false);
1130
1131 assert(rs.base() != NULL, "Must be");
1132 assert(rs.size() == size, "Must be");
1133
1134 if (rs.special()) {
1135 small_page_write(rs.base(), size);
1136 }
1137
1138 release_memory_for_test(rs);
1139 }
1140
1141
1142 static void test_reserved_space1() {
1143 size_t size = 2 * 1024 * 1024;
1144 size_t ag = os::vm_allocation_granularity();
1145
1146 test_reserved_space1(size, ag);
1147 test_reserved_space1(size * 2, ag);
1148 test_reserved_space1(size * 10, ag);
1149 }
1150
|