Add logic for TCMalloc to release memory to the system
[WebKit-https.git] / JavaScriptCore / wtf / TCSystemAlloc.cpp
1 // Copyright (c) 2005, 2007, Google Inc.
2 // 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 // Author: Sanjay Ghemawat
32
33 #include "config.h"
34 #if HAVE(STDINT_H)
35 #include <stdint.h>
36 #elif HAVE(INTTYPES_H)
37 #include <inttypes.h>
38 #else
39 #include <sys/types.h>
40 #endif
41 #if PLATFORM(WIN_OS)
42 #include "windows.h"
43 #else
44 #include <errno.h>
45 #include <unistd.h>
46 #include <sys/mman.h>
47 #endif
48 #include <fcntl.h>
49 #include "Assertions.h"
50 #include "TCSystemAlloc.h"
51 #include "TCSpinLock.h"
52
53 #ifndef MAP_ANONYMOUS
54 #define MAP_ANONYMOUS MAP_ANON
55 #endif
56
57 // Structure for discovering alignment
58 union MemoryAligner {
59   void*  p;
60   double d;
61   size_t s;
62 };
63
64 static SpinLock spinlock = SPINLOCK_INITIALIZER;
65
66 // Page size is initialized on demand
67 static size_t pagesize = 0;
68
69 // Configuration parameters.
70 //
71 // if use_devmem is true, either use_sbrk or use_mmap must also be true.
72 // For 2.2 kernels, it looks like the sbrk address space (500MBish) and
73 // the mmap address space (1300MBish) are disjoint, so we need both allocators
74 // to get as much virtual memory as possible.
75 #ifndef WTF_CHANGES
76 static bool use_devmem = false;
77 #endif
78
79 #if HAVE(SBRK)
80 static bool use_sbrk = false;
81 #endif
82
83 #if HAVE(MMAP)
84 static bool use_mmap = true;
85 #endif 
86
87 #if HAVE(VIRTUALALLOC)
88 static bool use_VirtualAlloc = true;
89 #endif
90
91 // Flags to keep us from retrying allocators that failed.
92 static bool devmem_failure = false;
93 static bool sbrk_failure = false;
94 static bool mmap_failure = false;
95 static bool VirtualAlloc_failure = false;
96
97 #ifndef WTF_CHANGES
98 DEFINE_int32(malloc_devmem_start, 0,
99              "Physical memory starting location in MB for /dev/mem allocation."
100              "  Setting this to 0 disables /dev/mem allocation");
101 DEFINE_int32(malloc_devmem_limit, 0,
102              "Physical memory limit location in MB for /dev/mem allocation."
103              "  Setting this to 0 means no limit.");
104 #else
105 static const int32_t FLAGS_malloc_devmem_start = 0;
106 static const int32_t FLAGS_malloc_devmem_limit = 0;
107 #endif
108
109 #if HAVE(SBRK)
110
111 static void* TrySbrk(size_t size, size_t *actual_size, size_t alignment) {
112   size = ((size + alignment - 1) / alignment) * alignment;
113   
114   // could theoretically return the "extra" bytes here, but this
115   // is simple and correct.
116   if (actual_size) 
117     *actual_size = size;
118     
119   void* result = sbrk(size);
120   if (result == reinterpret_cast<void*>(-1)) {
121     sbrk_failure = true;
122     return NULL;
123   }
124
125   // Is it aligned?
126   uintptr_t ptr = reinterpret_cast<uintptr_t>(result);
127   if ((ptr & (alignment-1)) == 0)  return result;
128
129   // Try to get more memory for alignment
130   size_t extra = alignment - (ptr & (alignment-1));
131   void* r2 = sbrk(extra);
132   if (reinterpret_cast<uintptr_t>(r2) == (ptr + size)) {
133     // Contiguous with previous result
134     return reinterpret_cast<void*>(ptr + extra);
135   }
136
137   // Give up and ask for "size + alignment - 1" bytes so
138   // that we can find an aligned region within it.
139   result = sbrk(size + alignment - 1);
140   if (result == reinterpret_cast<void*>(-1)) {
141     sbrk_failure = true;
142     return NULL;
143   }
144   ptr = reinterpret_cast<uintptr_t>(result);
145   if ((ptr & (alignment-1)) != 0) {
146     ptr += alignment - (ptr & (alignment-1));
147   }
148   return reinterpret_cast<void*>(ptr);
149 }
150
151 #endif /* HAVE(SBRK) */
152
153 #if HAVE(MMAP)
154
155 static void* TryMmap(size_t size, size_t *actual_size, size_t alignment) {
156   // Enforce page alignment
157   if (pagesize == 0) pagesize = getpagesize();
158   if (alignment < pagesize) alignment = pagesize;
159   size = ((size + alignment - 1) / alignment) * alignment;
160   
161   // could theoretically return the "extra" bytes here, but this
162   // is simple and correct.
163   if (actual_size) 
164     *actual_size = size;
165     
166   // Ask for extra memory if alignment > pagesize
167   size_t extra = 0;
168   if (alignment > pagesize) {
169     extra = alignment - pagesize;
170   }
171   void* result = mmap(NULL, size + extra,
172                       PROT_READ|PROT_WRITE,
173                       MAP_PRIVATE|MAP_ANONYMOUS,
174                       -1, 0);
175   if (result == reinterpret_cast<void*>(MAP_FAILED)) {
176     mmap_failure = true;
177     return NULL;
178   }
179
180   // Adjust the return memory so it is aligned
181   uintptr_t ptr = reinterpret_cast<uintptr_t>(result);
182   size_t adjust = 0;
183   if ((ptr & (alignment - 1)) != 0) {
184     adjust = alignment - (ptr & (alignment - 1));
185   }
186
187   // Return the unused memory to the system
188   if (adjust > 0) {
189     munmap(reinterpret_cast<void*>(ptr), adjust);
190   }
191   if (adjust < extra) {
192     munmap(reinterpret_cast<void*>(ptr + adjust + size), extra - adjust);
193   }
194
195   ptr += adjust;
196   return reinterpret_cast<void*>(ptr);
197 }
198
199 #endif /* HAVE(MMAP) */
200
201 #if HAVE(VIRTUALALLOC)
202
203 static void* TryVirtualAlloc(size_t size, size_t *actual_size, size_t alignment) {
204   // Enforce page alignment
205   if (pagesize == 0) {
206     SYSTEM_INFO system_info;
207     GetSystemInfo(&system_info);
208     pagesize = system_info.dwPageSize;
209   }
210
211   if (alignment < pagesize) alignment = pagesize;
212   size = ((size + alignment - 1) / alignment) * alignment;
213
214   // could theoretically return the "extra" bytes here, but this
215   // is simple and correct.
216   if (actual_size) 
217     *actual_size = size;
218     
219   // Ask for extra memory if alignment > pagesize
220   size_t extra = 0;
221   if (alignment > pagesize) {
222     extra = alignment - pagesize;
223   }
224   void* result = VirtualAlloc(NULL, size + extra,
225                               MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN, 
226                               PAGE_READWRITE);
227
228   if (result == NULL) {
229     VirtualAlloc_failure = true;
230     return NULL;
231   }
232
233   // Adjust the return memory so it is aligned
234   uintptr_t ptr = reinterpret_cast<uintptr_t>(result);
235   size_t adjust = 0;
236   if ((ptr & (alignment - 1)) != 0) {
237     adjust = alignment - (ptr & (alignment - 1));
238   }
239
240   // Return the unused memory to the system - we'd like to release but the best we can do
241   // is decommit, since Windows only lets you free the whole allocation.
242   if (adjust > 0) {
243     VirtualFree(reinterpret_cast<void*>(ptr), adjust, MEM_DECOMMIT);
244   }
245   if (adjust < extra) {
246     VirtualFree(reinterpret_cast<void*>(ptr + adjust + size), extra-adjust, MEM_DECOMMIT);
247   }
248
249   ptr += adjust;
250   return reinterpret_cast<void*>(ptr);
251 }
252
253 #endif /* HAVE(MMAP) */
254
255 #ifndef WTF_CHANGES
256 static void* TryDevMem(size_t size, size_t *actual_size, size_t alignment) {
257   static bool initialized = false;
258   static off_t physmem_base;  // next physical memory address to allocate
259   static off_t physmem_limit; // maximum physical address allowed
260   static int physmem_fd;      // file descriptor for /dev/mem
261   
262   // Check if we should use /dev/mem allocation.  Note that it may take
263   // a while to get this flag initialized, so meanwhile we fall back to
264   // the next allocator.  (It looks like 7MB gets allocated before
265   // this flag gets initialized -khr.)
266   if (FLAGS_malloc_devmem_start == 0) {
267     // NOTE: not a devmem_failure - we'd like TCMalloc_SystemAlloc to
268     // try us again next time.
269     return NULL;
270   }
271   
272   if (!initialized) {
273     physmem_fd = open("/dev/mem", O_RDWR);
274     if (physmem_fd < 0) {
275       devmem_failure = true;
276       return NULL;
277     }
278     physmem_base = FLAGS_malloc_devmem_start*1024LL*1024LL;
279     physmem_limit = FLAGS_malloc_devmem_limit*1024LL*1024LL;
280     initialized = true;
281   }
282   
283   // Enforce page alignment
284   if (pagesize == 0) pagesize = getpagesize();
285   if (alignment < pagesize) alignment = pagesize;
286   size = ((size + alignment - 1) / alignment) * alignment;
287     
288   // could theoretically return the "extra" bytes here, but this
289   // is simple and correct.
290   if (actual_size)
291     *actual_size = size;
292     
293   // Ask for extra memory if alignment > pagesize
294   size_t extra = 0;
295   if (alignment > pagesize) {
296     extra = alignment - pagesize;
297   }
298   
299   // check to see if we have any memory left
300   if (physmem_limit != 0 && physmem_base + size + extra > physmem_limit) {
301     devmem_failure = true;
302     return NULL;
303   }
304   void *result = mmap(0, size + extra, PROT_WRITE|PROT_READ,
305                       MAP_SHARED, physmem_fd, physmem_base);
306   if (result == reinterpret_cast<void*>(MAP_FAILED)) {
307     devmem_failure = true;
308     return NULL;
309   }
310   uintptr_t ptr = reinterpret_cast<uintptr_t>(result);
311   
312   // Adjust the return memory so it is aligned
313   size_t adjust = 0;
314   if ((ptr & (alignment - 1)) != 0) {
315     adjust = alignment - (ptr & (alignment - 1));
316   }
317   
318   // Return the unused virtual memory to the system
319   if (adjust > 0) {
320     munmap(reinterpret_cast<void*>(ptr), adjust);
321   }
322   if (adjust < extra) {
323     munmap(reinterpret_cast<void*>(ptr + adjust + size), extra - adjust);
324   }
325   
326   ptr += adjust;
327   physmem_base += adjust + size;
328   
329   return reinterpret_cast<void*>(ptr);
330 }
331 #endif
332
333 void* TCMalloc_SystemAlloc(size_t size, size_t *actual_size, size_t alignment) {
334   // Discard requests that overflow
335   if (size + alignment < size) return NULL;
336     
337   SpinLockHolder lock_holder(&spinlock);
338
339   // Enforce minimum alignment
340   if (alignment < sizeof(MemoryAligner)) alignment = sizeof(MemoryAligner);
341
342   // Try twice, once avoiding allocators that failed before, and once
343   // more trying all allocators even if they failed before.
344   for (int i = 0; i < 2; i++) {
345
346 #ifndef WTF_CHANGES
347     if (use_devmem && !devmem_failure) {
348       void* result = TryDevMem(size, actual_size, alignment);
349       if (result != NULL) return result;
350     }
351 #endif
352     
353 #if HAVE(SBRK)
354     if (use_sbrk && !sbrk_failure) {
355       void* result = TrySbrk(size, actual_size, alignment);
356       if (result != NULL) return result;
357     }
358 #endif
359
360 #if HAVE(MMAP)    
361     if (use_mmap && !mmap_failure) {
362       void* result = TryMmap(size, actual_size, alignment);
363       if (result != NULL) return result;
364     }
365 #endif
366
367 #if HAVE(VIRTUALALLOC)
368     if (use_VirtualAlloc && !VirtualAlloc_failure) {
369       void* result = TryVirtualAlloc(size, actual_size, alignment);
370       if (result != NULL) return result;
371     }
372 #endif
373
374     // nothing worked - reset failure flags and try again
375     devmem_failure = false;
376     sbrk_failure = false;
377     mmap_failure = false;
378     VirtualAlloc_failure = false;
379   }
380   return NULL;
381 }
382
383 void TCMalloc_SystemRelease(void* start, size_t length) {
384 #ifdef MADV_DONTNEED
385   if (FLAGS_malloc_devmem_start) {
386     // It's not safe to use MADV_DONTNEED if we've been mapping
387     // /dev/mem for heap memory
388     return;
389   }
390   if (pagesize == 0) pagesize = getpagesize();
391   const size_t pagemask = pagesize - 1;
392
393   size_t new_start = reinterpret_cast<size_t>(start);
394   size_t end = new_start + length;
395   size_t new_end = end;
396
397   // Round up the starting address and round down the ending address
398   // to be page aligned:
399   new_start = (new_start + pagesize - 1) & ~pagemask;
400   new_end = new_end & ~pagemask;
401
402   ASSERT((new_start & pagemask) == 0);
403   ASSERT((new_end & pagemask) == 0);
404   ASSERT(new_start >= reinterpret_cast<size_t>(start));
405   ASSERT(new_end <= end);
406
407   if (new_end > new_start) {
408     // Note -- ignoring most return codes, because if this fails it
409     // doesn't matter...
410     while (madvise(reinterpret_cast<char*>(new_start), new_end - new_start,
411                    MADV_DONTNEED) == -1 &&
412            errno == EAGAIN) {
413       // NOP
414     }
415   }
416 #endif
417
418 #if HAVE(MMAP)
419   void *newAddress = mmap(start, length, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED, -1, 0);
420   UNUSED_PARAM(newAddress);
421   // If the mmap failed then that's ok, we just won't return the memory to the system.
422   ASSERT(newAddress == start || newAddress == reinterpret_cast<void*>(MAP_FAILED));
423 #endif
424 }