Source/bmalloc:
[WebKit-https.git] / Source / WTF / wtf / FastMalloc.h
1 /*
2  *  Copyright (C) 2005-2009, 2015 Apple Inc. All rights reserved.
3  *
4  *  This library is free software; you can redistribute it and/or
5  *  modify it under the terms of the GNU Library General Public
6  *  License as published by the Free Software Foundation; either
7  *  version 2 of the License, or (at your option) any later version.
8  *
9  *  This library is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  *  Library General Public License for more details.
13  *
14  *  You should have received a copy of the GNU Library General Public License
15  *  along with this library; see the file COPYING.LIB.  If not, write to
16  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  *  Boston, MA 02110-1301, USA.
18  *
19  */
20
21 #ifndef WTF_FastMalloc_h
22 #define WTF_FastMalloc_h
23
24 #include <new>
25 #include <stdlib.h>
26 #include <wtf/StdLibExtras.h>
27
28 namespace WTF {
29
30 class TryMallocReturnValue {
31 public:
32     TryMallocReturnValue(void*);
33     TryMallocReturnValue(TryMallocReturnValue&&);
34     ~TryMallocReturnValue();
35     template<typename T> bool getValue(T*&) WARN_UNUSED_RETURN;
36 private:
37     void operator=(TryMallocReturnValue&&) = delete;
38     mutable void* m_data;
39 };
40
41 WTF_EXPORT_PRIVATE bool isFastMallocEnabled();
42
43 // These functions call CRASH() if an allocation fails.
44 WTF_EXPORT_PRIVATE void* fastMalloc(size_t);
45 WTF_EXPORT_PRIVATE void* fastZeroedMalloc(size_t);
46 WTF_EXPORT_PRIVATE void* fastCalloc(size_t numElements, size_t elementSize);
47 WTF_EXPORT_PRIVATE void* fastRealloc(void*, size_t);
48 WTF_EXPORT_PRIVATE char* fastStrDup(const char*);
49
50 WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastMalloc(size_t);
51 TryMallocReturnValue tryFastZeroedMalloc(size_t);
52 WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastCalloc(size_t numElements, size_t elementSize);
53
54 WTF_EXPORT_PRIVATE void fastFree(void*);
55
56 // Allocations from fastAlignedMalloc() must be freed using fastAlignedFree().
57 WTF_EXPORT_PRIVATE void* fastAlignedMalloc(size_t alignment, size_t);
58 WTF_EXPORT_PRIVATE void fastAlignedFree(void*);
59
60 WTF_EXPORT_PRIVATE size_t fastMallocSize(const void*);
61
62 // FIXME: This is non-helpful; fastMallocGoodSize will be removed soon.
63 WTF_EXPORT_PRIVATE size_t fastMallocGoodSize(size_t);
64
65 WTF_EXPORT_PRIVATE void releaseFastMallocFreeMemory();
66 WTF_EXPORT_PRIVATE void releaseFastMallocFreeMemoryForThisThread();
67
68 struct FastMallocStatistics {
69     size_t reservedVMBytes;
70     size_t committedVMBytes;
71     size_t freeListBytes;
72 };
73 WTF_EXPORT_PRIVATE FastMallocStatistics fastMallocStatistics();
74
75 // This defines a type which holds an unsigned integer and is the same
76 // size as the minimally aligned memory allocation.
77 typedef unsigned long long AllocAlignmentInteger;
78
79 inline TryMallocReturnValue::TryMallocReturnValue(void* data)
80     : m_data(data)
81 {
82 }
83
84 inline TryMallocReturnValue::TryMallocReturnValue(TryMallocReturnValue&& source)
85     : m_data(source.m_data)
86 {
87     source.m_data = nullptr;
88 }
89
90 inline TryMallocReturnValue::~TryMallocReturnValue()
91 {
92     ASSERT(!m_data);
93 }
94
95 template<typename T> inline bool TryMallocReturnValue::getValue(T*& data)
96 {
97     data = static_cast<T*>(m_data);
98     m_data = nullptr;
99     return data;
100 }
101
102 } // namespace WTF
103
104 using WTF::isFastMallocEnabled;
105 using WTF::fastCalloc;
106 using WTF::fastFree;
107 using WTF::fastMalloc;
108 using WTF::fastMallocGoodSize;
109 using WTF::fastMallocSize;
110 using WTF::fastRealloc;
111 using WTF::fastStrDup;
112 using WTF::fastZeroedMalloc;
113 using WTF::tryFastCalloc;
114 using WTF::tryFastMalloc;
115 using WTF::tryFastZeroedMalloc;
116 using WTF::fastAlignedMalloc;
117 using WTF::fastAlignedFree;
118
119 #if COMPILER(GCC_OR_CLANG) && OS(DARWIN)
120 #define WTF_PRIVATE_INLINE __private_extern__ inline __attribute__((always_inline))
121 #elif COMPILER(GCC_OR_CLANG)
122 #define WTF_PRIVATE_INLINE inline __attribute__((always_inline))
123 #elif COMPILER(MSVC)
124 #define WTF_PRIVATE_INLINE __forceinline
125 #else
126 #define WTF_PRIVATE_INLINE inline
127 #endif
128
129 #define WTF_MAKE_FAST_ALLOCATED \
130 public: \
131     void* operator new(size_t, void* p) { return p; } \
132     void* operator new[](size_t, void* p) { return p; } \
133     \
134     void* operator new(size_t size) \
135     { \
136         return ::WTF::fastMalloc(size); \
137     } \
138     \
139     void operator delete(void* p) \
140     { \
141         ::WTF::fastFree(p); \
142     } \
143     \
144     void* operator new[](size_t size) \
145     { \
146         return ::WTF::fastMalloc(size); \
147     } \
148     \
149     void operator delete[](void* p) \
150     { \
151         ::WTF::fastFree(p); \
152     } \
153     void* operator new(size_t, NotNullTag, void* location) \
154     { \
155         ASSERT(location); \
156         return location; \
157     } \
158 private: \
159 typedef int __thisIsHereToForceASemicolonAfterThisMacro
160
161 #endif /* WTF_FastMalloc_h */