|
145
|
1 /**
|
|
|
2 * Contains OS-level routines needed by the garbage collector.
|
|
|
3 *
|
|
|
4 * Copyright: Copyright Digital Mars 2005 - 2013.
|
|
|
5 * License: $(WEB www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
|
|
|
6 * Authors: Walter Bright, David Friedman, Sean Kelly, Leandro Lucarella
|
|
|
7 */
|
|
|
8
|
|
|
9 /* Copyright Digital Mars 2005 - 2013.
|
|
|
10 * Distributed under the Boost Software License, Version 1.0.
|
|
|
11 * (See accompanying file LICENSE or copy at
|
|
|
12 * http://www.boost.org/LICENSE_1_0.txt)
|
|
|
13 */
|
|
|
14 module gc.os;
|
|
|
15
|
|
|
16
|
|
|
17 version (Windows)
|
|
|
18 {
|
|
|
19 import core.sys.windows.winbase : GetCurrentThreadId, VirtualAlloc, VirtualFree;
|
|
|
20 import core.sys.windows.winnt : MEM_COMMIT, MEM_RELEASE, MEM_RESERVE, PAGE_READWRITE;
|
|
|
21
|
|
|
22 alias int pthread_t;
|
|
|
23
|
|
|
24 pthread_t pthread_self() nothrow
|
|
|
25 {
|
|
|
26 return cast(pthread_t) GetCurrentThreadId();
|
|
|
27 }
|
|
|
28
|
|
|
29 //version = GC_Use_Alloc_Win32;
|
|
|
30 }
|
|
|
31 else version (Posix)
|
|
|
32 {
|
|
|
33 version (OSX)
|
|
|
34 version = Darwin;
|
|
|
35 else version (iOS)
|
|
|
36 version = Darwin;
|
|
|
37 else version (TVOS)
|
|
|
38 version = Darwin;
|
|
|
39 else version (WatchOS)
|
|
|
40 version = Darwin;
|
|
|
41
|
|
|
42 import core.sys.posix.sys.mman;
|
|
|
43 version (FreeBSD) import core.sys.freebsd.sys.mman : MAP_ANON;
|
|
|
44 version (DragonFlyBSD) import core.sys.dragonflybsd.sys.mman : MAP_ANON;
|
|
|
45 version (NetBSD) import core.sys.netbsd.sys.mman : MAP_ANON;
|
|
|
46 version (OpenBSD) import core.sys.openbsd.sys.mman : MAP_ANON;
|
|
|
47 version (CRuntime_Glibc) import core.sys.linux.sys.mman : MAP_ANON;
|
|
|
48 version (Darwin) import core.sys.darwin.sys.mman : MAP_ANON;
|
|
|
49 version (CRuntime_UClibc) import core.sys.linux.sys.mman : MAP_ANON;
|
|
|
50 import core.stdc.stdlib;
|
|
|
51
|
|
|
52 //version = GC_Use_Alloc_MMap;
|
|
|
53 }
|
|
|
54 else
|
|
|
55 {
|
|
|
56 import core.stdc.stdlib;
|
|
|
57
|
|
|
58 //version = GC_Use_Alloc_Malloc;
|
|
|
59 }
|
|
|
60
|
|
|
61 /+
|
|
|
62 static if (is(typeof(VirtualAlloc)))
|
|
|
63 version = GC_Use_Alloc_Win32;
|
|
|
64 else static if (is(typeof(mmap)))
|
|
|
65 version = GC_Use_Alloc_MMap;
|
|
|
66 else static if (is(typeof(valloc)))
|
|
|
67 version = GC_Use_Alloc_Valloc;
|
|
|
68 else static if (is(typeof(malloc)))
|
|
|
69 version = GC_Use_Alloc_Malloc;
|
|
|
70 else static assert(false, "No supported allocation methods available.");
|
|
|
71 +/
|
|
|
72
|
|
|
73 static if (is(typeof(VirtualAlloc))) // version (GC_Use_Alloc_Win32)
|
|
|
74 {
|
|
|
75 /**
|
|
|
76 * Map memory.
|
|
|
77 */
|
|
|
78 void *os_mem_map(size_t nbytes) nothrow
|
|
|
79 {
|
|
|
80 return VirtualAlloc(null, nbytes, MEM_RESERVE | MEM_COMMIT,
|
|
|
81 PAGE_READWRITE);
|
|
|
82 }
|
|
|
83
|
|
|
84
|
|
|
85 /**
|
|
|
86 * Unmap memory allocated with os_mem_map().
|
|
|
87 * Returns:
|
|
|
88 * 0 success
|
|
|
89 * !=0 failure
|
|
|
90 */
|
|
|
91 int os_mem_unmap(void *base, size_t nbytes) nothrow
|
|
|
92 {
|
|
|
93 return cast(int)(VirtualFree(base, 0, MEM_RELEASE) == 0);
|
|
|
94 }
|
|
|
95 }
|
|
|
96 else static if (is(typeof(mmap))) // else version (GC_Use_Alloc_MMap)
|
|
|
97 {
|
|
|
98 void *os_mem_map(size_t nbytes) nothrow
|
|
|
99 { void *p;
|
|
|
100
|
|
|
101 p = mmap(null, nbytes, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
|
|
|
102 return (p == MAP_FAILED) ? null : p;
|
|
|
103 }
|
|
|
104
|
|
|
105
|
|
|
106 int os_mem_unmap(void *base, size_t nbytes) nothrow
|
|
|
107 {
|
|
|
108 return munmap(base, nbytes);
|
|
|
109 }
|
|
|
110 }
|
|
|
111 else static if (is(typeof(valloc))) // else version (GC_Use_Alloc_Valloc)
|
|
|
112 {
|
|
|
113 void *os_mem_map(size_t nbytes) nothrow
|
|
|
114 {
|
|
|
115 return valloc(nbytes);
|
|
|
116 }
|
|
|
117
|
|
|
118
|
|
|
119 int os_mem_unmap(void *base, size_t nbytes) nothrow
|
|
|
120 {
|
|
|
121 free(base);
|
|
|
122 return 0;
|
|
|
123 }
|
|
|
124 }
|
|
|
125 else static if (is(typeof(malloc))) // else version (GC_Use_Alloc_Malloc)
|
|
|
126 {
|
|
|
127 // NOTE: This assumes malloc granularity is at least (void*).sizeof. If
|
|
|
128 // (req_size + PAGESIZE) is allocated, and the pointer is rounded up
|
|
|
129 // to PAGESIZE alignment, there will be space for a void* at the end
|
|
|
130 // after PAGESIZE bytes used by the GC.
|
|
|
131
|
|
|
132
|
|
|
133 import gc.gc;
|
|
|
134
|
|
|
135
|
|
|
136 const size_t PAGE_MASK = PAGESIZE - 1;
|
|
|
137
|
|
|
138
|
|
|
139 void *os_mem_map(size_t nbytes) nothrow
|
|
|
140 { byte *p, q;
|
|
|
141 p = cast(byte *) malloc(nbytes + PAGESIZE);
|
|
|
142 q = p + ((PAGESIZE - ((cast(size_t) p & PAGE_MASK))) & PAGE_MASK);
|
|
|
143 * cast(void**)(q + nbytes) = p;
|
|
|
144 return q;
|
|
|
145 }
|
|
|
146
|
|
|
147
|
|
|
148 int os_mem_unmap(void *base, size_t nbytes) nothrow
|
|
|
149 {
|
|
|
150 free( *cast(void**)( cast(byte*) base + nbytes ) );
|
|
|
151 return 0;
|
|
|
152 }
|
|
|
153 }
|
|
|
154 else
|
|
|
155 {
|
|
|
156 static assert(false, "No supported allocation methods available.");
|
|
|
157 }
|
|
|
158
|
|
|
159 /**
|
|
|
160 Check for any kind of memory pressure.
|
|
|
161
|
|
|
162 Params:
|
|
|
163 mapped = the amount of memory mapped by the GC in bytes
|
|
|
164 Returns:
|
|
|
165 true if memory is scarce
|
|
|
166 */
|
|
|
167 // TOOD: get virtual mem sizes and current usage from OS
|
|
|
168 // TODO: compare current RSS and avail. physical memory
|
|
|
169 version (Windows)
|
|
|
170 {
|
|
|
171 bool isLowOnMem(size_t mapped) nothrow @nogc
|
|
|
172 {
|
|
|
173 version (D_LP64)
|
|
|
174 return false;
|
|
|
175 else
|
|
|
176 {
|
|
|
177 import core.sys.windows.winbase : GlobalMemoryStatus, MEMORYSTATUS;
|
|
|
178 MEMORYSTATUS stat;
|
|
|
179 GlobalMemoryStatus(&stat);
|
|
|
180 // Less than 5 % of virtual address space available
|
|
|
181 return stat.dwAvailVirtual < stat.dwTotalVirtual / 20;
|
|
|
182 }
|
|
|
183 }
|
|
|
184 }
|
|
|
185 else version (Darwin)
|
|
|
186 {
|
|
|
187 bool isLowOnMem(size_t mapped) nothrow @nogc
|
|
|
188 {
|
|
|
189 enum GB = 2 ^^ 30;
|
|
|
190 version (D_LP64)
|
|
|
191 return false;
|
|
|
192 else
|
|
|
193 {
|
|
|
194 // 80 % of available 4GB is used for GC (excluding malloc and mmap)
|
|
|
195 enum size_t limit = 4UL * GB * 8 / 10;
|
|
|
196 return mapped > limit;
|
|
|
197 }
|
|
|
198 }
|
|
|
199 }
|
|
|
200 else
|
|
|
201 {
|
|
|
202 bool isLowOnMem(size_t mapped) nothrow @nogc
|
|
|
203 {
|
|
|
204 enum GB = 2 ^^ 30;
|
|
|
205 version (D_LP64)
|
|
|
206 return false;
|
|
|
207 else
|
|
|
208 {
|
|
|
209 // be conservative and assume 3GB
|
|
|
210 enum size_t limit = 3UL * GB * 8 / 10;
|
|
|
211 return mapped > limit;
|
|
|
212 }
|
|
|
213 }
|
|
|
214 }
|
