242 // The one and only G1CollectedHeap, so static functions can find it. |
242 // The one and only G1CollectedHeap, so static functions can find it. |
243 static G1CollectedHeap* _g1h; |
243 static G1CollectedHeap* _g1h; |
244 |
244 |
245 static size_t _humongous_object_threshold_in_words; |
245 static size_t _humongous_object_threshold_in_words; |
246 |
246 |
247 // Storage for the G1 heap. |
|
248 VirtualSpace _g1_storage; |
|
249 MemRegion _g1_reserved; |
|
250 |
|
251 // The part of _g1_storage that is currently committed. |
|
252 MemRegion _g1_committed; |
|
253 |
|
254 // The master free list. It will satisfy all new region allocations. |
|
255 FreeRegionList _free_list; |
|
256 |
|
257 // The secondary free list which contains regions that have been |
247 // The secondary free list which contains regions that have been |
258 // freed up during the cleanup process. This will be appended to the |
248 // freed up during the cleanup process. This will be appended to |
259 // master free list when appropriate. |
249 // the master free list when appropriate. |
260 FreeRegionList _secondary_free_list; |
250 FreeRegionList _secondary_free_list; |
261 |
251 |
262 // It keeps track of the old regions. |
252 // It keeps track of the old regions. |
263 HeapRegionSet _old_set; |
253 HeapRegionSet _old_set; |
264 |
254 |
517 // an allocation of the given word_size. If do_expand is true, |
507 // an allocation of the given word_size. If do_expand is true, |
518 // attempt to expand the heap if necessary to satisfy the allocation |
508 // attempt to expand the heap if necessary to satisfy the allocation |
519 // request. If the region is to be used as an old region or for a |
509 // request. If the region is to be used as an old region or for a |
520 // humongous object, set is_old to true. If not, to false. |
510 // humongous object, set is_old to true. If not, to false. |
521 HeapRegion* new_region(size_t word_size, bool is_old, bool do_expand); |
511 HeapRegion* new_region(size_t word_size, bool is_old, bool do_expand); |
522 |
|
523 // Attempt to satisfy a humongous allocation request of the given |
|
524 // size by finding a contiguous set of free regions of num_regions |
|
525 // length and remove them from the master free list. Return the |
|
526 // index of the first region or G1_NULL_HRS_INDEX if the search |
|
527 // was unsuccessful. |
|
528 uint humongous_obj_allocate_find_first(uint num_regions, |
|
529 size_t word_size); |
|
530 |
512 |
531 // Initialize a contiguous set of free regions of length num_regions |
513 // Initialize a contiguous set of free regions of length num_regions |
532 // and starting at index first so that they appear as a single |
514 // and starting at index first so that they appear as a single |
533 // humongous region. |
515 // humongous region. |
534 HeapWord* humongous_obj_allocate_initialize_regions(uint first, |
516 HeapWord* humongous_obj_allocate_initialize_regions(uint first, |
1191 // should be treated as an approximation, not a guarantee, for use in |
1173 // should be treated as an approximation, not a guarantee, for use in |
1192 // heuristic resizing decisions. |
1174 // heuristic resizing decisions. |
1193 virtual size_t unsafe_max_alloc(); |
1175 virtual size_t unsafe_max_alloc(); |
1194 |
1176 |
1195 virtual bool is_maximal_no_gc() const { |
1177 virtual bool is_maximal_no_gc() const { |
1196 return _g1_storage.uncommitted_size() == 0; |
1178 return _hrs.available() == 0; |
1197 } |
1179 } |
1198 |
1180 |
1199 // The total number of regions in the heap. |
1181 // The current number of regions in the heap. |
1200 uint n_regions() const { return _hrs.length(); } |
1182 uint num_regions() const { return _hrs.length(); } |
1201 |
1183 |
1202 // The max number of regions in the heap. |
1184 // The max number of regions in the heap. |
1203 uint max_regions() const { return _hrs.max_length(); } |
1185 uint max_regions() const { return _hrs.max_length(); } |
1204 |
1186 |
1205 // The number of regions that are completely free. |
1187 // The number of regions that are completely free. |
1206 uint free_regions() const { return _free_list.length(); } |
1188 uint num_free_regions() const { return _hrs.num_free_regions(); } |
1207 |
1189 |
1208 // The number of regions that are not completely free. |
1190 // The number of regions that are not completely free. |
1209 uint used_regions() const { return n_regions() - free_regions(); } |
1191 uint num_used_regions() const { return num_regions() - num_free_regions(); } |
1210 |
|
1211 // The number of regions available for "regular" expansion. |
|
1212 uint expansion_regions() const { return _expansion_regions; } |
|
1213 |
|
1214 // Factory method for HeapRegion instances. It will return NULL if |
|
1215 // the allocation fails. |
|
1216 HeapRegion* new_heap_region(uint hrs_index, HeapWord* bottom); |
|
1217 |
1192 |
1218 void verify_not_dirty_region(HeapRegion* hr) PRODUCT_RETURN; |
1193 void verify_not_dirty_region(HeapRegion* hr) PRODUCT_RETURN; |
1219 void verify_dirty_region(HeapRegion* hr) PRODUCT_RETURN; |
1194 void verify_dirty_region(HeapRegion* hr) PRODUCT_RETURN; |
1220 void verify_dirty_young_list(HeapRegion* head) PRODUCT_RETURN; |
1195 void verify_dirty_young_list(HeapRegion* head) PRODUCT_RETURN; |
1221 void verify_dirty_young_regions() PRODUCT_RETURN; |
1196 void verify_dirty_young_regions() PRODUCT_RETURN; |
1260 void verify_region_sets_optional() { } |
1235 void verify_region_sets_optional() { } |
1261 #endif // HEAP_REGION_SET_FORCE_VERIFY |
1236 #endif // HEAP_REGION_SET_FORCE_VERIFY |
1262 |
1237 |
1263 #ifdef ASSERT |
1238 #ifdef ASSERT |
1264 bool is_on_master_free_list(HeapRegion* hr) { |
1239 bool is_on_master_free_list(HeapRegion* hr) { |
1265 return hr->containing_set() == &_free_list; |
1240 return _hrs.is_free(hr); |
1266 } |
1241 } |
1267 #endif // ASSERT |
1242 #endif // ASSERT |
1268 |
1243 |
1269 // Wrapper for the region list operations that can be called from |
1244 // Wrapper for the region list operations that can be called from |
1270 // methods outside this class. |
1245 // methods outside this class. |
1272 void secondary_free_list_add(FreeRegionList* list) { |
1247 void secondary_free_list_add(FreeRegionList* list) { |
1273 _secondary_free_list.add_ordered(list); |
1248 _secondary_free_list.add_ordered(list); |
1274 } |
1249 } |
1275 |
1250 |
1276 void append_secondary_free_list() { |
1251 void append_secondary_free_list() { |
1277 _free_list.add_ordered(&_secondary_free_list); |
1252 _hrs.insert_list_into_free_list(&_secondary_free_list); |
1278 } |
1253 } |
1279 |
1254 |
1280 void append_secondary_free_list_if_not_empty_with_lock() { |
1255 void append_secondary_free_list_if_not_empty_with_lock() { |
1281 // If the secondary free list looks empty there's no reason to |
1256 // If the secondary free list looks empty there's no reason to |
1282 // take the lock and then try to append it. |
1257 // take the lock and then try to append it. |
1378 inline in_cset_state_t in_cset_state(const oop obj); |
1353 inline in_cset_state_t in_cset_state(const oop obj); |
1379 |
1354 |
1380 // Return "TRUE" iff the given object address is in the reserved |
1355 // Return "TRUE" iff the given object address is in the reserved |
1381 // region of g1. |
1356 // region of g1. |
1382 bool is_in_g1_reserved(const void* p) const { |
1357 bool is_in_g1_reserved(const void* p) const { |
1383 return _g1_reserved.contains(p); |
1358 return _hrs.reserved().contains(p); |
1384 } |
1359 } |
1385 |
1360 |
1386 // Returns a MemRegion that corresponds to the space that has been |
1361 // Returns a MemRegion that corresponds to the space that has been |
1387 // reserved for the heap |
1362 // reserved for the heap |
1388 MemRegion g1_reserved() { |
1363 MemRegion g1_reserved() const { |
1389 return _g1_reserved; |
1364 return _hrs.reserved(); |
1390 } |
1365 } |
1391 |
1366 |
1392 // Returns a MemRegion that corresponds to the space that has been |
1367 // Returns a MemRegion that corresponds to the space that has been |
1393 // committed in the heap |
1368 // committed in the heap |
1394 MemRegion g1_committed() { |
1369 MemRegion g1_committed() { |
1395 return _g1_committed; |
1370 return _hrs.committed(); |
1396 } |
1371 } |
1397 |
1372 |
1398 virtual bool is_in_closed_subset(const void* p) const; |
1373 virtual bool is_in_closed_subset(const void* p) const; |
1399 |
1374 |
1400 G1SATBCardTableModRefBS* g1_barrier_set() { |
1375 G1SATBCardTableModRefBS* g1_barrier_set() { |
1429 inline HeapRegion* region_at(uint index) const; |
1404 inline HeapRegion* region_at(uint index) const; |
1430 |
1405 |
1431 // Calculate the region index of the given address. Given address must be |
1406 // Calculate the region index of the given address. Given address must be |
1432 // within the heap. |
1407 // within the heap. |
1433 inline uint addr_to_region(HeapWord* addr) const; |
1408 inline uint addr_to_region(HeapWord* addr) const; |
|
1409 |
|
1410 inline HeapWord* bottom_addr_for_region(uint index) const; |
1434 |
1411 |
1435 // Divide the heap region sequence into "chunks" of some size (the number |
1412 // Divide the heap region sequence into "chunks" of some size (the number |
1436 // of regions divided by the number of parallel threads times some |
1413 // of regions divided by the number of parallel threads times some |
1437 // overpartition factor, currently 4). Assumes that this will be called |
1414 // overpartition factor, currently 4). Assumes that this will be called |
1438 // in parallel by ParallelGCThreads worker threads with discinct worker |
1415 // in parallel by ParallelGCThreads worker threads with discinct worker |
1443 // attempting to claim the first region in each chunk, and, if |
1420 // attempting to claim the first region in each chunk, and, if |
1444 // successful, applying the closure to each region in the chunk (and |
1421 // successful, applying the closure to each region in the chunk (and |
1445 // setting the claim value of the second and subsequent regions of the |
1422 // setting the claim value of the second and subsequent regions of the |
1446 // chunk.) For now requires that "doHeapRegion" always returns "false", |
1423 // chunk.) For now requires that "doHeapRegion" always returns "false", |
1447 // i.e., that a closure never attempt to abort a traversal. |
1424 // i.e., that a closure never attempt to abort a traversal. |
1448 void heap_region_par_iterate_chunked(HeapRegionClosure* blk, |
1425 void heap_region_par_iterate_chunked(HeapRegionClosure* cl, |
1449 uint worker, |
1426 uint worker_id, |
1450 uint no_of_par_workers, |
1427 uint num_workers, |
1451 jint claim_value); |
1428 jint claim_value) const; |
1452 |
1429 |
1453 // It resets all the region claim values to the default. |
1430 // It resets all the region claim values to the default. |
1454 void reset_heap_region_claim_values(); |
1431 void reset_heap_region_claim_values(); |
1455 |
1432 |
1456 // Resets the claim values of regions in the current |
1433 // Resets the claim values of regions in the current |
1470 void clear_cset_start_regions(); |
1447 void clear_cset_start_regions(); |
1471 |
1448 |
1472 // Given the id of a worker, obtain or calculate a suitable |
1449 // Given the id of a worker, obtain or calculate a suitable |
1473 // starting region for iterating over the current collection set. |
1450 // starting region for iterating over the current collection set. |
1474 HeapRegion* start_cset_region_for_worker(uint worker_i); |
1451 HeapRegion* start_cset_region_for_worker(uint worker_i); |
1475 |
|
1476 // This is a convenience method that is used by the |
|
1477 // HeapRegionIterator classes to calculate the starting region for |
|
1478 // each worker so that they do not all start from the same region. |
|
1479 HeapRegion* start_region_for_worker(uint worker_i, uint no_of_par_workers); |
|
1480 |
1452 |
1481 // Iterate over the regions (if any) in the current collection set. |
1453 // Iterate over the regions (if any) in the current collection set. |
1482 void collection_set_iterate(HeapRegionClosure* blk); |
1454 void collection_set_iterate(HeapRegionClosure* blk); |
1483 |
1455 |
1484 // As above but starting from region r |
1456 // As above but starting from region r |