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 #include "precompiled.hpp"
25 #include "gc/z/zGlobals.hpp"
26 #include "gc/z/zVirtualMemory.inline.hpp"
27 #include "logging/log.hpp"
28 #include "services/memTracker.hpp"
29
30 ZVirtualMemoryManager::ZVirtualMemoryManager() :
31 _manager(),
32 _initialized(false) {
33
34 log_info(gc, init)("Address Space: " PTR_FORMAT " - " PTR_FORMAT " (" SIZE_FORMAT "T)",
35 ZAddressSpaceStart, ZAddressSpaceEnd, ZAddressSpaceSize / K / G);
36
37 // Reserve address space
38 if (!reserve(ZAddressSpaceStart, ZAddressSpaceSize)) {
39 return;
40 }
41
42 // Make the complete address view free
43 _manager.free(0, ZAddressOffsetMax);
44
45 // Register address space with native memory tracker
46 nmt_reserve(ZAddressSpaceStart, ZAddressSpaceSize);
47
48 // Successfully initialized
49 _initialized = true;
50 }
51
52 void ZVirtualMemoryManager::nmt_reserve(uintptr_t start, size_t size) {
53 MemTracker::record_virtual_memory_reserve((void*)start, size, CALLER_PC);
54 MemTracker::record_virtual_memory_type((void*)start, mtJavaHeap);
55 }
56
57 bool ZVirtualMemoryManager::is_initialized() const {
58 return _initialized;
59 }
60
61 ZVirtualMemory ZVirtualMemoryManager::alloc(size_t size, bool alloc_from_front) {
62 uintptr_t start;
63
64 if (alloc_from_front || size <= ZPageSizeSmall) {
65 // Small page
66 start = _manager.alloc_from_front(size);
67 } else {
68 // Medium/Large page
69 start = _manager.alloc_from_back(size);
70 }
71
72 return ZVirtualMemory(start, size);
73 }
74
|
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 #include "precompiled.hpp"
25 #include "gc/z/zAddress.inline.hpp"
26 #include "gc/z/zGlobals.hpp"
27 #include "gc/z/zVirtualMemory.inline.hpp"
28 #include "logging/log.hpp"
29 #include "services/memTracker.hpp"
30
31 bool ZVirtualMemoryManager::reserve_range(uintptr_t start, size_t size) {
32 // Reserve address space
33 char* const marked0_addr = (char*)ZAddress::marked0(start);
34 char* const marked1_addr = (char*)ZAddress::marked1(start);
35 char* const remapped_addr = (char*)ZAddress::remapped(start);
36
37 if (!os::attempt_reserve_memory_at(size, marked0_addr)) {
38 return false;
39 }
40
41 if (!os::attempt_reserve_memory_at(size, marked1_addr)) {
42 os::release_memory(marked0_addr, size);
43 return false;
44 }
45
46 if (!os::attempt_reserve_memory_at(size, remapped_addr)) {
47 os::release_memory(marked0_addr, size);
48 os::release_memory(marked1_addr, size);
49 return false;
50 }
51
52 // Make the address view free
53 _manager.free(start, size);
54 return true;
55 }
56
57 size_t ZVirtualMemoryManager::reserve(uintptr_t start, size_t size) {
58 if (reserve_range(start, size)) {
59 return size;
60 }
61
62 if (size <= ZGranuleSize) {
63 return 0;
64 }
65
66 const size_t range = size / 2;
67 return reserve(start, range) + reserve(start + range, range);
68 }
69
70 ZVirtualMemoryManager::ZVirtualMemoryManager() :
71 _manager(),
72 _initialized(false) {
73
74 log_info(gc, init)("Address Space: " PTR_FORMAT " - " PTR_FORMAT " (" SIZE_FORMAT "T)",
75 ZAddressSpaceStart, ZAddressSpaceEnd, ZAddressSpaceSize / K / G);
76
77 // Reserve address space
78 if (reserve(0, ZAddressOffsetMax) < MaxHeapSize) {
79 log_error(gc)("Failed to reserve enough address space for Java heap");
80 return;
81 }
82
83 // Successfully initialized
84 _initialized = true;
85 }
86
87 bool ZVirtualMemoryManager::is_initialized() const {
88 return _initialized;
89 }
90
91 ZVirtualMemory ZVirtualMemoryManager::alloc(size_t size, bool alloc_from_front) {
92 uintptr_t start;
93
94 if (alloc_from_front || size <= ZPageSizeSmall) {
95 // Small page
96 start = _manager.alloc_from_front(size);
97 } else {
98 // Medium/Large page
99 start = _manager.alloc_from_back(size);
100 }
101
102 return ZVirtualMemory(start, size);
103 }
104
|