1/* Copyright (c) 2006, 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#if !defined(_BASE_LOW_LEVEL_ALLOC_H_) 32#define _BASE_LOW_LEVEL_ALLOC_H_ 33 34// A simple thread-safe memory allocator that does not depend on 35// mutexes or thread-specific data. It is intended to be used 36// sparingly, and only when malloc() would introduce an unwanted 37// dependency, such as inside the heap-checker. 38 39#include <config.h> 40#include <stddef.h> // for size_t 41#include "base/basictypes.h" 42 43class LowLevelAlloc { 44 public: 45 struct Arena; // an arena from which memory may be allocated 46 47 // Returns a pointer to a block of at least "request" bytes 48 // that have been newly allocated from the specific arena. 49 // for Alloc() call the DefaultArena() is used. 50 // Returns 0 if passed request==0. 51 // Does not return 0 under other circumstances; it crashes if memory 52 // is not available. 53 static void *Alloc(size_t request) 54 ATTRIBUTE_SECTION(malloc_hook); 55 static void *AllocWithArena(size_t request, Arena *arena) 56 ATTRIBUTE_SECTION(malloc_hook); 57 58 // Deallocates a region of memory that was previously allocated with 59 // Alloc(). Does nothing if passed 0. "s" must be either 0, 60 // or must have been returned from a call to Alloc() and not yet passed to 61 // Free() since that call to Alloc(). The space is returned to the arena 62 // from which it was allocated. 63 static void Free(void *s) ATTRIBUTE_SECTION(malloc_hook); 64 65 // ATTRIBUTE_SECTION(malloc_hook) for Alloc* and Free 66 // are to put all callers of MallocHook::Invoke* in this module 67 // into special section, 68 // so that MallocHook::GetCallerStackTrace can function accurately. 69 70 // Create a new arena. 71 // The root metadata for the new arena is allocated in the 72 // meta_data_arena; the DefaultArena() can be passed for meta_data_arena. 73 // These values may be ored into flags: 74 enum { 75 // Report calls to Alloc() and Free() via the MallocHook interface. 76 // Set in the DefaultArena. 77 kCallMallocHook = 0x0001, 78 79 // Make calls to Alloc(), Free() be async-signal-safe. Not set in 80 // DefaultArena(). 81 kAsyncSignalSafe = 0x0002, 82 83 // When used with DefaultArena(), the NewArena() and DeleteArena() calls 84 // obey the flags given explicitly in the NewArena() call, even if those 85 // flags differ from the settings in DefaultArena(). So the call 86 // NewArena(kAsyncSignalSafe, DefaultArena()) is itself async-signal-safe, 87 // as well as generatating an arena that provides async-signal-safe 88 // Alloc/Free. 89 }; 90 static Arena *NewArena(int32 flags, Arena *meta_data_arena); 91 92 // Destroys an arena allocated by NewArena and returns true, 93 // provided no allocated blocks remain in the arena. 94 // If allocated blocks remain in the arena, does nothing and 95 // returns false. 96 // It is illegal to attempt to destroy the DefaultArena(). 97 static bool DeleteArena(Arena *arena); 98 99 // The default arena that always exists. 100 static Arena *DefaultArena(); 101 102 private: 103 LowLevelAlloc(); // no instances 104}; 105 106#endif 107