1 /* 2 * Copyright (C) 2008, 2009 Paul Pedriana <ppedriana (at) 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 414
