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 G1RegionToSpaceMapper* result =
1574 G1RegionToSpaceMapper::create_mapper(rs,
1575 size,
1576 rs.alignment(),
1577 HeapRegion::GrainBytes,
1578 translation_factor,
1579 mtGC);
1580
1581 os::trace_page_sizes_for_requested_size(description,
1582 size,
1583 preferred_page_size,
1584 rs.alignment(),
1585 rs.base(),
1586 rs.size());
1587
1588 return result;
1589 }
1590
1591 jint G1CollectedHeap::initialize_concurrent_refinement() {
1592 jint ecode = JNI_OK;
1593 _cr = G1ConcurrentRefine::create(&ecode);
1594 return ecode;
1595 }
1596
1597 jint G1CollectedHeap::initialize_young_gen_sampling_thread() {
1598 _young_gen_sampling_thread = new G1YoungRemSetSamplingThread();
1599 if (_young_gen_sampling_thread->osthread() == NULL) {
1600 vm_shutdown_during_initialization("Could not create G1YoungRemSetSamplingThread");
1601 return JNI_ENOMEM;
1602 }
1603 return JNI_OK;
1604 }
1641
1642 ReservedSpace heap_rs = Universe::reserve_heap(max_byte_size,
1643 heap_alignment);
1644
1645 initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
1646
1647 // Create the barrier set for the entire reserved region.
1648 G1CardTable* ct = new G1CardTable(reserved_region());
1649 ct->initialize();
1650 G1BarrierSet* bs = new G1BarrierSet(ct);
1651 bs->initialize();
1652 assert(bs->is_a(BarrierSet::G1BarrierSet), "sanity");
1653 BarrierSet::set_barrier_set(bs);
1654 _card_table = ct;
1655
1656 // Create the hot card cache.
1657 _hot_card_cache = new G1HotCardCache(this);
1658
1659 // Carve out the G1 part of the heap.
1660 ReservedSpace g1_rs = heap_rs.first_part(max_byte_size);
1661 size_t page_size = UseLargePages ? os::large_page_size() : os::vm_page_size();
1662 G1RegionToSpaceMapper* heap_storage =
1663 G1RegionToSpaceMapper::create_mapper(g1_rs,
1664 g1_rs.size(),
1665 page_size,
1666 HeapRegion::GrainBytes,
1667 1,
1668 mtJavaHeap);
1669 os::trace_page_sizes("Heap",
1670 collector_policy()->min_heap_byte_size(),
1671 max_byte_size,
1672 page_size,
1673 heap_rs.base(),
1674 heap_rs.size());
1675 heap_storage->set_mapping_changed_listener(&_listener);
1676
1677 // Create storage for the BOT, card table, card counts table (hot card cache) and the bitmaps.
1678 G1RegionToSpaceMapper* bot_storage =
1679 create_aux_memory_mapper("Block Offset Table",
1680 G1BlockOffsetTable::compute_size(g1_rs.size() / HeapWordSize),
1681 G1BlockOffsetTable::heap_map_factor());
|
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());
|