000001 /*
000002 ** 2007 August 14
000003 **
000004 ** The author disclaims copyright to this source code. In place of
000005 ** a legal notice, here is a blessing:
000006 **
000007 ** May you do good and not evil.
000008 ** May you find forgiveness for yourself and forgive others.
000009 ** May you share freely, never taking more than you give.
000010 **
000011 *************************************************************************
000012 **
000013 ** This file contains low-level memory allocation drivers for when
000014 ** SQLite will use the standard C-library malloc/realloc/free interface
000015 ** to obtain the memory it needs.
000016 **
000017 ** This file contains implementations of the low-level memory allocation
000018 ** routines specified in the sqlite3_mem_methods object. The content of
000019 ** this file is only used if SQLITE_SYSTEM_MALLOC is defined. The
000020 ** SQLITE_SYSTEM_MALLOC macro is defined automatically if neither the
000021 ** SQLITE_MEMDEBUG nor the SQLITE_WIN32_MALLOC macros are defined. The
000022 ** default configuration is to use memory allocation routines in this
000023 ** file.
000024 **
000025 ** C-preprocessor macro summary:
000026 **
000027 ** HAVE_MALLOC_USABLE_SIZE The configure script sets this symbol if
000028 ** the malloc_usable_size() interface exists
000029 ** on the target platform. Or, this symbol
000030 ** can be set manually, if desired.
000031 ** If an equivalent interface exists by
000032 ** a different name, using a separate -D
000033 ** option to rename it.
000034 **
000035 ** SQLITE_WITHOUT_ZONEMALLOC Some older macs lack support for the zone
000036 ** memory allocator. Set this symbol to enable
000037 ** building on older macs.
000038 **
000039 ** SQLITE_WITHOUT_MSIZE Set this symbol to disable the use of
000040 ** _msize() on windows systems. This might
000041 ** be necessary when compiling for Delphi,
000042 ** for example.
000043 */
000044 #include "sqliteInt.h"
000045
000046 /*
000047 ** This version of the memory allocator is the default. It is
000048 ** used when no other memory allocator is specified using compile-time
000049 ** macros.
000050 */
000051 #ifdef SQLITE_SYSTEM_MALLOC
000052 #if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC)
000053
000054 /*
000055 ** Use the zone allocator available on apple products unless the
000056 ** SQLITE_WITHOUT_ZONEMALLOC symbol is defined.
000057 */
000058 #include <sys/sysctl.h>
000059 #include <malloc/malloc.h>
000060 #ifdef SQLITE_MIGHT_BE_SINGLE_CORE
000061 #include <libkern/OSAtomic.h>
000062 #endif /* SQLITE_MIGHT_BE_SINGLE_CORE */
000063 static malloc_zone_t* _sqliteZone_;
000064 #define SQLITE_MALLOC(x) malloc_zone_malloc(_sqliteZone_, (x))
000065 #define SQLITE_FREE(x) malloc_zone_free(_sqliteZone_, (x));
000066 #define SQLITE_REALLOC(x,y) malloc_zone_realloc(_sqliteZone_, (x), (y))
000067 #define SQLITE_MALLOCSIZE(x) \
000068 (_sqliteZone_ ? _sqliteZone_->size(_sqliteZone_,x) : malloc_size(x))
000069
000070 #else /* if not __APPLE__ */
000071
000072 /*
000073 ** Use standard C library malloc and free on non-Apple systems.
000074 ** Also used by Apple systems if SQLITE_WITHOUT_ZONEMALLOC is defined.
000075 */
000076 #define SQLITE_MALLOC(x) malloc(x)
000077 #define SQLITE_FREE(x) free(x)
000078 #define SQLITE_REALLOC(x,y) realloc((x),(y))
000079
000080 /*
000081 ** The malloc.h header file is needed for malloc_usable_size() function
000082 ** on some systems (e.g. Linux).
000083 */
000084 #if HAVE_MALLOC_H && HAVE_MALLOC_USABLE_SIZE
000085 # define SQLITE_USE_MALLOC_H 1
000086 # define SQLITE_USE_MALLOC_USABLE_SIZE 1
000087 /*
000088 ** The MSVCRT has malloc_usable_size(), but it is called _msize(). The
000089 ** use of _msize() is automatic, but can be disabled by compiling with
000090 ** -DSQLITE_WITHOUT_MSIZE. Using the _msize() function also requires
000091 ** the malloc.h header file.
000092 */
000093 #elif defined(_MSC_VER) && !defined(SQLITE_WITHOUT_MSIZE)
000094 # define SQLITE_USE_MALLOC_H
000095 # define SQLITE_USE_MSIZE
000096 #endif
000097
000098 /*
000099 ** Include the malloc.h header file, if necessary. Also set define macro
000100 ** SQLITE_MALLOCSIZE to the appropriate function name, which is _msize()
000101 ** for MSVC and malloc_usable_size() for most other systems (e.g. Linux).
000102 ** The memory size function can always be overridden manually by defining
000103 ** the macro SQLITE_MALLOCSIZE to the desired function name.
000104 */
000105 #if defined(SQLITE_USE_MALLOC_H)
000106 # include <malloc.h>
000107 # if defined(SQLITE_USE_MALLOC_USABLE_SIZE)
000108 # if !defined(SQLITE_MALLOCSIZE)
000109 # define SQLITE_MALLOCSIZE(x) malloc_usable_size(x)
000110 # endif
000111 # elif defined(SQLITE_USE_MSIZE)
000112 # if !defined(SQLITE_MALLOCSIZE)
000113 # define SQLITE_MALLOCSIZE _msize
000114 # endif
000115 # endif
000116 #endif /* defined(SQLITE_USE_MALLOC_H) */
000117
000118 #endif /* __APPLE__ or not __APPLE__ */
000119
000120 /*
000121 ** Like malloc(), but remember the size of the allocation
000122 ** so that we can find it later using sqlite3MemSize().
000123 **
000124 ** For this low-level routine, we are guaranteed that nByte>0 because
000125 ** cases of nByte<=0 will be intercepted and dealt with by higher level
000126 ** routines.
000127 */
000128 static void *sqlite3MemMalloc(int nByte){
000129 #ifdef SQLITE_MALLOCSIZE
000130 void *p;
000131 testcase( ROUND8(nByte)==nByte );
000132 p = SQLITE_MALLOC( nByte );
000133 if( p==0 ){
000134 testcase( sqlite3GlobalConfig.xLog!=0 );
000135 sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
000136 }
000137 return p;
000138 #else
000139 sqlite3_int64 *p;
000140 assert( nByte>0 );
000141 testcase( ROUND8(nByte)!=nByte );
000142 p = SQLITE_MALLOC( nByte+8 );
000143 if( p ){
000144 p[0] = nByte;
000145 p++;
000146 }else{
000147 testcase( sqlite3GlobalConfig.xLog!=0 );
000148 sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
000149 }
000150 return (void *)p;
000151 #endif
000152 }
000153
000154 /*
000155 ** Like free() but works for allocations obtained from sqlite3MemMalloc()
000156 ** or sqlite3MemRealloc().
000157 **
000158 ** For this low-level routine, we already know that pPrior!=0 since
000159 ** cases where pPrior==0 will have been intercepted and dealt with
000160 ** by higher-level routines.
000161 */
000162 static void sqlite3MemFree(void *pPrior){
000163 #ifdef SQLITE_MALLOCSIZE
000164 SQLITE_FREE(pPrior);
000165 #else
000166 sqlite3_int64 *p = (sqlite3_int64*)pPrior;
000167 assert( pPrior!=0 );
000168 p--;
000169 SQLITE_FREE(p);
000170 #endif
000171 }
000172
000173 /*
000174 ** Report the allocated size of a prior return from xMalloc()
000175 ** or xRealloc().
000176 */
000177 static int sqlite3MemSize(void *pPrior){
000178 #ifdef SQLITE_MALLOCSIZE
000179 assert( pPrior!=0 );
000180 return (int)SQLITE_MALLOCSIZE(pPrior);
000181 #else
000182 sqlite3_int64 *p;
000183 assert( pPrior!=0 );
000184 p = (sqlite3_int64*)pPrior;
000185 p--;
000186 return (int)p[0];
000187 #endif
000188 }
000189
000190 /*
000191 ** Like realloc(). Resize an allocation previously obtained from
000192 ** sqlite3MemMalloc().
000193 **
000194 ** For this low-level interface, we know that pPrior!=0. Cases where
000195 ** pPrior==0 while have been intercepted by higher-level routine and
000196 ** redirected to xMalloc. Similarly, we know that nByte>0 because
000197 ** cases where nByte<=0 will have been intercepted by higher-level
000198 ** routines and redirected to xFree.
000199 */
000200 static void *sqlite3MemRealloc(void *pPrior, int nByte){
000201 #ifdef SQLITE_MALLOCSIZE
000202 void *p = SQLITE_REALLOC(pPrior, nByte);
000203 if( p==0 ){
000204 testcase( sqlite3GlobalConfig.xLog!=0 );
000205 sqlite3_log(SQLITE_NOMEM,
000206 "failed memory resize %u to %u bytes",
000207 SQLITE_MALLOCSIZE(pPrior), nByte);
000208 }
000209 return p;
000210 #else
000211 sqlite3_int64 *p = (sqlite3_int64*)pPrior;
000212 assert( pPrior!=0 && nByte>0 );
000213 assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */
000214 p--;
000215 p = SQLITE_REALLOC(p, nByte+8 );
000216 if( p ){
000217 p[0] = nByte;
000218 p++;
000219 }else{
000220 testcase( sqlite3GlobalConfig.xLog!=0 );
000221 sqlite3_log(SQLITE_NOMEM,
000222 "failed memory resize %u to %u bytes",
000223 sqlite3MemSize(pPrior), nByte);
000224 }
000225 return (void*)p;
000226 #endif
000227 }
000228
000229 /*
000230 ** Round up a request size to the next valid allocation size.
000231 */
000232 static int sqlite3MemRoundup(int n){
000233 return ROUND8(n);
000234 }
000235
000236 /*
000237 ** Initialize this module.
000238 */
000239 static int sqlite3MemInit(void *NotUsed){
000240 #if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC)
000241 int cpuCount;
000242 size_t len;
000243 if( _sqliteZone_ ){
000244 return SQLITE_OK;
000245 }
000246 len = sizeof(cpuCount);
000247 /* One usually wants to use hw.activecpu for MT decisions, but not here */
000248 sysctlbyname("hw.ncpu", &cpuCount, &len, NULL, 0);
000249 if( cpuCount>1 ){
000250 /* defer MT decisions to system malloc */
000251 _sqliteZone_ = malloc_default_zone();
000252 }else{
000253 /* only 1 core, use our own zone to contention over global locks,
000254 ** e.g. we have our own dedicated locks */
000255 _sqliteZone_ = malloc_create_zone(4096, 0);
000256 malloc_set_zone_name(_sqliteZone_, "Sqlite_Heap");
000257 }
000258 #endif /* defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC) */
000259 UNUSED_PARAMETER(NotUsed);
000260 return SQLITE_OK;
000261 }
000262
000263 /*
000264 ** Deinitialize this module.
000265 */
000266 static void sqlite3MemShutdown(void *NotUsed){
000267 UNUSED_PARAMETER(NotUsed);
000268 return;
000269 }
000270
000271 /*
000272 ** This routine is the only routine in this file with external linkage.
000273 **
000274 ** Populate the low-level memory allocation function pointers in
000275 ** sqlite3GlobalConfig.m with pointers to the routines in this file.
000276 */
000277 void sqlite3MemSetDefault(void){
000278 static const sqlite3_mem_methods defaultMethods = {
000279 sqlite3MemMalloc,
000280 sqlite3MemFree,
000281 sqlite3MemRealloc,
000282 sqlite3MemSize,
000283 sqlite3MemRoundup,
000284 sqlite3MemInit,
000285 sqlite3MemShutdown,
000286 0
000287 };
000288 sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
000289 }
000290
000291 #endif /* SQLITE_SYSTEM_MALLOC */