wtf/FastAllocBase.h

   1 /*
   2  * Copyright (C) 2008, 2009 Paul Pedriana <ppedriana@ea.com>. 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
   6  * are met:
   7  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  14  *     its contributors may be used to endorse or promote products derived
  15  *     from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #ifndef FastAllocBase_h
  30 #define FastAllocBase_h
  31
  32 // Provides customizable overrides of fastMalloc/fastFree and operator new/delete
  33 //
  34 // Provided functionality:
  35 //    namespace WTF {
  36 //        class FastAllocBase;
  37 //
  38 //        T*    fastNew<T>();
  39 //        T*    fastNew<T>(arg);
  40 //        T*    fastNew<T>(arg, arg);
  41 //        T*    fastNewArray<T>(count);
  42 //        void  fastDelete(T* p);
  43 //        void  fastDeleteArray(T* p);
  44 //        void  fastNonNullDelete(T* p);
  45 //        void  fastNonNullDeleteArray(T* p);
  46 //    }
  47 //
  48 // FastDelete assumes that the underlying
  49 //
  50 // Example usage:
  51 //    class Widget : public FastAllocBase { ... };
  52 //
  53 //    char* charPtr = fastNew<char>();
  54 //    fastDelete(charPtr);
  55 //
  56 //    char* charArrayPtr = fastNewArray<char>(37);
  57 //    fastDeleteArray(charArrayPtr);
  58 //
  59 //    void** voidPtrPtr = fastNew<void*>();
  60 //    fastDelete(voidPtrPtr);
  61 //
  62 //    void** voidPtrArrayPtr = fastNewArray<void*>(37);
  63 //    fastDeleteArray(voidPtrArrayPtr);
  64 //
  65 //    POD* podPtr = fastNew<POD>();
  66 //    fastDelete(podPtr);
  67 //
  68 //    POD* podArrayPtr = fastNewArray<POD>(37);
  69 //    fastDeleteArray(podArrayPtr);
  70 //
  71 //    Object* objectPtr = fastNew<Object>();
  72 //    fastDelete(objectPtr);
  73 //
  74 //    Object* objectArrayPtr = fastNewArray<Object>(37);
  75 //    fastDeleteArray(objectArrayPtr);
  76 //
  77
  78 #include <new>
  79 #include <stdint.h>
  80 #include <stdlib.h>
  81 #include <string.h>
  82 #include "Assertions.h"
  83 #include "FastMalloc.h"
  84 #include "TypeTraits.h"
  85
  86 namespace WTF {
  87
  88     class FastAllocBase {
  89     public:
  90         // Placement operator new.
  91         void* operator new(size_t, void* p) { return p; }
  92         void* operator new[](size_t, void* p) { return p; }
  93
  94         void* operator new(size_t size)
  95         {
  96             void* p = fastMalloc(size);
  97             fastMallocMatchValidateMalloc(p, Internal::AllocTypeClassNew);
  98             return p;
  99         }
 100
 101         void operator delete(void* p)
 102         {
 103             fastMallocMatchValidateFree(p, Internal::AllocTypeClassNew);
 104             fastFree(p);
 105         }
 106
 107         void* operator new[](size_t size)
 108         {
 109             void* p = fastMalloc(size);
 110             fastMallocMatchValidateMalloc(p, Internal::AllocTypeClassNewArray);
 111             return p;
 112         }
 113
 114         void operator delete[](void* p)
 115         {
 116             fastMallocMatchValidateFree(p, Internal::AllocTypeClassNewArray);
 117             fastFree(p);
 118         }
 119     };
 120
 121     // fastNew / fastDelete
 122
 123     template <typename T>
 124     inline T* fastNew()
 125     {
 126         void* p = fastMalloc(sizeof(T));
 127
 128         if (!p)
 129             return 0;
 130
 131         fastMallocMatchValidateMalloc(p, Internal::AllocTypeFastNew);
 132         return ::new(p) T;
 133     }
 134
 135     template <typename T, typename Arg1>
 136     inline T* fastNew(Arg1 arg1)
 137     {
 138         void* p = fastMalloc(sizeof(T));
 139
 140         if (!p)
 141             return 0;
 142
 143         fastMallocMatchValidateMalloc(p, Internal::AllocTypeFastNew);
 144         return ::new(p) T(arg1);
 145     }
 146
 147     template <typename T, typename Arg1, typename Arg2>
 148     inline T* fastNew(Arg1 arg1, Arg2 arg2)
 149     {
 150         void* p = fastMalloc(sizeof(T));
 151
 152         if (!p)
 153             return 0;
 154
 155         fastMallocMatchValidateMalloc(p, Internal::AllocTypeFastNew);
 156         return ::new(p) T(arg1, arg2);
 157     }
 158
 159     template <typename T, typename Arg1, typename Arg2, typename Arg3>
 160     inline T* fastNew(Arg1 arg1, Arg2 arg2, Arg3 arg3)
 161     {
 162         void* p = fastMalloc(sizeof(T));
 163
 164         if (!p)
 165             return 0;
 166
 167         fastMallocMatchValidateMalloc(p, Internal::AllocTypeFastNew);
 168         return ::new(p) T(arg1, arg2, arg3);
 169     }
 170
 171     template <typename T, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
 172     inline T* fastNew(Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
 173     {
 174         void* p = fastMalloc(sizeof(T));
 175
 176         if (!p)
 177             return 0;
 178
 179         fastMallocMatchValidateMalloc(p, Internal::AllocTypeFastNew);
 180         return ::new(p) T(arg1, arg2, arg3, arg4);
 181     }
 182
 183     template <typename T, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
 184     inline T* fastNew(Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5)
 185     {
 186         void* p = fastMalloc(sizeof(T));
 187
 188         if (!p)
 189             return 0;
 190
 191         fastMallocMatchValidateMalloc(p, Internal::AllocTypeFastNew);
 192         return ::new(p) T(arg1, arg2, arg3, arg4, arg5);
 193     }
 194
 195     namespace Internal {
 196
 197         // We define a union of pointer to an integer and pointer to T.
 198         // When non-POD arrays are allocated we add a few leading bytes to tell what
 199         // the size of the array is. We return to the user the pointer to T.
 200         // The way to think of it is as if we allocate a struct like so:
 201         //    struct Array {
 202         //        AllocAlignmentInteger m_size;
 203         //        T m_T[array count];
 204         //    };
 205
 206         template <typename T>
 207         union ArraySize {
 208             AllocAlignmentInteger* size;
 209             T* t;
 210         };
 211
 212         // This is a support template for fastNewArray.
 213         // This handles the case wherein T has a trivial ctor and a trivial dtor.
 214         template <typename T, bool trivialCtor, bool trivialDtor>
 215         struct NewArrayImpl {
 216             static T* fastNewArray(size_t count)
 217             {
 218                 T* p = static_cast<T*>(fastMalloc(sizeof(T) * count));
 219                 fastMallocMatchValidateMalloc(p, Internal::AllocTypeFastNewArray);
 220                 return p;
 221             }
 222         };
 223
 224         // This is a support template for fastNewArray.
 225         // This handles the case wherein T has a non-trivial ctor and a trivial dtor.
 226         template <typename T>
 227         struct NewArrayImpl<T, false, true> {
 228             static T* fastNewArray(size_t count)
 229             {
 230                 T* p = static_cast<T*>(fastMalloc(sizeof(T) * count));
 231
 232                 if (!p)
 233                     return 0;
 234
 235                 fastMallocMatchValidateMalloc(p, Internal::AllocTypeFastNewArray);
 236
 237                 for (T* pObject = p, *pObjectEnd = pObject + count; pObject != pObjectEnd; ++pObject)
 238                     ::new(pObject) T;
 239
 240                 return p;
 241             }
 242         };
 243
 244         // This is a support template for fastNewArray.
 245         // This handles the case wherein T has a trivial ctor and a non-trivial dtor.
 246         template <typename T>
 247         struct NewArrayImpl<T, true, false> {
 248             static T* fastNewArray(size_t count)
 249             {
 250                 void* p = fastMalloc(sizeof(AllocAlignmentInteger) + (sizeof(T) * count));
 251                 ArraySize<T> a = { static_cast<AllocAlignmentInteger*>(p) };
 252
 253                 if (!p)
 254                     return 0;
 255
 256                 fastMallocMatchValidateMalloc(p, Internal::AllocTypeFastNewArray);
 257                 *a.size++ = count;
 258                 // No need to construct the objects in this case.
 259
 260                 return a.t;
 261             }
 262         };
 263
 264         // This is a support template for fastNewArray.
 265         // This handles the case wherein T has a non-trivial ctor and a non-trivial dtor.
 266         template <typename T>
 267         struct NewArrayImpl<T, false, false> {
 268             static T* fastNewArray(size_t count)
 269             {
 270                 void* p = fastMalloc(sizeof(AllocAlignmentInteger) + (sizeof(T) * count));
 271                 ArraySize<T> a = { static_cast<AllocAlignmentInteger*>(p) };
 272
 273                 if (!p)
 274                     return 0;
 275
 276                 fastMallocMatchValidateMalloc(p, Internal::AllocTypeFastNewArray);
 277                 *a.size++ = count;
 278
 279                 for (T* pT = a.t, *pTEnd = pT + count; pT != pTEnd; ++pT)
 280                     ::new(pT) T;
 281
 282                 return a.t;
 283             }
 284         };
 285     } // namespace Internal
 286
 287     template <typename T>
 288     inline T* fastNewArray(size_t count)
 289     {
 290         return Internal::NewArrayImpl<T, WTF::HasTrivialConstructor<T>::value, WTF::HasTrivialDestructor<T>::value>::fastNewArray(count);
 291     }
 292
 293     template <typename T>
 294     inline void fastDelete(T* p)
 295     {
 296         if (!p)
 297             return;
 298
 299         fastMallocMatchValidateFree(p, Internal::AllocTypeFastNew);
 300         p->~T();
 301         fastFree(p);
 302     }
 303
 304     template <typename T>
 305     inline void fastDeleteSkippingDestructor(T* p)
 306     {
 307         if (!p)
 308             return;
 309
 310         fastMallocMatchValidateFree(p, Internal::AllocTypeFastNew);
 311         fastFree(p);
 312     }
 313
 314     namespace Internal {
 315         // This is a support template for fastDeleteArray.
 316         // This handles the case wherein T has a trivial dtor.
 317         template <typename T, bool trivialDtor>
 318         struct DeleteArrayImpl {
 319             static void fastDeleteArray(void* p)
 320             {
 321                 // No need to destruct the objects in this case.
 322                 // We expect that fastFree checks for null.
 323                 fastMallocMatchValidateFree(p, Internal::AllocTypeFastNewArray);
 324                 fastFree(p);
 325             }
 326         };
 327
 328         // This is a support template for fastDeleteArray.
 329         // This handles the case wherein T has a non-trivial dtor.
 330         template <typename T>
 331         struct DeleteArrayImpl<T, false> {
 332             static void fastDeleteArray(T* p)
 333             {
 334                 if (!p)
 335                     return;
 336
 337                 ArraySize<T> a;
 338                 a.t = p;
 339                 a.size--; // Decrement size pointer
 340
 341                 T* pEnd = p + *a.size;
 342                 while (pEnd-- != p)
 343                     pEnd->~T();
 344
 345                 fastMallocMatchValidateFree(a.size, Internal::AllocTypeFastNewArray);
 346                 fastFree(a.size);
 347             }
 348         };
 349
 350     } // namespace Internal
 351
 352     template <typename T>
 353     void fastDeleteArray(T* p)
 354     {
 355         Internal::DeleteArrayImpl<T, WTF::HasTrivialDestructor<T>::value>::fastDeleteArray(p);
 356     }
 357
 358
 359     template <typename T>
 360     inline void fastNonNullDelete(T* p)
 361     {
 362         fastMallocMatchValidateFree(p, Internal::AllocTypeFastNew);
 363         p->~T();
 364         fastFree(p);
 365     }
 366
 367     namespace Internal {
 368         // This is a support template for fastDeleteArray.
 369         // This handles the case wherein T has a trivial dtor.
 370         template <typename T, bool trivialDtor>
 371         struct NonNullDeleteArrayImpl {
 372             static void fastNonNullDeleteArray(void* p)
 373             {
 374                 fastMallocMatchValidateFree(p, Internal::AllocTypeFastNewArray);
 375                 // No need to destruct the objects in this case.
 376                 fastFree(p);
 377             }
 378         };
 379
 380         // This is a support template for fastDeleteArray.
 381         // This handles the case wherein T has a non-trivial dtor.
 382         template <typename T>
 383         struct NonNullDeleteArrayImpl<T, false> {
 384             static void fastNonNullDeleteArray(T* p)
 385             {
 386                 ArraySize<T> a;
 387                 a.t = p;
 388                 a.size--;
 389
 390                 T* pEnd = p + *a.size;
 391                 while (pEnd-- != p)
 392                     pEnd->~T();
 393
 394                 fastMallocMatchValidateFree(a.size, Internal::AllocTypeFastNewArray);
 395                 fastFree(a.size);
 396             }
 397         };
 398
 399     } // namespace Internal
 400
 401     template <typename T>
 402     void fastNonNullDeleteArray(T* p)
 403     {
 404         Internal::NonNullDeleteArrayImpl<T, WTF::HasTrivialDestructor<T>::value>::fastNonNullDeleteArray(p);
 405     }
 406
 407
 408 } // namespace WTF
 409
 410 using WTF::FastAllocBase;
 411 using WTF::fastDeleteSkippingDestructor;
 412
 413 #endif // FastAllocBase_h