1 /*
2 * Copyright (c) 2015, 2017, 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 #include "precompiled.hpp"
25 #include "gc/z/zList.inline.hpp"
26 #include "gc/z/zNUMA.hpp"
27 #include "gc/z/zPage.inline.hpp"
28 #include "gc/z/zPageCache.hpp"
29 #include "gc/z/zStat.hpp"
30 #include "logging/log.hpp"
31
32 static const ZStatCounter ZCounterPageCacheHitL1("Memory", "Page Cache Hit L1", ZStatUnitOpsPerSecond);
33 static const ZStatCounter ZCounterPageCacheHitL2("Memory", "Page Cache Hit L2", ZStatUnitOpsPerSecond);
34 static const ZStatCounter ZCounterPageCacheMiss("Memory", "Page Cache Miss", ZStatUnitOpsPerSecond);
35 static const ZStatCounter ZCounterPageCacheFlush("Memory", "Page Cache Flush", ZStatUnitBytesPerSecond);
36
37 ZPageCache::ZPageCache() :
38 _available(0),
39 _small(),
40 _medium(),
41 _large() {}
42
43 ZPage* ZPageCache::alloc_small_page() {
44 const uint32_t numa_id = ZNUMA::id();
45 const uint32_t numa_count = ZNUMA::count();
46
47 // Try NUMA local page cache
48 ZPage* const l1_page = _small.get(numa_id).remove_first();
49 if (l1_page != NULL) {
50 ZStatInc(ZCounterPageCacheHitL1);
51 return l1_page;
52 }
53
54 // Try NUMA remote page cache(s)
55 uint32_t remote_numa_id = numa_id + 1;
56 const uint32_t remote_numa_count = numa_count - 1;
57 for (uint32_t i = 0; i < remote_numa_count; i++) {
58 if (remote_numa_id == numa_count) {
59 remote_numa_id = 0;
60 }
61
62 ZPage* const l2_page = _small.get(remote_numa_id).remove_first();
63 if (l2_page != NULL) {
64 ZStatInc(ZCounterPageCacheHitL2);
65 return l2_page;
66 }
67
68 remote_numa_id++;
69 }
70
71 ZStatInc(ZCounterPageCacheMiss);
72 return NULL;
73 }
74
75 ZPage* ZPageCache::alloc_medium_page() {
76 ZPage* const l1_page = _medium.remove_first();
77 if (l1_page != NULL) {
78 ZStatInc(ZCounterPageCacheHitL1);
79 return l1_page;
80 }
81
82 ZStatInc(ZCounterPageCacheMiss);
83 return NULL;
84 }
85
86 ZPage* ZPageCache::alloc_large_page(size_t size) {
87 // Find a page with the right size
88 ZListIterator<ZPage> iter(&_large);
89 for (ZPage* l1_page; iter.next(&l1_page);) {
90 if (l1_page->size() == size) {
91 // Page found
92 _large.remove(l1_page);
93 ZStatInc(ZCounterPageCacheHitL1);
94 return l1_page;
95 }
96 }
97
98 ZStatInc(ZCounterPageCacheMiss);
99 return NULL;
100 }
101
102 ZPage* ZPageCache::alloc_page(uint8_t type, size_t size) {
103 ZPage* page;
104
105 if (type == ZPageTypeSmall) {
106 page = alloc_small_page();
107 } else if (type == ZPageTypeMedium) {
108 page = alloc_medium_page();
109 } else {
110 page = alloc_large_page(size);
111 }
112
113 if (page != NULL) {
114 _available -= page->size();
115 }
116
117 return page;
118 }
119
120 void ZPageCache::free_page(ZPage* page) {
121 assert(!page->is_active(), "Invalid page state");
122 assert(!page->is_pinned(), "Invalid page state");
123 assert(!page->is_detached(), "Invalid page state");
124
125 const uint8_t type = page->type();
126 if (type == ZPageTypeSmall) {
127 _small.get(page->numa_id()).insert_first(page);
128 } else if (type == ZPageTypeMedium) {
129 _medium.insert_first(page);
130 } else {
131 _large.insert_first(page);
132 }
133
134 _available += page->size();
135 }
136
137 void ZPageCache::flush_list(ZList<ZPage>* from, size_t requested, ZList<ZPage>* to, size_t* flushed) {
138 while (*flushed < requested) {
139 // Flush least recently used
140 ZPage* const page = from->remove_last();
141 if (page == NULL) {
142 break;
143 }
144
145 *flushed += page->size();
146 to->insert_last(page);
147 }
148 }
149
150 void ZPageCache::flush_per_numa_lists(ZPerNUMA<ZList<ZPage> >* from, size_t requested, ZList<ZPage>* to, size_t* flushed) {
151 const uint32_t numa_count = ZNUMA::count();
152 uint32_t numa_empty = 0;
153 uint32_t numa_next = 0;
154
155 // Flush lists round-robin
156 while (*flushed < requested) {
157 ZPage* const page = from->get(numa_next).remove_last();
158
159 if (++numa_next == numa_count) {
160 numa_next = 0;
161 }
162
163 if (page == NULL) {
164 // List is empty
165 if (++numa_empty == numa_count) {
166 // All lists are empty
167 break;
168 }
169
170 // Try next list
171 continue;
172 }
173
174 // Flush page
175 numa_empty = 0;
176 *flushed += page->size();
177 to->insert_last(page);
178 }
179 }
180
181 void ZPageCache::flush(ZList<ZPage>* to, size_t requested) {
182 size_t flushed = 0;
183
184 // Prefer flushing large, then medium and last small pages
185 flush_list(&_large, requested, to, &flushed);
186 flush_list(&_medium, requested, to, &flushed);
187 flush_per_numa_lists(&_small, requested, to, &flushed);
188
189 ZStatInc(ZCounterPageCacheFlush, flushed);
190
191 log_info(gc, heap)("Page Cache Flushed: "
192 SIZE_FORMAT "M requested, "
193 SIZE_FORMAT "M(" SIZE_FORMAT "M->" SIZE_FORMAT "M) flushed",
194 requested / M, flushed / M , _available / M, (_available - flushed) / M);
195
196 _available -= flushed;
197 }