< prev index next >

src/hotspot/share/gc/g1/g1CollectedHeap.cpp

Print this page
rev 52577 : imported patch webrev.0
rev 52578 : imported patch webrev.1
rev 52579 : imported patch webrev.2_reserved_page_size
rev 52580 : [mq]: webrev.3


1547   _filler_array_max_size = _humongous_object_threshold_in_words;
1548 
1549   uint n_queues = ParallelGCThreads;
1550   _task_queues = new RefToScanQueueSet(n_queues);
1551 
1552   _evacuation_failed_info_array = NEW_C_HEAP_ARRAY(EvacuationFailedInfo, n_queues, mtGC);
1553 
1554   for (uint i = 0; i < n_queues; i++) {
1555     RefToScanQueue* q = new RefToScanQueue();
1556     q->initialize();
1557     _task_queues->register_queue(i, q);
1558     ::new (&_evacuation_failed_info_array[i]) EvacuationFailedInfo();
1559   }
1560 
1561   // Initialize the G1EvacuationFailureALot counters and flags.
1562   NOT_PRODUCT(reset_evacuation_should_fail();)
1563 
1564   guarantee(_task_queues != NULL, "task_queues allocation failure.");
1565 }
1566 
















1567 G1RegionToSpaceMapper* G1CollectedHeap::create_aux_memory_mapper(const char* description,
1568                                                                  size_t size,
1569                                                                  size_t translation_factor) {
1570   size_t preferred_page_size = os::page_size_for_region_unaligned(size, 1);
1571   // Allocate a new reserved space, preferring to use large pages.
1572   ReservedSpace rs(size, preferred_page_size);
1573   size_t page_size = rs.actual_page_size();
1574   G1RegionToSpaceMapper* result  =
1575     G1RegionToSpaceMapper::create_mapper(rs,
1576                                          size,
1577                                          page_size,
1578                                          HeapRegion::GrainBytes,
1579                                          translation_factor,
1580                                          mtGC);
1581 
1582   os::trace_page_sizes_for_requested_size(description,
1583                                           size,
1584                                           preferred_page_size,
1585                                           page_size,
1586                                           rs.base(),
1587                                           rs.size());
1588 
1589   return result;
1590 }
1591 
1592 jint G1CollectedHeap::initialize_concurrent_refinement() {
1593   jint ecode = JNI_OK;
1594   _cr = G1ConcurrentRefine::create(&ecode);
1595   return ecode;
1596 }
1597 
1598 jint G1CollectedHeap::initialize_young_gen_sampling_thread() {
1599   _young_gen_sampling_thread = new G1YoungRemSetSamplingThread();
1600   if (_young_gen_sampling_thread->osthread() == NULL) {
1601     vm_shutdown_during_initialization("Could not create G1YoungRemSetSamplingThread");
1602     return JNI_ENOMEM;
1603   }
1604   return JNI_OK;
1605 }


1642 
1643   ReservedSpace heap_rs = Universe::reserve_heap(max_byte_size,
1644                                                  heap_alignment);
1645 
1646   initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
1647 
1648   // Create the barrier set for the entire reserved region.
1649   G1CardTable* ct = new G1CardTable(reserved_region());
1650   ct->initialize();
1651   G1BarrierSet* bs = new G1BarrierSet(ct);
1652   bs->initialize();
1653   assert(bs->is_a(BarrierSet::G1BarrierSet), "sanity");
1654   BarrierSet::set_barrier_set(bs);
1655   _card_table = ct;
1656 
1657   // Create the hot card cache.
1658   _hot_card_cache = new G1HotCardCache(this);
1659 
1660   // Carve out the G1 part of the heap.
1661   ReservedSpace g1_rs = heap_rs.first_part(max_byte_size);
1662   size_t page_size = heap_rs.actual_page_size();
1663   G1RegionToSpaceMapper* heap_storage =
1664     G1RegionToSpaceMapper::create_mapper(g1_rs,
1665                                          g1_rs.size(),
1666                                          page_size,
1667                                          HeapRegion::GrainBytes,
1668                                          1,
1669                                          mtJavaHeap);
1670   os::trace_page_sizes("Heap",
1671                        collector_policy()->min_heap_byte_size(),
1672                        max_byte_size,
1673                        page_size,
1674                        heap_rs.base(),
1675                        heap_rs.size());
1676   heap_storage->set_mapping_changed_listener(&_listener);
1677 
1678   // Create storage for the BOT, card table, card counts table (hot card cache) and the bitmaps.
1679   G1RegionToSpaceMapper* bot_storage =
1680     create_aux_memory_mapper("Block Offset Table",
1681                              G1BlockOffsetTable::compute_size(g1_rs.size() / HeapWordSize),
1682                              G1BlockOffsetTable::heap_map_factor());




