mfbt/AllocPolicy.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /*
   8  * An allocation policy concept, usable for structures and algorithms to
   9  * control how memory is allocated and how failures are handled.
  10  */
  11
  12 #ifndef mozilla_AllocPolicy_h
  13 #define mozilla_AllocPolicy_h
  14
  15 #include "mozilla/Attributes.h"
  16 #include "mozilla/Assertions.h"
  17 #include "mozilla/TemplateLib.h"
  18
  19 #include <stddef.h>
  20 #include <stdlib.h>
  21
  22 namespace mozilla {
  23
  24 /*
  25  * Allocation policies are used to implement the standard allocation behaviors
  26  * in a customizable way.  Additionally, custom behaviors may be added to these
  27  * behaviors, such as additionally reporting an error through an out-of-band
  28  * mechanism when OOM occurs.  The concept modeled here is as follows:
  29  *
  30  *  - public copy constructor, assignment, destructor
  31  *  - template <typename T> T* maybe_pod_malloc(size_t)
  32  *      Fallible, but doesn't report an error on OOM.
  33  *  - template <typename T> T* maybe_pod_calloc(size_t)
  34  *      Fallible, but doesn't report an error on OOM.
  35  *  - template <typename T> T* maybe_pod_realloc(T*, size_t, size_t)
  36  *      Fallible, but doesn't report an error on OOM.  The old allocation
  37  *      size is passed in, in addition to the new allocation size requested.
  38  *  - template <typename T> T* pod_malloc(size_t)
  39  *      Responsible for OOM reporting when null is returned.
  40  *  - template <typename T> T* pod_calloc(size_t)
  41  *      Responsible for OOM reporting when null is returned.
  42  *  - template <typename T> T* pod_realloc(T*, size_t, size_t)
  43  *      Responsible for OOM reporting when null is returned.  The old allocation
  44  *      size is passed in, in addition to the new allocation size requested.
  45  *  - void free_(void*)
  46  *  - void reportAllocOverflow() const
  47  *      Called on allocation overflow (that is, an allocation implicitly tried
  48  *      to allocate more than the available memory space -- think allocating an
  49  *      array of large-size objects, where N * size overflows) before null is
  50  *      returned.
  51  *  - bool checkSimulatedOOM() const
  52  *      Some clients generally allocate memory yet in some circumstances won't
  53  *      need to do so. For example, appending to a vector with a small amount of
  54  *      inline storage generally allocates memory, but no allocation occurs
  55  *      unless appending exceeds inline storage. But for testing purposes, it
  56  *      can be useful to treat *every* operation as allocating.
  57  *      Clients (such as this hypothetical append method implementation) should
  58  *      call this method in situations that don't allocate, but could generally,
  59  *      to support this. The default behavior should return true; more
  60  *      complicated behavior might be to return false only after a certain
  61  *      number of allocations-or-check-simulated-OOMs (coordinating with the
  62  *      other AllocPolicy methods) have occurred.
  63  *
  64  * mfbt provides (and typically uses by default) only MallocAllocPolicy, which
  65  * does nothing more than delegate to the malloc/alloc/free functions.
  66  */
  67
  68 /*
  69  * A policy that straightforwardly uses malloc/calloc/realloc/free and adds no
  70  * extra behaviors.
  71  */
  72 class MallocAllocPolicy
  73 {
  74 public:
  75   template <typename T>
  76   T* maybe_pod_malloc(size_t aNumElems)
  77   {
  78     if (aNumElems & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
  79       return nullptr;
  80     }
  81     return static_cast<T*>(malloc(aNumElems * sizeof(T)));
  82   }
  83
  84   template <typename T>
  85   T* maybe_pod_calloc(size_t aNumElems)
  86   {
  87     return static_cast<T*>(calloc(aNumElems, sizeof(T)));
  88   }
  89
  90   template <typename T>
  91   T* maybe_pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize)
  92   {
  93     if (aNewSize & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
  94       return nullptr;
  95     }
  96     return static_cast<T*>(realloc(aPtr, aNewSize * sizeof(T)));
  97   }
  98
  99   template <typename T>
 100   T* pod_malloc(size_t aNumElems)
 101   {
 102     return maybe_pod_malloc<T>(aNumElems);
 103   }
 104
 105   template <typename T>
 106   T* pod_calloc(size_t aNumElems)
 107   {
 108     return maybe_pod_calloc<T>(aNumElems);
 109   }
 110
 111   template <typename T>
 112   T* pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize)
 113   {
 114     return maybe_pod_realloc<T>(aPtr, aOldSize, aNewSize);
 115   }
 116
 117   void free_(void* aPtr)
 118   {
 119     free(aPtr);
 120   }
 121
 122   void reportAllocOverflow() const
 123   {
 124   }
 125
 126   MOZ_MUST_USE bool checkSimulatedOOM() const
 127   {
 128     return true;
 129   }
 130 };
 131
 132 /*
 133  * A policy which always fails to allocate memory, returning nullptr. Methods
 134  * which expect an existing allocation assert.
 135  *
 136  * This type should be used in situations where you want to use a MFBT type with
 137  * inline storage, and don't want to allow it to allocate on the heap.
 138  */
 139 class NeverAllocPolicy
 140 {
 141 public:
 142   template <typename T>
 143   T* maybe_pod_malloc(size_t aNumElems)
 144   {
 145     return nullptr;
 146   }
 147
 148   template <typename T>
 149   T* maybe_pod_calloc(size_t aNumElems)
 150   {
 151     return nullptr;
 152   }
 153
 154   template <typename T>
 155   T* maybe_pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize)
 156   {
 157     MOZ_CRASH("NeverAllocPolicy::maybe_pod_realloc");
 158   }
 159
 160   template <typename T>
 161   T* pod_malloc(size_t aNumElems)
 162   {
 163     return nullptr;
 164   }
 165
 166   template <typename T>
 167   T* pod_calloc(size_t aNumElems)
 168   {
 169     return nullptr;
 170   }
 171
 172   template <typename T>
 173   T* pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize)
 174   {
 175     MOZ_CRASH("NeverAllocPolicy::pod_realloc");
 176   }
 177
 178   void free_(void* aPtr)
 179   {
 180     MOZ_CRASH("NeverAllocPolicy::free_");
 181   }
 182
 183   void reportAllocOverflow() const
 184   {
 185   }
 186
 187   MOZ_MUST_USE bool checkSimulatedOOM() const
 188   {
 189     return true;
 190   }
 191 };
 192
 193 } // namespace mozilla
 194
 195 #endif /* mozilla_AllocPolicy_h */