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