--- old/src/hotspot/share/gc/parallel/adjoiningGenerationsForHeteroHeap.cpp 2018-10-03 14:40:06.440948900 -0700 +++ new/src/hotspot/share/gc/parallel/adjoiningGenerationsForHeteroHeap.cpp 2018-10-03 14:40:05.313382700 -0700 @@ -46,8 +46,8 @@ size_t max_young_byte_size = policy->max_young_size(); // create HeteroVirtualSpaces which is composed of non-overlapping virtual spaces. - _virtual_spaces = new HeteroVirtualSpaces(old_young_rs, min_old_byte_size, - min_young_byte_size, _total_size_limit, alignment); + HeteroVirtualSpaces* hetero_virtual_spaces = new HeteroVirtualSpaces(old_young_rs, min_old_byte_size, + min_young_byte_size, _total_size_limit, alignment); assert(min_old_byte_size <= init_old_byte_size && init_old_byte_size <= max_old_byte_size, "Parameter check"); @@ -60,17 +60,17 @@ // for initialization of the generation. // Does the actual creation of the virtual spaces - _virtual_spaces->initialize(max_old_byte_size, init_old_byte_size, init_young_byte_size); + hetero_virtual_spaces->initialize(max_old_byte_size, init_old_byte_size, init_young_byte_size); - _young_gen = new ASPSYoungGen(_virtual_spaces->high(), - _virtual_spaces->high()->committed_size() /* intial_size */, + _young_gen = new ASPSYoungGen(hetero_virtual_spaces->high(), + hetero_virtual_spaces->high()->committed_size() /* intial_size */, min_young_byte_size, - (static_cast (_virtual_spaces))->max_young_size()); + hetero_virtual_spaces->max_young_size()); - _old_gen = new ASPSOldGen(_virtual_spaces->low(), - _virtual_spaces->low()->committed_size() /* intial_size */, + _old_gen = new ASPSOldGen(hetero_virtual_spaces->low(), + hetero_virtual_spaces->low()->committed_size() /* intial_size */, min_old_byte_size, - (static_cast (_virtual_spaces))->max_old_size(), "old", 1); + hetero_virtual_spaces->max_old_size(), "old", 1); young_gen()->initialize_work(); assert(young_gen()->reserved().byte_size() <= young_gen()->gen_size_limit(), "Consistency check"); @@ -79,6 +79,8 @@ old_gen()->initialize_work("old", 1); assert(old_gen()->reserved().byte_size() <= old_gen()->gen_size_limit(), "Consistency check"); assert(old_young_rs.size() >= old_gen()->gen_size_limit(), "Consistency check"); + + _virtual_spaces = hetero_virtual_spaces; } size_t AdjoiningGenerationsForHeteroHeap::required_reserved_memory(GenerationSizer* policy) { @@ -119,13 +121,13 @@ size_t initial_young_reserved_size = _max_total_size - initial_old_reserved_size; young_rs = young_rs.last_part(_max_young_byte_size - initial_young_reserved_size); - _old_vs = new PSFileBackedVirtualSpace(old_rs, alignment(), AllocateOldGenAt); - if (!_old_vs->expand_by(init_old_byte_size)) { + _low = new PSFileBackedVirtualSpace(old_rs, alignment(), AllocateOldGenAt); + if (!_low->expand_by(init_old_byte_size)) { vm_exit_during_initialization("Could not reserve enough space for object heap"); } - _young_vs = new PSVirtualSpaceHighToLow(young_rs, alignment()); - if (!_young_vs->expand_by(init_young_byte_size)) { + _high = new PSVirtualSpaceHighToLow(young_rs, alignment()); + if (!_high->expand_by(init_young_byte_size)) { vm_exit_during_initialization("Could not reserve enough space for object heap"); } } @@ -135,15 +137,15 @@ // increasing old generation size and decreasing young generation size by same amount. bool AdjoiningGenerationsForHeteroHeap::HeteroVirtualSpaces::adjust_boundary_up(size_t change_in_bytes) { assert(UseAdaptiveSizePolicy && UseAdaptiveGCBoundary, "runtime check"); - DEBUG_ONLY(size_t total_size_before = _young_vs->reserved_size() + _old_vs->reserved_size()); + DEBUG_ONLY(size_t total_size_before = young_vs()->reserved_size() + old_vs()->reserved_size()); size_t bytes_needed = change_in_bytes; - size_t uncommitted_in_old = MIN2(_old_vs->uncommitted_size(), bytes_needed); + size_t uncommitted_in_old = MIN2(old_vs()->uncommitted_size(), bytes_needed); bool old_expanded = false; // 1. Try to expand old within its reserved space. if (uncommitted_in_old != 0) { - if (!_old_vs->expand_by(uncommitted_in_old)) { + if (!old_vs()->expand_by(uncommitted_in_old)) { return false; } old_expanded = true; @@ -156,36 +158,36 @@ size_t bytes_to_add_in_old = 0; // 2. Get uncommitted memory from Young virtualspace. - size_t young_uncommitted = MIN2(_young_vs->uncommitted_size(), bytes_needed); + size_t young_uncommitted = MIN2(young_vs()->uncommitted_size(), bytes_needed); if (young_uncommitted > 0) { - _young_vs->set_reserved(_young_vs->reserved_low_addr() + young_uncommitted, - _young_vs->reserved_high_addr(), - _young_vs->special()); + young_vs()->set_reserved(young_vs()->reserved_low_addr() + young_uncommitted, + young_vs()->reserved_high_addr(), + young_vs()->special()); bytes_needed -= young_uncommitted; bytes_to_add_in_old = young_uncommitted; } // 3. Get committed memory from Young virtualspace if (bytes_needed > 0) { - size_t shrink_size = align_down(bytes_needed, _young_vs->alignment()); - bool ret = _young_vs->shrink_by(shrink_size); + size_t shrink_size = align_down(bytes_needed, young_vs()->alignment()); + bool ret = young_vs()->shrink_by(shrink_size); assert(ret, "We should be able to shrink young space"); - _young_vs->set_reserved(_young_vs->reserved_low_addr() + shrink_size, - _young_vs->reserved_high_addr(), - _young_vs->special()); + young_vs()->set_reserved(young_vs()->reserved_low_addr() + shrink_size, + young_vs()->reserved_high_addr(), + young_vs()->special()); bytes_to_add_in_old += shrink_size; } // 4. Increase size of old space - _old_vs->set_reserved(_old_vs->reserved_low_addr(), - _old_vs->reserved_high_addr() + bytes_to_add_in_old, - _old_vs->special()); - if (!_old_vs->expand_by(bytes_to_add_in_old) && !old_expanded) { + old_vs()->set_reserved(old_vs()->reserved_low_addr(), + old_vs()->reserved_high_addr() + bytes_to_add_in_old, + old_vs()->special()); + if (!old_vs()->expand_by(bytes_to_add_in_old) && !old_expanded) { return false; } - DEBUG_ONLY(size_t total_size_after = _young_vs->reserved_size() + _old_vs->reserved_size()); + DEBUG_ONLY(size_t total_size_after = young_vs()->reserved_size() + old_vs()->reserved_size()); assert(total_size_after == total_size_before, "should be equal"); return true; @@ -195,15 +197,15 @@ // Increase young generation size and decrease old generation size by same amount. bool AdjoiningGenerationsForHeteroHeap::HeteroVirtualSpaces::adjust_boundary_down(size_t change_in_bytes) { assert(UseAdaptiveSizePolicy && UseAdaptiveGCBoundary, "runtime check"); - DEBUG_ONLY(size_t total_size_before = _young_vs->reserved_size() + _old_vs->reserved_size()); + DEBUG_ONLY(size_t total_size_before = young_vs()->reserved_size() + old_vs()->reserved_size()); size_t bytes_needed = change_in_bytes; - size_t uncommitted_in_young = MIN2(_young_vs->uncommitted_size(), bytes_needed); + size_t uncommitted_in_young = MIN2(young_vs()->uncommitted_size(), bytes_needed); bool young_expanded = false; // 1. Try to expand old within its reserved space. if (uncommitted_in_young > 0) { - if (!_young_vs->expand_by(uncommitted_in_young)) { + if (!young_vs()->expand_by(uncommitted_in_young)) { return false; } young_expanded = true; @@ -216,37 +218,37 @@ size_t bytes_to_add_in_young = 0; // 2. Get uncommitted memory from Old virtualspace. - size_t old_uncommitted = MIN2(_old_vs->uncommitted_size(), bytes_needed); + size_t old_uncommitted = MIN2(old_vs()->uncommitted_size(), bytes_needed); if (old_uncommitted > 0) { - _old_vs->set_reserved(_old_vs->reserved_low_addr(), - _old_vs->reserved_high_addr() - old_uncommitted, - _old_vs->special()); + old_vs()->set_reserved(old_vs()->reserved_low_addr(), + old_vs()->reserved_high_addr() - old_uncommitted, + old_vs()->special()); bytes_needed -= old_uncommitted; bytes_to_add_in_young = old_uncommitted; } // 3. Get committed memory from Old virtualspace if (bytes_needed > 0) { - size_t shrink_size = align_down(bytes_needed, _old_vs->alignment()); - bool ret = _old_vs->shrink_by(shrink_size); + size_t shrink_size = align_down(bytes_needed, old_vs()->alignment()); + bool ret = old_vs()->shrink_by(shrink_size); assert(ret, "We should be able to shrink young space"); - _old_vs->set_reserved(_old_vs->reserved_low_addr(), - _old_vs->reserved_high_addr() - shrink_size, - _old_vs->special()); + old_vs()->set_reserved(old_vs()->reserved_low_addr(), + old_vs()->reserved_high_addr() - shrink_size, + old_vs()->special()); bytes_to_add_in_young += shrink_size; } assert(bytes_to_add_in_young <= change_in_bytes, "should not be more than requested size"); // 4. Increase size of young space - _young_vs->set_reserved(_young_vs->reserved_low_addr() - bytes_to_add_in_young, - _young_vs->reserved_high_addr(), - _young_vs->special()); - if (!_young_vs->expand_by(bytes_to_add_in_young) && !young_expanded) { + young_vs()->set_reserved(young_vs()->reserved_low_addr() - bytes_to_add_in_young, + young_vs()->reserved_high_addr(), + young_vs()->special()); + if (!young_vs()->expand_by(bytes_to_add_in_young) && !young_expanded) { return false; } - DEBUG_ONLY(size_t total_size_after = _young_vs->reserved_size() + _old_vs->reserved_size()); + DEBUG_ONLY(size_t total_size_after = young_vs()->reserved_size() + old_vs()->reserved_size()); assert(total_size_after == total_size_before, "should be equal"); return true; --- old/src/hotspot/share/gc/parallel/adjoiningGenerationsForHeteroHeap.hpp 2018-10-03 14:40:21.621881800 -0700 +++ new/src/hotspot/share/gc/parallel/adjoiningGenerationsForHeteroHeap.hpp 2018-10-03 14:40:20.578710400 -0700 @@ -38,27 +38,27 @@ return _total_size_limit; } - // HeteroVirtualSpaces creates non-overlapping virtual spaces. - // low() manages memory in nv-dimm and is meant for old generation. - // high() manages memory in dram and is meant for young generation. + // HeteroVirtualSpaces creates non-overlapping virtual spaces. Here _low and _high do not share a reserved space, i.e. there is no boundary + // separating the two virtual spaces. class HeteroVirtualSpaces : public AdjoiningVirtualSpaces { - PSVirtualSpace* _young_vs; - PSVirtualSpace* _old_vs; - size_t _min_old_byte_size; size_t _min_young_byte_size; size_t _max_old_byte_size; size_t _max_young_byte_size; size_t _max_total_size; + // Internally we access the virtual spaces using these methods. It increases readability, since we were not really + // dealing with adjoining virtual spaces separated by a boundary as is the case in base class. + // Externally they are accessed using low() and high() methods of base class. + PSVirtualSpace* young_vs() { return high(); } + PSVirtualSpace* old_vs() { return low(); } + public: HeteroVirtualSpaces(ReservedSpace rs, size_t min_old_byte_size, size_t min_young_byte_size, size_t max_total_size, size_t alignment); - PSVirtualSpace* high() { return _young_vs; } - PSVirtualSpace* low() { return _old_vs; } // Increase old generation size and decrease young generation size by same amount bool adjust_boundary_up(size_t size_in_bytes); // Increase young generation size and decrease old generation size by same amount --- old/src/hotspot/share/gc/parallel/adjoiningVirtualSpaces.hpp 2018-10-03 14:40:36.503991800 -0700 +++ new/src/hotspot/share/gc/parallel/adjoiningVirtualSpaces.hpp 2018-10-03 14:40:35.408811800 -0700 @@ -60,11 +60,11 @@ // interfaces for moving the this boundary. class AdjoiningVirtualSpaces : public CHeapObj { +protected: // space at the high end and the low end, respectively PSVirtualSpace* _high; PSVirtualSpace* _low; -protected: // The reserved space spanned by the two spaces. ReservedSpace _reserved_space; @@ -108,7 +108,7 @@ // Sets the boundaries for the virtual spaces and commits and // initial size; - void initialize(size_t max_low_byte_size, + virtual void initialize(size_t max_low_byte_size, size_t init_low_byte_size, size_t init_high_byte_size); };