1 /*
2 * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_GC_G1_G1ALLOCATOR_INLINE_HPP
26 #define SHARE_GC_G1_G1ALLOCATOR_INLINE_HPP
27
28 #include "gc/g1/g1Allocator.hpp"
29 #include "gc/g1/g1AllocRegion.inline.hpp"
30 #include "gc/shared/plab.inline.hpp"
31 #include "memory/universe.hpp"
32
current_node_index() const33 inline uint G1Allocator::current_node_index() const {
34 return _numa->index_of_current_thread();
35 }
36
mutator_alloc_region(uint node_index)37 inline MutatorAllocRegion* G1Allocator::mutator_alloc_region(uint node_index) {
38 assert(node_index < _num_alloc_regions, "Invalid index: %u", node_index);
39 return &_mutator_alloc_regions[node_index];
40 }
41
survivor_gc_alloc_region(uint node_index)42 inline SurvivorGCAllocRegion* G1Allocator::survivor_gc_alloc_region(uint node_index) {
43 assert(node_index < _num_alloc_regions, "Invalid index: %u", node_index);
44 return &_survivor_gc_alloc_regions[node_index];
45 }
46
old_gc_alloc_region()47 inline OldGCAllocRegion* G1Allocator::old_gc_alloc_region() {
48 return &_old_gc_alloc_region;
49 }
50
attempt_allocation(size_t min_word_size,size_t desired_word_size,size_t * actual_word_size)51 inline HeapWord* G1Allocator::attempt_allocation(size_t min_word_size,
52 size_t desired_word_size,
53 size_t* actual_word_size) {
54 uint node_index = current_node_index();
55 HeapWord* result = mutator_alloc_region(node_index)->attempt_retained_allocation(min_word_size, desired_word_size, actual_word_size);
56 if (result != NULL) {
57 return result;
58 }
59 return mutator_alloc_region(node_index)->attempt_allocation(min_word_size, desired_word_size, actual_word_size);
60 }
61
attempt_allocation_locked(size_t word_size)62 inline HeapWord* G1Allocator::attempt_allocation_locked(size_t word_size) {
63 uint node_index = current_node_index();
64 HeapWord* result = mutator_alloc_region(node_index)->attempt_allocation_locked(word_size);
65 assert(result != NULL || mutator_alloc_region(node_index)->get() == NULL,
66 "Must not have a mutator alloc region if there is no memory, but is " PTR_FORMAT, p2i(mutator_alloc_region(node_index)->get()));
67 return result;
68 }
69
attempt_allocation_force(size_t word_size)70 inline HeapWord* G1Allocator::attempt_allocation_force(size_t word_size) {
71 uint node_index = current_node_index();
72 return mutator_alloc_region(node_index)->attempt_allocation_force(word_size);
73 }
74
alloc_buffer(G1HeapRegionAttr dest,uint node_index) const75 inline PLAB* G1PLABAllocator::alloc_buffer(G1HeapRegionAttr dest, uint node_index) const {
76 assert(dest.is_valid(),
77 "Allocation buffer index out of bounds: %s", dest.get_type_str());
78 assert(_alloc_buffers[dest.type()] != NULL,
79 "Allocation buffer is NULL: %s", dest.get_type_str());
80 return alloc_buffer(dest.type(), node_index);
81 }
82
alloc_buffer(region_type_t dest,uint node_index) const83 inline PLAB* G1PLABAllocator::alloc_buffer(region_type_t dest, uint node_index) const {
84 assert(dest < G1HeapRegionAttr::Num,
85 "Allocation buffer index out of bounds: %u", dest);
86
87 if (dest == G1HeapRegionAttr::Young) {
88 assert(node_index < alloc_buffers_length(dest),
89 "Allocation buffer index out of bounds: %u, %u", dest, node_index);
90 return _alloc_buffers[dest][node_index];
91 } else {
92 return _alloc_buffers[dest][0];
93 }
94 }
95
alloc_buffers_length(region_type_t dest) const96 inline uint G1PLABAllocator::alloc_buffers_length(region_type_t dest) const {
97 if (dest == G1HeapRegionAttr::Young) {
98 return _allocator->num_nodes();
99 } else {
100 return 1;
101 }
102 }
103
plab_allocate(G1HeapRegionAttr dest,size_t word_sz,uint node_index)104 inline HeapWord* G1PLABAllocator::plab_allocate(G1HeapRegionAttr dest,
105 size_t word_sz,
106 uint node_index) {
107 PLAB* buffer = alloc_buffer(dest, node_index);
108 if (_survivor_alignment_bytes == 0 || !dest.is_young()) {
109 return buffer->allocate(word_sz);
110 } else {
111 return buffer->allocate_aligned(word_sz, _survivor_alignment_bytes);
112 }
113 }
114
allocate(G1HeapRegionAttr dest,size_t word_sz,bool * refill_failed,uint node_index)115 inline HeapWord* G1PLABAllocator::allocate(G1HeapRegionAttr dest,
116 size_t word_sz,
117 bool* refill_failed,
118 uint node_index) {
119 HeapWord* const obj = plab_allocate(dest, word_sz, node_index);
120 if (obj != NULL) {
121 return obj;
122 }
123 return allocate_direct_or_new_plab(dest, word_sz, refill_failed, node_index);
124 }
125
126 // Create the maps which is used to identify archive objects.
enable_archive_object_check()127 inline void G1ArchiveAllocator::enable_archive_object_check() {
128 if (_archive_check_enabled) {
129 return;
130 }
131
132 _archive_check_enabled = true;
133 size_t length = G1CollectedHeap::heap()->max_reserved_capacity();
134 _archive_region_map.initialize(G1CollectedHeap::heap()->base(),
135 G1CollectedHeap::heap()->base() + length,
136 HeapRegion::GrainBytes);
137 }
138
139 // Set the regions containing the specified address range as archive.
set_range_archive(MemRegion range,bool open)140 inline void G1ArchiveAllocator::set_range_archive(MemRegion range, bool open) {
141 assert(_archive_check_enabled, "archive range check not enabled");
142 log_info(gc, cds)("Mark %s archive regions in map: [" PTR_FORMAT ", " PTR_FORMAT "]",
143 open ? "open" : "closed",
144 p2i(range.start()),
145 p2i(range.last()));
146 uint8_t const value = open ? G1ArchiveRegionMap::OpenArchive : G1ArchiveRegionMap::ClosedArchive;
147 _archive_region_map.set_by_address(range, value);
148 }
149
150 // Clear the archive regions map containing the specified address range.
clear_range_archive(MemRegion range)151 inline void G1ArchiveAllocator::clear_range_archive(MemRegion range) {
152 assert(_archive_check_enabled, "archive range check not enabled");
153 log_info(gc, cds)("Clear archive regions in map: [" PTR_FORMAT ", " PTR_FORMAT "]",
154 p2i(range.start()),
155 p2i(range.last()));
156 _archive_region_map.set_by_address(range, G1ArchiveRegionMap::NoArchive);
157 }
158
159 // Check if an object is in a closed archive region using the _archive_region_map.
in_closed_archive_range(oop object)160 inline bool G1ArchiveAllocator::in_closed_archive_range(oop object) {
161 return _archive_region_map.get_by_address(cast_from_oop<HeapWord*>(object)) == G1ArchiveRegionMap::ClosedArchive;
162 }
163
in_open_archive_range(oop object)164 inline bool G1ArchiveAllocator::in_open_archive_range(oop object) {
165 return _archive_region_map.get_by_address(cast_from_oop<HeapWord*>(object)) == G1ArchiveRegionMap::OpenArchive;
166 }
167
168 // Check if archive object checking is enabled, to avoid calling in_open/closed_archive_range
169 // unnecessarily.
archive_check_enabled()170 inline bool G1ArchiveAllocator::archive_check_enabled() {
171 return _archive_check_enabled;
172 }
173
is_closed_archive_object(oop object)174 inline bool G1ArchiveAllocator::is_closed_archive_object(oop object) {
175 return (archive_check_enabled() && in_closed_archive_range(object));
176 }
177
is_open_archive_object(oop object)178 inline bool G1ArchiveAllocator::is_open_archive_object(oop object) {
179 return (archive_check_enabled() && in_open_archive_range(object));
180 }
181
is_archived_object(oop object)182 inline bool G1ArchiveAllocator::is_archived_object(oop object) {
183 return archive_check_enabled() &&
184 (_archive_region_map.get_by_address(cast_from_oop<HeapWord*>(object)) != G1ArchiveRegionMap::NoArchive);
185 }
186
187 #endif // SHARE_GC_G1_G1ALLOCATOR_INLINE_HPP
188