Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(509)

Side by Side Diff: third_party/WebKit/Source/wtf/allocator/PageAllocator.h

Issue 2518253002: Move Partition Allocator into Chromium base. (Closed)
Patch Set: Created 4 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
1 /*
2 * Copyright (C) 2013 Google Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met:
7 *
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above
11 * copyright notice, this list of conditions and the following disclaimer
12 * in the documentation and/or other materials provided with the
13 * distribution.
14 * * Neither the name of Google Inc. nor the names of its
15 * contributors may be used to endorse or promote products derived from
16 * this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 #ifndef WTF_PageAllocator_h
32 #define WTF_PageAllocator_h
33
34 #include "wtf/Assertions.h"
35 #include "wtf/CPU.h"
36 #include "wtf/WTFExport.h"
37 #include <cstddef>
38 #include <stdint.h>
39
40 namespace WTF {
41
42 #if OS(WIN)
43 static const size_t kPageAllocationGranularityShift = 16; // 64KB
44 #else
45 static const size_t kPageAllocationGranularityShift = 12; // 4KB
46 #endif
47 static const size_t kPageAllocationGranularity =
48 1 << kPageAllocationGranularityShift;
49 static const size_t kPageAllocationGranularityOffsetMask =
50 kPageAllocationGranularity - 1;
51 static const size_t kPageAllocationGranularityBaseMask =
52 ~kPageAllocationGranularityOffsetMask;
53
54 // All Blink-supported systems have 4096 sized system pages and can handle
55 // permissions and commit / decommit at this granularity.
56 static const size_t kSystemPageSize = 4096;
57 static const size_t kSystemPageOffsetMask = kSystemPageSize - 1;
58 static const size_t kSystemPageBaseMask = ~kSystemPageOffsetMask;
59
60 enum PageAccessibilityConfiguration {
61 PageAccessible,
62 PageInaccessible,
63 };
64
65 // Allocate one or more pages.
66 // The requested address is just a hint; the actual address returned may
67 // differ. The returned address will be aligned at least to align bytes.
68 // len is in bytes, and must be a multiple of kPageAllocationGranularity.
69 // align is in bytes, and must be a power-of-two multiple of
70 // kPageAllocationGranularity.
71 // If addr is null, then a suitable and randomized address will be chosen
72 // automatically.
73 // PageAccessibilityConfiguration controls the permission of the
74 // allocated pages.
75 // This call will return null if the allocation cannot be satisfied.
76 WTF_EXPORT void* allocPages(void* addr,
77 size_t len,
78 size_t align,
79 PageAccessibilityConfiguration);
80
81 // Free one or more pages.
82 // addr and len must match a previous call to allocPages().
83 WTF_EXPORT void freePages(void* addr, size_t len);
84
85 // Mark one or more system pages as being inaccessible.
86 // Subsequently accessing any address in the range will fault, and the
87 // addresses will not be re-used by future allocations.
88 // len must be a multiple of kSystemPageSize bytes.
89 WTF_EXPORT void setSystemPagesInaccessible(void* addr, size_t len);
90
91 // Mark one or more system pages as being accessible.
92 // The pages will be readable and writeable.
93 // len must be a multiple of kSystemPageSize bytes.
94 // The result bool value indicates whether the permission
95 // change succeeded or not. You must check the result
96 // (in most cases you need to RELEASE_ASSERT that it is
97 // true).
98 WTF_EXPORT WARN_UNUSED_RETURN bool setSystemPagesAccessible(void* addr,
99 size_t len);
100
101 // Decommit one or more system pages. Decommitted means that the physical memory
102 // is released to the system, but the virtual address space remains reserved.
103 // System pages are re-committed by calling recommitSystemPages(). Touching
104 // a decommitted page _may_ fault.
105 // Clients should not make any assumptions about the contents of decommitted
106 // system pages, before or after they write to the page. The only guarantee
107 // provided is that the contents of the system page will be deterministic again
108 // after recommitting and writing to it. In particlar note that system pages are
109 // not guaranteed to be zero-filled upon re-commit. len must be a multiple of
110 // kSystemPageSize bytes.
111 WTF_EXPORT void decommitSystemPages(void* addr, size_t len);
112
113 // Recommit one or more system pages. Decommitted system pages must be
114 // recommitted before they are read are written again.
115 // Note that this operation may be a no-op on some platforms.
116 // len must be a multiple of kSystemPageSize bytes.
117 WTF_EXPORT void recommitSystemPages(void* addr, size_t len);
118
119 // Discard one or more system pages. Discarding is a hint to the system that
120 // the page is no longer required. The hint may:
121 // - Do nothing.
122 // - Discard the page immediately, freeing up physical pages.
123 // - Discard the page at some time in the future in response to memory pressure.
124 // Only committed pages should be discarded. Discarding a page does not
125 // decommit it, and it is valid to discard an already-discarded page.
126 // A read or write to a discarded page will not fault.
127 // Reading from a discarded page may return the original page content, or a
128 // page full of zeroes.
129 // Writing to a discarded page is the only guaranteed way to tell the system
130 // that the page is required again. Once written to, the content of the page is
131 // guaranteed stable once more. After being written to, the page content may be
132 // based on the original page content, or a page of zeroes.
133 // len must be a multiple of kSystemPageSize bytes.
134 WTF_EXPORT void discardSystemPages(void* addr, size_t len);
135
136 WTF_EXPORT ALWAYS_INLINE uintptr_t roundUpToSystemPage(uintptr_t address) {
137 return (address + kSystemPageOffsetMask) & kSystemPageBaseMask;
138 }
139
140 WTF_EXPORT ALWAYS_INLINE uintptr_t roundDownToSystemPage(uintptr_t address) {
141 return address & kSystemPageBaseMask;
142 }
143
144 // Only allowed inside WTF for investigating WTF::initializeWithoutV8 crashes.
145 // Guess, the function fails because of mmap (or VirtualAlloc) failure.
146 // The following function returns errno (or GetLastError code) when mmap
147 // (or VirtualAlloc) fails.
148 uint32_t getAllocPageErrorCode();
149
150 } // namespace WTF
151
152 #endif // WTF_PageAllocator_h
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698