| 1 |
// -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- |
| 2 |
/* Copyright (c) 2006, Google Inc. |
| 3 |
* All rights reserved. |
| 4 |
* |
| 5 |
* Redistribution and use in source and binary forms, with or without |
| 6 |
* modification, are permitted provided that the following conditions are |
| 7 |
* met: |
| 8 |
* |
| 9 |
* * Redistributions of source code must retain the above copyright |
| 10 |
* notice, this list of conditions and the following disclaimer. |
| 11 |
* * Redistributions in binary form must reproduce the above |
| 12 |
* copyright notice, this list of conditions and the following disclaimer |
| 13 |
* in the documentation and/or other materials provided with the |
| 14 |
* distribution. |
| 15 |
* * Neither the name of Google Inc. nor the names of its |
| 16 |
* contributors may be used to endorse or promote products derived from |
| 17 |
* this software without specific prior written permission. |
| 18 |
* |
| 19 |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 20 |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 21 |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 22 |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 23 |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 24 |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 25 |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 26 |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 27 |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 28 |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 29 |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 30 |
*/ |
| 31 |
|
| 32 |
#if !defined(_BASE_LOW_LEVEL_ALLOC_H_) |
| 33 |
#define _BASE_LOW_LEVEL_ALLOC_H_ |
| 34 |
|
| 35 |
// A simple thread-safe memory allocator that does not depend on |
| 36 |
// mutexes or thread-specific data. It is intended to be used |
| 37 |
// sparingly, and only when malloc() would introduce an unwanted |
| 38 |
// dependency, such as inside the heap-checker. |
| 39 |
|
| 40 |
#include <config.h> |
| 41 |
#include <stddef.h> // for size_t |
| 42 |
#include "base/basictypes.h" |
| 43 |
|
| 44 |
#ifndef __APPLE__ |
| 45 |
// As of now, whatever clang version apple ships (clang-1205.0.22.11), |
| 46 |
// somehow miscompiles LowLevelAlloc when we try this section |
| 47 |
// thingy. Thankfully, we only need this section stuff heap leak |
| 48 |
// checker which is Linux-only anyways. |
| 49 |
#define ATTR_MALLOC_SECTION ATTRIBUTE_SECTION(malloc_hook) |
| 50 |
#else |
| 51 |
#define ATTR_MALLOC_SECTION |
| 52 |
#endif |
| 53 |
|
| 54 |
class LowLevelAlloc { |
| 55 |
public: |
| 56 |
class PagesAllocator { |
| 57 |
public: |
| 58 |
virtual ~PagesAllocator(); |
| 59 |
virtual void *MapPages(int32 flags, size_t size) = 0; |
| 60 |
virtual void UnMapPages(int32 flags, void *addr, size_t size) = 0; |
| 61 |
}; |
| 62 |
|
| 63 |
static PagesAllocator *GetDefaultPagesAllocator(void); |
| 64 |
|
| 65 |
struct Arena; // an arena from which memory may be allocated |
| 66 |
|
| 67 |
// Returns a pointer to a block of at least "request" bytes |
| 68 |
// that have been newly allocated from the specific arena. |
| 69 |
// for Alloc() call the DefaultArena() is used. |
| 70 |
// Returns 0 if passed request==0. |
| 71 |
// Does not return 0 under other circumstances; it crashes if memory |
| 72 |
// is not available. |
| 73 |
static void *Alloc(size_t request) |
| 74 |
ATTR_MALLOC_SECTION; |
| 75 |
static void *AllocWithArena(size_t request, Arena *arena) |
| 76 |
ATTR_MALLOC_SECTION; |
| 77 |
|
| 78 |
// Deallocates a region of memory that was previously allocated with |
| 79 |
// Alloc(). Does nothing if passed 0. "s" must be either 0, |
| 80 |
// or must have been returned from a call to Alloc() and not yet passed to |
| 81 |
// Free() since that call to Alloc(). The space is returned to the arena |
| 82 |
// from which it was allocated. |
| 83 |
static void Free(void *s) ATTR_MALLOC_SECTION; |
| 84 |
|
| 85 |
// ATTR_MALLOC_SECTION for Alloc* and Free |
| 86 |
// are to put all callers of MallocHook::Invoke* in this module |
| 87 |
// into special section, |
| 88 |
// so that MallocHook::GetCallerStackTrace can function accurately. |
| 89 |
|
| 90 |
// Create a new arena. |
| 91 |
// The root metadata for the new arena is allocated in the |
| 92 |
// meta_data_arena; the DefaultArena() can be passed for meta_data_arena. |
| 93 |
// These values may be ored into flags: |
| 94 |
enum { |
| 95 |
// Report calls to Alloc() and Free() via the MallocHook interface. |
| 96 |
// Set in the DefaultArena. |
| 97 |
kCallMallocHook = 0x0001, |
| 98 |
|
| 99 |
// Make calls to Alloc(), Free() be async-signal-safe. Not set in |
| 100 |
// DefaultArena(). |
| 101 |
kAsyncSignalSafe = 0x0002, |
| 102 |
|
| 103 |
// When used with DefaultArena(), the NewArena() and DeleteArena() calls |
| 104 |
// obey the flags given explicitly in the NewArena() call, even if those |
| 105 |
// flags differ from the settings in DefaultArena(). So the call |
| 106 |
// NewArena(kAsyncSignalSafe, DefaultArena()) is itself async-signal-safe, |
| 107 |
// as well as generatating an arena that provides async-signal-safe |
| 108 |
// Alloc/Free. |
| 109 |
}; |
| 110 |
static Arena *NewArena(int32 flags, Arena *meta_data_arena); |
| 111 |
|
| 112 |
// note: pages allocator will never be destroyed and allocated pages will never be freed |
| 113 |
// When allocator is NULL, it's same as NewArena |
| 114 |
static Arena *NewArenaWithCustomAlloc(int32 flags, Arena *meta_data_arena, PagesAllocator *allocator); |
| 115 |
|
| 116 |
// Destroys an arena allocated by NewArena and returns true, |
| 117 |
// provided no allocated blocks remain in the arena. |
| 118 |
// If allocated blocks remain in the arena, does nothing and |
| 119 |
// returns false. |
| 120 |
// It is illegal to attempt to destroy the DefaultArena(). |
| 121 |
static bool DeleteArena(Arena *arena); |
| 122 |
|
| 123 |
// The default arena that always exists. |
| 124 |
static Arena *DefaultArena(); |
| 125 |
|
| 126 |
private: |
| 127 |
LowLevelAlloc(); // no instances |
| 128 |
}; |
| 129 |
|
| 130 |
#endif |