|
132
|
1 /**
|
|
|
2 * This module contains allocation functions for the garbage collector.
|
|
|
3 *
|
|
|
4 * Copyright: Copyright (C) 2005-2006 Digital Mars, www.digitalmars.com.
|
|
|
5 * All rights reserved.
|
|
|
6 * License:
|
|
|
7 * This software is provided 'as-is', without any express or implied
|
|
|
8 * warranty. In no event will the authors be held liable for any damages
|
|
|
9 * arising from the use of this software.
|
|
|
10 *
|
|
|
11 * Permission is granted to anyone to use this software for any purpose,
|
|
|
12 * including commercial applications, and to alter it and redistribute it
|
|
|
13 * freely, in both source and binary form, subject to the following
|
|
|
14 * restrictions:
|
|
|
15 *
|
|
|
16 * o The origin of this software must not be misrepresented; you must not
|
|
|
17 * claim that you wrote the original software. If you use this software
|
|
|
18 * in a product, an acknowledgment in the product documentation would be
|
|
|
19 * appreciated but is not required.
|
|
|
20 * o Altered source versions must be plainly marked as such, and must not
|
|
|
21 * be misrepresented as being the original software.
|
|
|
22 * o This notice may not be removed or altered from any source
|
|
|
23 * distribution.
|
|
|
24 * Authors: Walter Bright, David Friedman, Sean Kelly
|
|
|
25 */
|
|
|
26
|
|
|
27
|
|
|
28 version (Win32)
|
|
|
29 {
|
|
|
30 private import tango.sys.win32.UserGdi;
|
|
|
31
|
|
|
32 alias int pthread_t;
|
|
|
33
|
|
|
34 pthread_t pthread_self()
|
|
|
35 {
|
|
|
36 return cast(pthread_t) GetCurrentThreadId();
|
|
|
37 }
|
|
|
38
|
|
|
39 //version = GC_Use_Alloc_Win32;
|
|
|
40 }
|
|
|
41 else version (Posix)
|
|
|
42 {
|
|
|
43 private import tango.stdc.posix.sys.mman;
|
|
|
44 private import tango.stdc.stdlib;
|
|
|
45
|
|
|
46 //version = GC_Use_Alloc_MMap;
|
|
|
47 }
|
|
|
48 else
|
|
|
49 {
|
|
|
50 private import tango.stdc.stdlib;
|
|
|
51
|
|
|
52 //version = GC_Use_Alloc_Malloc;
|
|
|
53 }
|
|
|
54
|
|
|
55 /+
|
|
|
56 static if(is(typeof(VirtualAlloc)))
|
|
|
57 version = GC_Use_Alloc_Win32;
|
|
|
58 else static if (is(typeof(mmap)))
|
|
|
59 version = GC_Use_Alloc_MMap;
|
|
|
60 else static if (is(typeof(valloc)))
|
|
|
61 version = GC_Use_Alloc_Valloc;
|
|
|
62 else static if (is(typeof(malloc)))
|
|
|
63 version = GC_Use_Alloc_Malloc;
|
|
|
64 else static assert(false, "No supported allocation methods available.");
|
|
|
65 +/
|
|
|
66
|
|
|
67 static if (is(typeof(VirtualAlloc))) // version (GC_Use_Alloc_Win32)
|
|
|
68 {
|
|
|
69 /**
|
|
|
70 * Map memory.
|
|
|
71 */
|
|
|
72 void *os_mem_map(size_t nbytes)
|
|
|
73 {
|
|
|
74 return VirtualAlloc(null, nbytes, MEM_RESERVE, PAGE_READWRITE);
|
|
|
75 }
|
|
|
76
|
|
|
77
|
|
|
78 /**
|
|
|
79 * Commit memory.
|
|
|
80 * Returns:
|
|
|
81 * 0 success
|
|
|
82 * !=0 failure
|
|
|
83 */
|
|
|
84 int os_mem_commit(void *base, size_t offset, size_t nbytes)
|
|
|
85 { void *p;
|
|
|
86
|
|
|
87 p = VirtualAlloc(base + offset, nbytes, MEM_COMMIT, PAGE_READWRITE);
|
|
|
88 return cast(int)(p == null);
|
|
|
89 }
|
|
|
90
|
|
|
91
|
|
|
92 /**
|
|
|
93 * Decommit memory.
|
|
|
94 * Returns:
|
|
|
95 * 0 success
|
|
|
96 * !=0 failure
|
|
|
97 */
|
|
|
98 int os_mem_decommit(void *base, size_t offset, size_t nbytes)
|
|
|
99 {
|
|
|
100 return cast(int)(VirtualFree(base + offset, nbytes, MEM_DECOMMIT) == 0);
|
|
|
101 }
|
|
|
102
|
|
|
103
|
|
|
104 /**
|
|
|
105 * Unmap memory allocated with os_mem_map().
|
|
|
106 * Memory must have already been decommitted.
|
|
|
107 * Returns:
|
|
|
108 * 0 success
|
|
|
109 * !=0 failure
|
|
|
110 */
|
|
|
111 int os_mem_unmap(void *base, size_t nbytes)
|
|
|
112 {
|
|
|
113 return cast(int)(VirtualFree(base, 0, MEM_RELEASE) == 0);
|
|
|
114 }
|
|
|
115 }
|
|
|
116 else static if (is(typeof(mmap))) // else version (GC_Use_Alloc_MMap)
|
|
|
117 {
|
|
|
118 void *os_mem_map(size_t nbytes)
|
|
|
119 { void *p;
|
|
|
120
|
|
|
121 p = mmap(null, nbytes, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
|
|
|
122 return (p == MAP_FAILED) ? null : p;
|
|
|
123 }
|
|
|
124
|
|
|
125
|
|
|
126 int os_mem_commit(void *base, size_t offset, size_t nbytes)
|
|
|
127 {
|
|
|
128 return 0;
|
|
|
129 }
|
|
|
130
|
|
|
131
|
|
|
132 int os_mem_decommit(void *base, size_t offset, size_t nbytes)
|
|
|
133 {
|
|
|
134 return 0;
|
|
|
135 }
|
|
|
136
|
|
|
137
|
|
|
138 int os_mem_unmap(void *base, size_t nbytes)
|
|
|
139 {
|
|
|
140 return munmap(base, nbytes);
|
|
|
141 }
|
|
|
142 }
|
|
|
143 else static if (is(typeof(valloc))) // else version (GC_Use_Alloc_Valloc)
|
|
|
144 {
|
|
|
145 void *os_mem_map(size_t nbytes)
|
|
|
146 {
|
|
|
147 return valloc(nbytes);
|
|
|
148 }
|
|
|
149
|
|
|
150
|
|
|
151 int os_mem_commit(void *base, size_t offset, size_t nbytes)
|
|
|
152 {
|
|
|
153 return 0;
|
|
|
154 }
|
|
|
155
|
|
|
156
|
|
|
157 int os_mem_decommit(void *base, size_t offset, size_t nbytes)
|
|
|
158 {
|
|
|
159 return 0;
|
|
|
160 }
|
|
|
161
|
|
|
162
|
|
|
163 int os_mem_unmap(void *base, size_t nbytes)
|
|
|
164 {
|
|
|
165 free(base);
|
|
|
166 return 0;
|
|
|
167 }
|
|
|
168 }
|
|
|
169 else static if (is(typeof(malloc))) // else version (GC_Use_Alloc_Malloc)
|
|
|
170 {
|
|
|
171 // NOTE: This assumes malloc granularity is at least (void*).sizeof. If
|
|
|
172 // (req_size + PAGESIZE) is allocated, and the pointer is rounded up
|
|
|
173 // to PAGESIZE alignment, there will be space for a void* at the end
|
|
|
174 // after PAGESIZE bytes used by the GC.
|
|
|
175
|
|
|
176
|
|
|
177 private import gcx; // for PAGESIZE
|
|
|
178
|
|
|
179
|
|
|
180 const size_t PAGE_MASK = PAGESIZE - 1;
|
|
|
181
|
|
|
182
|
|
|
183 void *os_mem_map(size_t nbytes)
|
|
|
184 { byte *p, q;
|
|
|
185 p = cast(byte *) malloc(nbytes + PAGESIZE);
|
|
|
186 q = p + ((PAGESIZE - ((cast(size_t) p & PAGE_MASK))) & PAGE_MASK);
|
|
|
187 * cast(void**)(q + nbytes) = p;
|
|
|
188 return q;
|
|
|
189 }
|
|
|
190
|
|
|
191
|
|
|
192 int os_mem_commit(void *base, size_t offset, size_t nbytes)
|
|
|
193 {
|
|
|
194 return 0;
|
|
|
195 }
|
|
|
196
|
|
|
197
|
|
|
198 int os_mem_decommit(void *base, size_t offset, size_t nbytes)
|
|
|
199 {
|
|
|
200 return 0;
|
|
|
201 }
|
|
|
202
|
|
|
203
|
|
|
204 int os_mem_unmap(void *base, size_t nbytes)
|
|
|
205 {
|
|
|
206 free( *cast(void**)( cast(byte*) base + nbytes ) );
|
|
|
207 return 0;
|
|
|
208 }
|
|
|
209 }
|
|
|
210 else
|
|
|
211 {
|
|
|
212 static assert(false, "No supported allocation methods available.");
|
|
|
213 } |
