53 54 _virtual_space = vs; 55 } 56 57 void ASPSYoungGen::initialize_virtual_space(ReservedSpace rs, 58 size_t alignment) { 59 assert(_init_gen_size != 0, "Should have a finite size"); 60 _virtual_space = new PSVirtualSpaceHighToLow(rs, alignment); 61 if (!_virtual_space->expand_by(_init_gen_size)) { 62 vm_exit_during_initialization("Could not reserve enough space for " 63 "object heap"); 64 } 65 } 66 67 void ASPSYoungGen::initialize(ReservedSpace rs, size_t alignment) { 68 initialize_virtual_space(rs, alignment); 69 initialize_work(); 70 } 71 72 size_t ASPSYoungGen::available_for_expansion() { 73 74 size_t current_committed_size = virtual_space()->committed_size(); 75 assert((gen_size_limit() >= current_committed_size), 76 "generation size limit is wrong"); 77 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); 78 size_t result = gen_size_limit() - current_committed_size; 79 size_t result_aligned = align_size_down(result, heap->young_gen_alignment()); 80 return result_aligned; 81 } 82 83 // Return the number of bytes the young gen is willing give up. 84 // 85 // Future implementations could check the survivors and if to_space is in the 86 // right place (below from_space), take a chunk from to_space. 87 size_t ASPSYoungGen::available_for_contraction() { 88 89 size_t uncommitted_bytes = virtual_space()->uncommitted_size(); 90 if (uncommitted_bytes != 0) { 91 return uncommitted_bytes; 92 } 93 94 if (eden_space()->is_empty()) { 95 // Respect the minimum size for eden and for the young gen as a whole. 96 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); 97 const size_t eden_alignment = heap->intra_heap_alignment(); 98 const size_t gen_alignment = heap->young_gen_alignment(); 99 100 assert(eden_space()->capacity_in_bytes() >= eden_alignment, 101 "Alignment is wrong"); 102 size_t eden_avail = eden_space()->capacity_in_bytes() - eden_alignment; 103 eden_avail = align_size_down(eden_avail, gen_alignment); 104 105 assert(virtual_space()->committed_size() >= min_gen_size(), 106 "minimum gen size is wrong"); 107 size_t gen_avail = virtual_space()->committed_size() - min_gen_size(); 108 assert(virtual_space()->is_aligned(gen_avail), "not aligned"); 109 110 const size_t max_contraction = MIN2(eden_avail, gen_avail); 111 // See comment for ASPSOldGen::available_for_contraction() 112 // for reasons the "increment" fraction is used. 113 PSAdaptiveSizePolicy* policy = heap->size_policy(); 114 size_t result = policy->eden_increment_aligned_down(max_contraction); 115 size_t result_aligned = align_size_down(result, gen_alignment); 116 if (PrintAdaptiveSizePolicy && Verbose) { 117 gclog_or_tty->print_cr("ASPSYoungGen::available_for_contraction: %d K", 118 result_aligned/K); 119 gclog_or_tty->print_cr(" max_contraction %d K", max_contraction/K); 120 gclog_or_tty->print_cr(" eden_avail %d K", eden_avail/K); 121 gclog_or_tty->print_cr(" gen_avail %d K", gen_avail/K); 122 } 123 return result_aligned; 124 125 } 126 127 return 0; 128 } 129 130 // The current implementation only considers to the end of eden. 131 // If to_space is below from_space, to_space is not considered. 132 // to_space can be. 133 size_t ASPSYoungGen::available_to_live() { 134 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); 135 const size_t alignment = heap->intra_heap_alignment(); 136 137 // Include any space that is committed but is not in eden. 138 size_t available = pointer_delta(eden_space()->bottom(), 139 virtual_space()->low(), 140 sizeof(char)); 141 142 const size_t eden_capacity = eden_space()->capacity_in_bytes(); 143 if (eden_space()->is_empty() && eden_capacity > alignment) { 144 available += eden_capacity - alignment; | 53 54 _virtual_space = vs; 55 } 56 57 void ASPSYoungGen::initialize_virtual_space(ReservedSpace rs, 58 size_t alignment) { 59 assert(_init_gen_size != 0, "Should have a finite size"); 60 _virtual_space = new PSVirtualSpaceHighToLow(rs, alignment); 61 if (!_virtual_space->expand_by(_init_gen_size)) { 62 vm_exit_during_initialization("Could not reserve enough space for " 63 "object heap"); 64 } 65 } 66 67 void ASPSYoungGen::initialize(ReservedSpace rs, size_t alignment) { 68 initialize_virtual_space(rs, alignment); 69 initialize_work(); 70 } 71 72 size_t ASPSYoungGen::available_for_expansion() { 73 size_t current_committed_size = virtual_space()->committed_size(); 74 assert((gen_size_limit() >= current_committed_size), 75 "generation size limit is wrong"); 76 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); 77 size_t result = gen_size_limit() - current_committed_size; 78 size_t result_aligned = align_size_down(result, heap->young_gen_alignment()); 79 return result_aligned; 80 } 81 82 // Return the number of bytes the young gen is willing give up. 83 // 84 // Future implementations could check the survivors and if to_space is in the 85 // right place (below from_space), take a chunk from to_space. 86 size_t ASPSYoungGen::available_for_contraction() { 87 size_t uncommitted_bytes = virtual_space()->uncommitted_size(); 88 if (uncommitted_bytes != 0) { 89 return uncommitted_bytes; 90 } 91 92 if (eden_space()->is_empty()) { 93 // Respect the minimum size for eden and for the young gen as a whole. 94 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); 95 const size_t eden_alignment = heap->intra_heap_alignment(); 96 const size_t gen_alignment = heap->young_gen_alignment(); 97 98 assert(eden_space()->capacity_in_bytes() >= eden_alignment, 99 "Alignment is wrong"); 100 size_t eden_avail = eden_space()->capacity_in_bytes() - eden_alignment; 101 eden_avail = align_size_down(eden_avail, gen_alignment); 102 103 assert(virtual_space()->committed_size() >= min_gen_size(), 104 "minimum gen size is wrong"); 105 size_t gen_avail = virtual_space()->committed_size() - min_gen_size(); 106 assert(virtual_space()->is_aligned(gen_avail), "not aligned"); 107 108 const size_t max_contraction = MIN2(eden_avail, gen_avail); 109 // See comment for ASPSOldGen::available_for_contraction() 110 // for reasons the "increment" fraction is used. 111 PSAdaptiveSizePolicy* policy = heap->size_policy(); 112 size_t result = policy->eden_increment_aligned_down(max_contraction); 113 size_t result_aligned = align_size_down(result, gen_alignment); 114 if (PrintAdaptiveSizePolicy && Verbose) { 115 gclog_or_tty->print_cr("ASPSYoungGen::available_for_contraction: %d K", 116 result_aligned/K); 117 gclog_or_tty->print_cr(" max_contraction %d K", max_contraction/K); 118 gclog_or_tty->print_cr(" eden_avail %d K", eden_avail/K); 119 gclog_or_tty->print_cr(" gen_avail %d K", gen_avail/K); 120 } 121 return result_aligned; 122 } 123 124 return 0; 125 } 126 127 // The current implementation only considers to the end of eden. 128 // If to_space is below from_space, to_space is not considered. 129 // to_space can be. 130 size_t ASPSYoungGen::available_to_live() { 131 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap(); 132 const size_t alignment = heap->intra_heap_alignment(); 133 134 // Include any space that is committed but is not in eden. 135 size_t available = pointer_delta(eden_space()->bottom(), 136 virtual_space()->low(), 137 sizeof(char)); 138 139 const size_t eden_capacity = eden_space()->capacity_in_bytes(); 140 if (eden_space()->is_empty() && eden_capacity > alignment) { 141 available += eden_capacity - alignment; |