| OLD | NEW |
|---|
| (Empty) |
| 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 #include <libkern/OSAtomic.h> | |
| 61 static malloc_zone_t* _sqliteZone_; | |
| 62 #define SQLITE_MALLOC(x) malloc_zone_malloc(_sqliteZone_, (x)) | |
| 63 #define SQLITE_FREE(x) malloc_zone_free(_sqliteZone_, (x)); | |
| 64 #define SQLITE_REALLOC(x,y) malloc_zone_realloc(_sqliteZone_, (x), (y)) | |
| 65 #define SQLITE_MALLOCSIZE(x) \ | |
| 66 (_sqliteZone_ ? _sqliteZone_->size(_sqliteZone_,x) : malloc_size(x)) | |
| 67 | |
| 68 #else /* if not __APPLE__ */ | |
| 69 | |
| 70 /* | |
| 71 ** Use standard C library malloc and free on non-Apple systems. | |
| 72 ** Also used by Apple systems if SQLITE_WITHOUT_ZONEMALLOC is defined. | |
| 73 */ | |
| 74 #define SQLITE_MALLOC(x) malloc(x) | |
| 75 #define SQLITE_FREE(x) free(x) | |
| 76 #define SQLITE_REALLOC(x,y) realloc((x),(y)) | |
| 77 | |
| 78 /* | |
| 79 ** The malloc.h header file is needed for malloc_usable_size() function | |
| 80 ** on some systems (e.g. Linux). | |
| 81 */ | |
| 82 #if HAVE_MALLOC_H && HAVE_MALLOC_USABLE_SIZE | |
| 83 # define SQLITE_USE_MALLOC_H 1 | |
| 84 # define SQLITE_USE_MALLOC_USABLE_SIZE 1 | |
| 85 /* | |
| 86 ** The MSVCRT has malloc_usable_size(), but it is called _msize(). The | |
| 87 ** use of _msize() is automatic, but can be disabled by compiling with | |
| 88 ** -DSQLITE_WITHOUT_MSIZE. Using the _msize() function also requires | |
| 89 ** the malloc.h header file. | |
| 90 */ | |
| 91 #elif defined(_MSC_VER) && !defined(SQLITE_WITHOUT_MSIZE) | |
| 92 # define SQLITE_USE_MALLOC_H | |
| 93 # define SQLITE_USE_MSIZE | |
| 94 #endif | |
| 95 | |
| 96 /* | |
| 97 ** Include the malloc.h header file, if necessary. Also set define macro | |
| 98 ** SQLITE_MALLOCSIZE to the appropriate function name, which is _msize() | |
| 99 ** for MSVC and malloc_usable_size() for most other systems (e.g. Linux). | |
| 100 ** The memory size function can always be overridden manually by defining | |
| 101 ** the macro SQLITE_MALLOCSIZE to the desired function name. | |
| 102 */ | |
| 103 #if defined(SQLITE_USE_MALLOC_H) | |
| 104 # include <malloc.h> | |
| 105 # if defined(SQLITE_USE_MALLOC_USABLE_SIZE) | |
| 106 # if !defined(SQLITE_MALLOCSIZE) | |
| 107 # define SQLITE_MALLOCSIZE(x) malloc_usable_size(x) | |
| 108 # endif | |
| 109 # elif defined(SQLITE_USE_MSIZE) | |
| 110 # if !defined(SQLITE_MALLOCSIZE) | |
| 111 # define SQLITE_MALLOCSIZE _msize | |
| 112 # endif | |
| 113 # endif | |
| 114 #endif /* defined(SQLITE_USE_MALLOC_H) */ | |
| 115 | |
| 116 #endif /* __APPLE__ or not __APPLE__ */ | |
| 117 | |
| 118 /* | |
| 119 ** Like malloc(), but remember the size of the allocation | |
| 120 ** so that we can find it later using sqlite3MemSize(). | |
| 121 ** | |
| 122 ** For this low-level routine, we are guaranteed that nByte>0 because | |
| 123 ** cases of nByte<=0 will be intercepted and dealt with by higher level | |
| 124 ** routines. | |
| 125 */ | |
| 126 static void *sqlite3MemMalloc(int nByte){ | |
| 127 #ifdef SQLITE_MALLOCSIZE | |
| 128 void *p = SQLITE_MALLOC( nByte ); | |
| 129 if( p==0 ){ | |
| 130 testcase( sqlite3GlobalConfig.xLog!=0 ); | |
| 131 sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte); | |
| 132 } | |
| 133 return p; | |
| 134 #else | |
| 135 sqlite3_int64 *p; | |
| 136 assert( nByte>0 ); | |
| 137 nByte = ROUND8(nByte); | |
| 138 p = SQLITE_MALLOC( nByte+8 ); | |
| 139 if( p ){ | |
| 140 p[0] = nByte; | |
| 141 p++; | |
| 142 }else{ | |
| 143 testcase( sqlite3GlobalConfig.xLog!=0 ); | |
| 144 sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte); | |
| 145 } | |
| 146 return (void *)p; | |
| 147 #endif | |
| 148 } | |
| 149 | |
| 150 /* | |
| 151 ** Like free() but works for allocations obtained from sqlite3MemMalloc() | |
| 152 ** or sqlite3MemRealloc(). | |
| 153 ** | |
| 154 ** For this low-level routine, we already know that pPrior!=0 since | |
| 155 ** cases where pPrior==0 will have been intecepted and dealt with | |
| 156 ** by higher-level routines. | |
| 157 */ | |
| 158 static void sqlite3MemFree(void *pPrior){ | |
| 159 #ifdef SQLITE_MALLOCSIZE | |
| 160 SQLITE_FREE(pPrior); | |
| 161 #else | |
| 162 sqlite3_int64 *p = (sqlite3_int64*)pPrior; | |
| 163 assert( pPrior!=0 ); | |
| 164 p--; | |
| 165 SQLITE_FREE(p); | |
| 166 #endif | |
| 167 } | |
| 168 | |
| 169 /* | |
| 170 ** Report the allocated size of a prior return from xMalloc() | |
| 171 ** or xRealloc(). | |
| 172 */ | |
| 173 static int sqlite3MemSize(void *pPrior){ | |
| 174 #ifdef SQLITE_MALLOCSIZE | |
| 175 assert( pPrior!=0 ); | |
| 176 return (int)SQLITE_MALLOCSIZE(pPrior); | |
| 177 #else | |
| 178 sqlite3_int64 *p; | |
| 179 assert( pPrior!=0 ); | |
| 180 p = (sqlite3_int64*)pPrior; | |
| 181 p--; | |
| 182 return (int)p[0]; | |
| 183 #endif | |
| 184 } | |
| 185 | |
| 186 /* | |
| 187 ** Like realloc(). Resize an allocation previously obtained from | |
| 188 ** sqlite3MemMalloc(). | |
| 189 ** | |
| 190 ** For this low-level interface, we know that pPrior!=0. Cases where | |
| 191 ** pPrior==0 while have been intercepted by higher-level routine and | |
| 192 ** redirected to xMalloc. Similarly, we know that nByte>0 because | |
| 193 ** cases where nByte<=0 will have been intercepted by higher-level | |
| 194 ** routines and redirected to xFree. | |
| 195 */ | |
| 196 static void *sqlite3MemRealloc(void *pPrior, int nByte){ | |
| 197 #ifdef SQLITE_MALLOCSIZE | |
| 198 void *p = SQLITE_REALLOC(pPrior, nByte); | |
| 199 if( p==0 ){ | |
| 200 testcase( sqlite3GlobalConfig.xLog!=0 ); | |
| 201 sqlite3_log(SQLITE_NOMEM, | |
| 202 "failed memory resize %u to %u bytes", | |
| 203 SQLITE_MALLOCSIZE(pPrior), nByte); | |
| 204 } | |
| 205 return p; | |
| 206 #else | |
| 207 sqlite3_int64 *p = (sqlite3_int64*)pPrior; | |
| 208 assert( pPrior!=0 && nByte>0 ); | |
| 209 assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */ | |
| 210 p--; | |
| 211 p = SQLITE_REALLOC(p, nByte+8 ); | |
| 212 if( p ){ | |
| 213 p[0] = nByte; | |
| 214 p++; | |
| 215 }else{ | |
| 216 testcase( sqlite3GlobalConfig.xLog!=0 ); | |
| 217 sqlite3_log(SQLITE_NOMEM, | |
| 218 "failed memory resize %u to %u bytes", | |
| 219 sqlite3MemSize(pPrior), nByte); | |
| 220 } | |
| 221 return (void*)p; | |
| 222 #endif | |
| 223 } | |
| 224 | |
| 225 /* | |
| 226 ** Round up a request size to the next valid allocation size. | |
| 227 */ | |
| 228 static int sqlite3MemRoundup(int n){ | |
| 229 return ROUND8(n); | |
| 230 } | |
| 231 | |
| 232 /* | |
| 233 ** Initialize this module. | |
| 234 */ | |
| 235 static int sqlite3MemInit(void *NotUsed){ | |
| 236 #if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC) | |
| 237 int cpuCount; | |
| 238 size_t len; | |
| 239 if( _sqliteZone_ ){ | |
| 240 return SQLITE_OK; | |
| 241 } | |
| 242 len = sizeof(cpuCount); | |
| 243 /* One usually wants to use hw.acctivecpu for MT decisions, but not here */ | |
| 244 sysctlbyname("hw.ncpu", &cpuCount, &len, NULL, 0); | |
| 245 if( cpuCount>1 ){ | |
| 246 /* defer MT decisions to system malloc */ | |
| 247 _sqliteZone_ = malloc_default_zone(); | |
| 248 }else{ | |
| 249 /* only 1 core, use our own zone to contention over global locks, | |
| 250 ** e.g. we have our own dedicated locks */ | |
| 251 bool success; | |
| 252 malloc_zone_t* newzone = malloc_create_zone(4096, 0); | |
| 253 malloc_set_zone_name(newzone, "Sqlite_Heap"); | |
| 254 do{ | |
| 255 success = OSAtomicCompareAndSwapPtrBarrier(NULL, newzone, | |
| 256 (void * volatile *)&_sqliteZone_); | |
| 257 }while(!_sqliteZone_); | |
| 258 if( !success ){ | |
| 259 /* somebody registered a zone first */ | |
| 260 malloc_destroy_zone(newzone); | |
| 261 } | |
| 262 } | |
| 263 #endif | |
| 264 UNUSED_PARAMETER(NotUsed); | |
| 265 return SQLITE_OK; | |
| 266 } | |
| 267 | |
| 268 /* | |
| 269 ** Deinitialize this module. | |
| 270 */ | |
| 271 static void sqlite3MemShutdown(void *NotUsed){ | |
| 272 UNUSED_PARAMETER(NotUsed); | |
| 273 return; | |
| 274 } | |
| 275 | |
| 276 /* | |
| 277 ** This routine is the only routine in this file with external linkage. | |
| 278 ** | |
| 279 ** Populate the low-level memory allocation function pointers in | |
| 280 ** sqlite3GlobalConfig.m with pointers to the routines in this file. | |
| 281 */ | |
| 282 void sqlite3MemSetDefault(void){ | |
| 283 static const sqlite3_mem_methods defaultMethods = { | |
| 284 sqlite3MemMalloc, | |
| 285 sqlite3MemFree, | |
| 286 sqlite3MemRealloc, | |
| 287 sqlite3MemSize, | |
| 288 sqlite3MemRoundup, | |
| 289 sqlite3MemInit, | |
| 290 sqlite3MemShutdown, | |
| 291 0 | |
| 292 }; | |
| 293 sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods); | |
| 294 } | |
| 295 | |
| 296 #endif /* SQLITE_SYSTEM_MALLOC */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2846743003:
[sql] Remove SQLite 3.10.2 reference directory. (Closed)
