1 /*
2 ** 2007 August 14
3 **
4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
6 **
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
10 **
11 *************************************************************************
12 **
13 ** This file contains low-level memory allocation drivers for when
14 ** SQLite will use the standard C-library malloc/realloc/free interface
15 ** to obtain the memory it needs.
16 **
17 ** This file contains implementations of the low-level memory allocation
18 ** routines specified in the sqlite3_mem_methods object. The content of
19 ** this file is only used if SQLITE_SYSTEM_MALLOC is defined. The
20 ** SQLITE_SYSTEM_MALLOC macro is defined automatically if neither the
21 ** SQLITE_MEMDEBUG nor the SQLITE_WIN32_MALLOC macros are defined. The
22 ** default configuration is to use memory allocation routines in this
23 ** file.
24 **
25 ** C-preprocessor macro summary:
26 **
27 ** HAVE_MALLOC_USABLE_SIZE The configure script sets this symbol if
28 ** the malloc_usable_size() interface exists
29 ** on the target platform. Or, this symbol
30 ** can be set manually, if desired.
31 ** If an equivalent interface exists by
32 ** a different name, using a separate -D
33 ** option to rename it.
34 **
35 ** SQLITE_WITHOUT_ZONEMALLOC Some older macs lack support for the zone
36 ** memory allocator. Set this symbol to enable
37 ** building on older macs.
38 **
39 ** SQLITE_WITHOUT_MSIZE Set this symbol to disable the use of
40 ** _msize() on windows systems. This might
41 ** be necessary when compiling for Delphi,
42 ** for example.
43 */
44 #include "sqliteInt.h"
45
46 /*
47 ** This version of the memory allocator is the default. It is
48 ** used when no other memory allocator is specified using compile-time
49 ** macros.
50 */
51 #ifdef SQLITE_SYSTEM_MALLOC
52 #if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC)
53
54 /*
55 ** Use the zone allocator available on apple products unless the
56 ** SQLITE_WITHOUT_ZONEMALLOC symbol is defined.
57 */
58 #include <sys/sysctl.h>
59 #include <malloc/malloc.h>
60 #ifdef SQLITE_MIGHT_BE_SINGLE_CORE
61 #include <libkern/OSAtomic.h>
62 #endif /* SQLITE_MIGHT_BE_SINGLE_CORE */
63 static malloc_zone_t* _sqliteZone_;
64 #define SQLITE_MALLOC(x) malloc_zone_malloc(_sqliteZone_, (x))
65 #define SQLITE_FREE(x) malloc_zone_free(_sqliteZone_, (x));
66 #define SQLITE_REALLOC(x,y) malloc_zone_realloc(_sqliteZone_, (x), (y))
67 #define SQLITE_MALLOCSIZE(x) \
68 (_sqliteZone_ ? _sqliteZone_->size(_sqliteZone_,x) : malloc_size(x))
69
70 #else /* if not __APPLE__ */
71
72 /*
73 ** Use standard C library malloc and free on non-Apple systems.
74 ** Also used by Apple systems if SQLITE_WITHOUT_ZONEMALLOC is defined.
75 */
76 #define SQLITE_MALLOC(x) malloc(x)
77 #define SQLITE_FREE(x) free(x)
78 #define SQLITE_REALLOC(x,y) realloc((x),(y))
79
80 /*
81 ** The malloc.h header file is needed for malloc_usable_size() function
82 ** on some systems (e.g. Linux).
83 */
84 #if HAVE_MALLOC_H && HAVE_MALLOC_USABLE_SIZE
85 # define SQLITE_USE_MALLOC_H 1
86 # define SQLITE_USE_MALLOC_USABLE_SIZE 1
87 /*
88 ** The MSVCRT has malloc_usable_size(), but it is called _msize(). The
89 ** use of _msize() is automatic, but can be disabled by compiling with
90 ** -DSQLITE_WITHOUT_MSIZE. Using the _msize() function also requires
91 ** the malloc.h header file.
92 */
93 #elif defined(_MSC_VER) && !defined(SQLITE_WITHOUT_MSIZE)
94 # define SQLITE_USE_MALLOC_H
95 # define SQLITE_USE_MSIZE
96 #endif
97
98 /*
99 ** Include the malloc.h header file, if necessary. Also set define macro
100 ** SQLITE_MALLOCSIZE to the appropriate function name, which is _msize()
101 ** for MSVC and malloc_usable_size() for most other systems (e.g. Linux).
102 ** The memory size function can always be overridden manually by defining
103 ** the macro SQLITE_MALLOCSIZE to the desired function name.
104 */
105 #if defined(SQLITE_USE_MALLOC_H)
106 # include <malloc.h>
107 # if defined(SQLITE_USE_MALLOC_USABLE_SIZE)
108 # if !defined(SQLITE_MALLOCSIZE)
109 # define SQLITE_MALLOCSIZE(x) malloc_usable_size(x)
110 # endif
111 # elif defined(SQLITE_USE_MSIZE)
112 # if !defined(SQLITE_MALLOCSIZE)
113 # define SQLITE_MALLOCSIZE _msize
114 # endif
115 # endif
116 #endif /* defined(SQLITE_USE_MALLOC_H) */
117
118 #endif /* __APPLE__ or not __APPLE__ */
119
120 /*
121 ** Like malloc(), but remember the size of the allocation
122 ** so that we can find it later using sqlite3MemSize().
123 **
124 ** For this low-level routine, we are guaranteed that nByte>0 because
125 ** cases of nByte<=0 will be intercepted and dealt with by higher level
126 ** routines.
127 */
sqlite3MemMalloc(int nByte)128 static void *sqlite3MemMalloc(int nByte){
129 #ifdef SQLITE_MALLOCSIZE
130 void *p;
131 testcase( ROUND8(nByte)==nByte );
132 p = SQLITE_MALLOC( nByte );
133 if( p==0 ){
134 testcase( sqlite3GlobalConfig.xLog!=0 );
135 sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
136 }
137 return p;
138 #else
139 sqlite3_int64 *p;
140 assert( nByte>0 );
141 testcase( ROUND8(nByte)!=nByte );
142 p = SQLITE_MALLOC( nByte+8 );
143 if( p ){
144 p[0] = nByte;
145 p++;
146 }else{
147 testcase( sqlite3GlobalConfig.xLog!=0 );
148 sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
149 }
150 return (void *)p;
151 #endif
152 }
153
154 /*
155 ** Like free() but works for allocations obtained from sqlite3MemMalloc()
156 ** or sqlite3MemRealloc().
157 **
158 ** For this low-level routine, we already know that pPrior!=0 since
159 ** cases where pPrior==0 will have been intecepted and dealt with
160 ** by higher-level routines.
161 */
sqlite3MemFree(void * pPrior)162 static void sqlite3MemFree(void *pPrior){
163 #ifdef SQLITE_MALLOCSIZE
164 SQLITE_FREE(pPrior);
165 #else
166 sqlite3_int64 *p = (sqlite3_int64*)pPrior;
167 assert( pPrior!=0 );
168 p--;
169 SQLITE_FREE(p);
170 #endif
171 }
172
173 /*
174 ** Report the allocated size of a prior return from xMalloc()
175 ** or xRealloc().
176 */
sqlite3MemSize(void * pPrior)177 static int sqlite3MemSize(void *pPrior){
178 #ifdef SQLITE_MALLOCSIZE
179 assert( pPrior!=0 );
180 return (int)SQLITE_MALLOCSIZE(pPrior);
181 #else
182 sqlite3_int64 *p;
183 assert( pPrior!=0 );
184 p = (sqlite3_int64*)pPrior;
185 p--;
186 return (int)p[0];
187 #endif
188 }
189
190 /*
191 ** Like realloc(). Resize an allocation previously obtained from
192 ** sqlite3MemMalloc().
193 **
194 ** For this low-level interface, we know that pPrior!=0. Cases where
195 ** pPrior==0 while have been intercepted by higher-level routine and
196 ** redirected to xMalloc. Similarly, we know that nByte>0 because
197 ** cases where nByte<=0 will have been intercepted by higher-level
198 ** routines and redirected to xFree.
199 */
sqlite3MemRealloc(void * pPrior,int nByte)200 static void *sqlite3MemRealloc(void *pPrior, int nByte){
201 #ifdef SQLITE_MALLOCSIZE
202 void *p = SQLITE_REALLOC(pPrior, nByte);
203 if( p==0 ){
204 testcase( sqlite3GlobalConfig.xLog!=0 );
205 sqlite3_log(SQLITE_NOMEM,
206 "failed memory resize %u to %u bytes",
207 SQLITE_MALLOCSIZE(pPrior), nByte);
208 }
209 return p;
210 #else
211 sqlite3_int64 *p = (sqlite3_int64*)pPrior;
212 assert( pPrior!=0 && nByte>0 );
213 assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */
214 p--;
215 p = SQLITE_REALLOC(p, nByte+8 );
216 if( p ){
217 p[0] = nByte;
218 p++;
219 }else{
220 testcase( sqlite3GlobalConfig.xLog!=0 );
221 sqlite3_log(SQLITE_NOMEM,
222 "failed memory resize %u to %u bytes",
223 sqlite3MemSize(pPrior), nByte);
224 }
225 return (void*)p;
226 #endif
227 }
228
229 /*
230 ** Round up a request size to the next valid allocation size.
231 */
sqlite3MemRoundup(int n)232 static int sqlite3MemRoundup(int n){
233 return ROUND8(n);
234 }
235
236 /*
237 ** Initialize this module.
238 */
sqlite3MemInit(void * NotUsed)239 static int sqlite3MemInit(void *NotUsed){
240 #if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC)
241 int cpuCount;
242 size_t len;
243 if( _sqliteZone_ ){
244 return SQLITE_OK;
245 }
246 len = sizeof(cpuCount);
247 /* One usually wants to use hw.acctivecpu for MT decisions, but not here */
248 sysctlbyname("hw.ncpu", &cpuCount, &len, NULL, 0);
249 if( cpuCount>1 ){
250 /* defer MT decisions to system malloc */
251 _sqliteZone_ = malloc_default_zone();
252 }else{
253 /* only 1 core, use our own zone to contention over global locks,
254 ** e.g. we have our own dedicated locks */
255 _sqliteZone_ = malloc_create_zone(4096, 0);
256 malloc_set_zone_name(_sqliteZone_, "Sqlite_Heap");
257 }
258 #endif /* defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC) */
259 UNUSED_PARAMETER(NotUsed);
260 return SQLITE_OK;
261 }
262
263 /*
264 ** Deinitialize this module.
265 */
sqlite3MemShutdown(void * NotUsed)266 static void sqlite3MemShutdown(void *NotUsed){
267 UNUSED_PARAMETER(NotUsed);
268 return;
269 }
270
271 /*
272 ** This routine is the only routine in this file with external linkage.
273 **
274 ** Populate the low-level memory allocation function pointers in
275 ** sqlite3GlobalConfig.m with pointers to the routines in this file.
276 */
sqlite3MemSetDefault(void)277 void sqlite3MemSetDefault(void){
278 static const sqlite3_mem_methods defaultMethods = {
279 sqlite3MemMalloc,
280 sqlite3MemFree,
281 sqlite3MemRealloc,
282 sqlite3MemSize,
283 sqlite3MemRoundup,
284 sqlite3MemInit,
285 sqlite3MemShutdown,
286 0
287 };
288 sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
289 }
290
291 #endif /* SQLITE_SYSTEM_MALLOC */
292