1547   _filler_array_max_size = _humongous_object_threshold_in_words;
1548 
1549   uint n_queues = ParallelGCThreads;
1550   _task_queues = new RefToScanQueueSet(n_queues);
1551 
1552   _evacuation_failed_info_array = NEW_C_HEAP_ARRAY(EvacuationFailedInfo, n_queues, mtGC);
1553 
1554   for (uint i = 0; i < n_queues; i++) {
1555     RefToScanQueue* q = new RefToScanQueue();
1556     q->initialize();
1557     _task_queues->register_queue(i, q);
1558     ::new (&_evacuation_failed_info_array[i]) EvacuationFailedInfo();
1559   }
1560 
1561   // Initialize the G1EvacuationFailureALot counters and flags.
1562   NOT_PRODUCT(reset_evacuation_should_fail();)
1563 
1564   guarantee(_task_queues != NULL, "task_queues allocation failure.");
1565 }
1566 
1567 static size_t actual_reserved_page_size(ReservedSpace rs) {
1568   size_t page_size = os::vm_page_size();
1569   if (UseLargePages) {
1570     // There are two ways to manage large page memory.
1571     // 1. OS supports committing large page memory.
1572     // 2. OS doesn't support committing large page memory so ReservedSpace manages it.
1573     //    And ReservedSpace calls it 'special'. If we failed to set 'special',
1574     //    we reserved memory without large page.
1575     if (os::can_commit_large_page_memory() || rs.special()) {
1576       page_size = os::large_page_size();
1577     }
1578   }
1579 
1580   return page_size;
1581 }
1582 
1583 G1RegionToSpaceMapper* G1CollectedHeap::create_aux_memory_mapper(const char* description,
1584                                                                  size_t size,
1585                                                                  size_t translation_factor) {
1586   size_t preferred_page_size = os::page_size_for_region_unaligned(size, 1);
1587   // Allocate a new reserved space, preferring to use large pages.
1588   ReservedSpace rs(size, preferred_page_size);

1589   G1RegionToSpaceMapper* result  =
1590     G1RegionToSpaceMapper::create_mapper(rs,
1591                                          size,
1592                                          rs.alignment(),
1593                                          HeapRegion::GrainBytes,
1594                                          translation_factor,
1595                                          mtGC);
1596 
1597   os::trace_page_sizes_for_requested_size(description,
1598                                           size,
1599                                           preferred_page_size,
1600                                           rs.alignment(),
1601                                           rs.base(),
1602                                           rs.size());
1603 
1604   return result;
1605 }
1606 
1607 jint G1CollectedHeap::initialize_concurrent_refinement() {
1608   jint ecode = JNI_OK;
1609   _cr = G1ConcurrentRefine::create(&ecode);
1610   return ecode;
1611 }
1612 
1613 jint G1CollectedHeap::initialize_young_gen_sampling_thread() {
1614   _young_gen_sampling_thread = new G1YoungRemSetSamplingThread();
1615   if (_young_gen_sampling_thread->osthread() == NULL) {
1616     vm_shutdown_during_initialization("Could not create G1YoungRemSetSamplingThread");
1617     return JNI_ENOMEM;
1618   }
1619   return JNI_OK;
1620 }


1657 
1658   ReservedSpace heap_rs = Universe::reserve_heap(max_byte_size,
1659                                                  heap_alignment);
1660 
1661   initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
1662 
1663   // Create the barrier set for the entire reserved region.
1664   G1CardTable* ct = new G1CardTable(reserved_region());
1665   ct->initialize();
1666   G1BarrierSet* bs = new G1BarrierSet(ct);
1667   bs->initialize();
1668   assert(bs->is_a(BarrierSet::G1BarrierSet), "sanity");
1669   BarrierSet::set_barrier_set(bs);
1670   _card_table = ct;
1671 
1672   // Create the hot card cache.
1673   _hot_card_cache = new G1HotCardCache(this);
1674 
1675   // Carve out the G1 part of the heap.
1676   ReservedSpace g1_rs = heap_rs.first_part(max_byte_size);
1677   size_t page_size = actual_reserved_page_size(heap_rs);
1678   G1RegionToSpaceMapper* heap_storage =
1679     G1RegionToSpaceMapper::create_mapper(g1_rs,
1680                                          g1_rs.size(),
1681                                          page_size,
1682                                          HeapRegion::GrainBytes,
1683                                          1,
1684                                          mtJavaHeap);
1685   os::trace_page_sizes("Heap",
1686                        collector_policy()->min_heap_byte_size(),
1687                        max_byte_size,
1688                        page_size,
1689                        heap_rs.base(),
1690                        heap_rs.size());
1691   heap_storage->set_mapping_changed_listener(&_listener);
1692 
1693   // Create storage for the BOT, card table, card counts table (hot card cache) and the bitmaps.
1694   G1RegionToSpaceMapper* bot_storage =
1695     create_aux_memory_mapper("Block Offset Table",
1696                              G1BlockOffsetTable::compute_size(g1_rs.size() / HeapWordSize),
1697                              G1BlockOffsetTable::heap_map_factor());


< prev index next >