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 */
63static 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*/
128static 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*/
162static 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*/
177static 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*/
200static 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*/
232static int sqlite3MemRoundup(int n){
233 return ROUND8(n);
234}
235
236/*
237** Initialize this module.
238*/
239static 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*/
266static 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*/
277void 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