1053 void GenCollectedHeap::save_marks() { 1054 for (int i = 0; i < _n_gens; i++) { 1055 _gens[i]->save_marks(); 1056 } 1057 } 1058 1059 void GenCollectedHeap::compute_new_generation_sizes(int collectedGen) { 1060 for (int i = 0; i <= collectedGen; i++) { 1061 _gens[i]->compute_new_size(); 1062 } 1063 } 1064 1065 GenCollectedHeap* GenCollectedHeap::heap() { 1066 assert(_gch != NULL, "Uninitialized access to GenCollectedHeap::heap()"); 1067 assert(_gch->kind() == CollectedHeap::GenCollectedHeap, "not a generational heap"); 1068 return _gch; 1069 } 1070 1071 1072 void GenCollectedHeap::prepare_for_compaction() { 1073 Generation* scanning_gen = _gens[_n_gens-1]; 1074 // Start by compacting into same gen. 1075 CompactPoint cp(scanning_gen, NULL, NULL); 1076 while (scanning_gen != NULL) { 1077 scanning_gen->prepare_for_compaction(&cp); 1078 scanning_gen = prev_gen(scanning_gen); 1079 } 1080 } 1081 1082 GCStats* GenCollectedHeap::gc_stats(int level) const { 1083 return _gens[level]->gc_stats(); 1084 } 1085 1086 void GenCollectedHeap::verify(bool silent, VerifyOption option /* ignored */) { 1087 for (int i = _n_gens-1; i >= 0; i--) { 1088 Generation* g = _gens[i]; 1089 if (!silent) { 1090 gclog_or_tty->print(g->name()); 1091 gclog_or_tty->print(" "); 1092 } 1093 g->verify(); 1094 } 1095 if (!silent) { 1096 gclog_or_tty->print("remset "); 1097 } 1098 rem_set()->verify(); 1099 } 1228 if (ZapUnusedHeapArea) { 1229 GenGCSaveTopsBeforeGCClosure blk; 1230 generation_iterate(&blk, false); // not old-to-young. 1231 } 1232 } 1233 #endif // not PRODUCT 1234 1235 class GenEnsureParsabilityClosure: public GenCollectedHeap::GenClosure { 1236 public: 1237 void do_generation(Generation* gen) { 1238 gen->ensure_parsability(); 1239 } 1240 }; 1241 1242 void GenCollectedHeap::ensure_parsability(bool retire_tlabs) { 1243 CollectedHeap::ensure_parsability(retire_tlabs); 1244 GenEnsureParsabilityClosure ep_cl; 1245 generation_iterate(&ep_cl, false); 1246 } 1247 1248 oop GenCollectedHeap::handle_failed_promotion(Generation* gen, 1249 oop obj, 1250 size_t obj_size) { 1251 assert(obj_size == (size_t)obj->size(), "bad obj_size passed in"); 1252 HeapWord* result = NULL; 1253 1254 // First give each higher generation a chance to allocate the promoted object. 1255 Generation* allocator = next_gen(gen); 1256 if (allocator != NULL) { 1257 do { 1258 result = allocator->allocate(obj_size, false); 1259 } while (result == NULL && (allocator = next_gen(allocator)) != NULL); 1260 } 1261 1262 if (result == NULL) { 1263 // Then give gen and higher generations a chance to expand and allocate the 1264 // object. 1265 do { 1266 result = gen->expand_and_allocate(obj_size, false); 1267 } while (result == NULL && (gen = next_gen(gen)) != NULL); 1268 } 1269 1270 if (result != NULL) { 1271 Copy::aligned_disjoint_words((HeapWord*)obj, result, obj_size); 1272 } 1273 return oop(result); 1274 } 1275 1276 class GenTimeOfLastGCClosure: public GenCollectedHeap::GenClosure { 1277 jlong _time; // in ms 1278 jlong _now; // in ms 1279 1280 public: 1281 GenTimeOfLastGCClosure(jlong now) : _time(now), _now(now) { } 1282 1283 jlong time() { return _time; } 1284 1285 void do_generation(Generation* gen) { 1286 _time = MIN2(_time, gen->time_of_last_gc(_now)); 1287 } 1288 }; | 1053 void GenCollectedHeap::save_marks() { 1054 for (int i = 0; i < _n_gens; i++) { 1055 _gens[i]->save_marks(); 1056 } 1057 } 1058 1059 void GenCollectedHeap::compute_new_generation_sizes(int collectedGen) { 1060 for (int i = 0; i <= collectedGen; i++) { 1061 _gens[i]->compute_new_size(); 1062 } 1063 } 1064 1065 GenCollectedHeap* GenCollectedHeap::heap() { 1066 assert(_gch != NULL, "Uninitialized access to GenCollectedHeap::heap()"); 1067 assert(_gch->kind() == CollectedHeap::GenCollectedHeap, "not a generational heap"); 1068 return _gch; 1069 } 1070 1071 1072 void GenCollectedHeap::prepare_for_compaction() { 1073 guarantee(_n_gens = 2, "Wrong number of generations"); 1074 Generation* old_gen = _gens[1]; 1075 // Start by compacting into same gen. 1076 CompactPoint cp(old_gen, NULL, NULL); 1077 old_gen->prepare_for_compaction(&cp); 1078 Generation* young_gen = _gens[0]; 1079 young_gen->prepare_for_compaction(&cp); 1080 } 1081 1082 GCStats* GenCollectedHeap::gc_stats(int level) const { 1083 return _gens[level]->gc_stats(); 1084 } 1085 1086 void GenCollectedHeap::verify(bool silent, VerifyOption option /* ignored */) { 1087 for (int i = _n_gens-1; i >= 0; i--) { 1088 Generation* g = _gens[i]; 1089 if (!silent) { 1090 gclog_or_tty->print(g->name()); 1091 gclog_or_tty->print(" "); 1092 } 1093 g->verify(); 1094 } 1095 if (!silent) { 1096 gclog_or_tty->print("remset "); 1097 } 1098 rem_set()->verify(); 1099 } 1228 if (ZapUnusedHeapArea) { 1229 GenGCSaveTopsBeforeGCClosure blk; 1230 generation_iterate(&blk, false); // not old-to-young. 1231 } 1232 } 1233 #endif // not PRODUCT 1234 1235 class GenEnsureParsabilityClosure: public GenCollectedHeap::GenClosure { 1236 public: 1237 void do_generation(Generation* gen) { 1238 gen->ensure_parsability(); 1239 } 1240 }; 1241 1242 void GenCollectedHeap::ensure_parsability(bool retire_tlabs) { 1243 CollectedHeap::ensure_parsability(retire_tlabs); 1244 GenEnsureParsabilityClosure ep_cl; 1245 generation_iterate(&ep_cl, false); 1246 } 1247 1248 oop GenCollectedHeap::handle_failed_promotion(Generation* old_gen, 1249 oop obj, 1250 size_t obj_size) { 1251 guarantee(old_gen->level() == 1, "We only get here with an old generation"); 1252 assert(obj_size == (size_t)obj->size(), "bad obj_size passed in"); 1253 HeapWord* result = NULL; 1254 1255 result = old_gen->expand_and_allocate(obj_size, false); 1256 1257 if (result != NULL) { 1258 Copy::aligned_disjoint_words((HeapWord*)obj, result, obj_size); 1259 } 1260 return oop(result); 1261 } 1262 1263 class GenTimeOfLastGCClosure: public GenCollectedHeap::GenClosure { 1264 jlong _time; // in ms 1265 jlong _now; // in ms 1266 1267 public: 1268 GenTimeOfLastGCClosure(jlong now) : _time(now), _now(now) { } 1269 1270 jlong time() { return _time; } 1271 1272 void do_generation(Generation* gen) { 1273 _time = MIN2(_time, gen->time_of_last_gc(_now)); 1274 } 1275 }; |