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());
|