third_party/tcmalloc/chromium/src/base/low_level_alloc.h

   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
  43 class 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