1// Copyright (c) 2005, 2007, Google Inc. 2// All rights reserved. 3// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2011 Apple Inc. All rights reserved. 4// 5// Redistribution and use in source and binary forms, with or without 6// modification, are permitted provided that the following conditions are 7// met: 8// 9// * Redistributions of source code must retain the above copyright 10// notice, this list of conditions and the following disclaimer. 11// * Redistributions in binary form must reproduce the above 12// copyright notice, this list of conditions and the following disclaimer 13// in the documentation and/or other materials provided with the 14// distribution. 15// * Neither the name of Google Inc. nor the names of its 16// contributors may be used to endorse or promote products derived from 17// this software without specific prior written permission. 18// 19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31#include "config.h" 32#include "wtf/FastMalloc.h" 33 34#include <string.h> 35 36namespace WTF { 37 38void* fastZeroedMalloc(size_t n) 39{ 40 void* result = fastMalloc(n); 41 memset(result, 0, n); 42 return result; 43} 44 45char* fastStrDup(const char* src) 46{ 47 size_t len = strlen(src) + 1; 48 char* dup = static_cast<char*>(fastMalloc(len)); 49 memcpy(dup, src, len); 50 return dup; 51} 52 53// TODO: remove these two. 54void releaseFastMallocFreeMemory() { } 55 56FastMallocStatistics fastMallocStatistics() 57{ 58 FastMallocStatistics statistics = { 0, 0, 0 }; 59 return statistics; 60} 61 62} // namespace WTF 63 64#if USE(SYSTEM_MALLOC) 65 66#include "wtf/Assertions.h" 67 68#include <stdlib.h> 69 70namespace WTF { 71 72void fastMallocShutdown() 73{ 74} 75 76void* fastMalloc(size_t n) 77{ 78 void* result = malloc(n); 79 ASSERT(result); // We expect tcmalloc underneath, which would crash instead of getting here. 80 81 return result; 82} 83 84void fastFree(void* p) 85{ 86 free(p); 87} 88 89void* fastRealloc(void* p, size_t n) 90{ 91 void* result = realloc(p, n); 92 ASSERT(result); // We expect tcmalloc underneath, which would crash instead of getting here. 93 94 return result; 95} 96 97} // namespace WTF 98 99#else // USE(SYSTEM_MALLOC) 100 101#include "wtf/PartitionAlloc.h" 102#include "wtf/SpinLock.h" 103 104namespace WTF { 105 106static PartitionAllocatorGeneric gPartition; 107static int gLock = 0; 108static bool gInitialized = false; 109 110void fastMallocShutdown() 111{ 112 gPartition.shutdown(); 113} 114 115void* fastMalloc(size_t n) 116{ 117 if (UNLIKELY(!gInitialized)) { 118 spinLockLock(&gLock); 119 if (!gInitialized) { 120 gInitialized = true; 121 gPartition.init(); 122 } 123 spinLockUnlock(&gLock); 124 } 125 return partitionAllocGeneric(gPartition.root(), n); 126} 127 128void fastFree(void* p) 129{ 130 partitionFreeGeneric(gPartition.root(), p); 131} 132 133void* fastRealloc(void* p, size_t n) 134{ 135 return partitionReallocGeneric(gPartition.root(), p, n); 136} 137 138} // namespace WTF 139 140#endif // USE(SYSTEM_MALLOC) 141