src/mem1.c

   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   return pPrior ? (int)SQLITE_MALLOCSIZE(pPrior) : 0;
 176 #else
 177   sqlite3_int64 *p;
 178   if( pPrior==0 ) return 0;
 179   p = (sqlite3_int64*)pPrior;
 180   p--;
 181   return (int)p[0];
 182 #endif
 183 }
 184
 185 /*
 186 ** Like realloc().  Resize an allocation previously obtained from
 187 ** sqlite3MemMalloc().
 188 **
 189 ** For this low-level interface, we know that pPrior!=0.  Cases where
 190 ** pPrior==0 while have been intercepted by higher-level routine and
 191 ** redirected to xMalloc.  Similarly, we know that nByte>0 because
 192 ** cases where nByte<=0 will have been intercepted by higher-level
 193 ** routines and redirected to xFree.
 194 */
 195 static void *sqlite3MemRealloc(void *pPrior, int nByte){
 196 #ifdef SQLITE_MALLOCSIZE
 197   void *p = SQLITE_REALLOC(pPrior, nByte);
 198   if( p==0 ){
 199     testcase( sqlite3GlobalConfig.xLog!=0 );
 200     sqlite3_log(SQLITE_NOMEM,
 201       "failed memory resize %u to %u bytes",
 202       SQLITE_MALLOCSIZE(pPrior), nByte);
 203   }
 204   return p;
 205 #else
 206   sqlite3_int64 *p = (sqlite3_int64*)pPrior;
 207   assert( pPrior!=0 && nByte>0 );
 208   assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */
 209   p--;
 210   p = SQLITE_REALLOC(p, nByte+8 );
 211   if( p ){
 212     p[0] = nByte;
 213     p++;
 214   }else{
 215     testcase( sqlite3GlobalConfig.xLog!=0 );
 216     sqlite3_log(SQLITE_NOMEM,
 217       "failed memory resize %u to %u bytes",
 218       sqlite3MemSize(pPrior), nByte);
 219   }
 220   return (void*)p;
 221 #endif
 222 }
 223
 224 /*
 225 ** Round up a request size to the next valid allocation size.
 226 */
 227 static int sqlite3MemRoundup(int n){
 228   return ROUND8(n);
 229 }
 230
 231 /*
 232 ** Initialize this module.
 233 */
 234 static int sqlite3MemInit(void *NotUsed){
 235 #if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC)
 236   int cpuCount;
 237   size_t len;
 238   if( _sqliteZone_ ){
 239     return SQLITE_OK;
 240   }
 241   len = sizeof(cpuCount);
 242   /* One usually wants to use hw.acctivecpu for MT decisions, but not here */
 243   sysctlbyname("hw.ncpu", &cpuCount, &len, NULL, 0);
 244   if( cpuCount>1 ){
 245     /* defer MT decisions to system malloc */
 246     _sqliteZone_ = malloc_default_zone();
 247   }else{
 248     /* only 1 core, use our own zone to contention over global locks,
 249     ** e.g. we have our own dedicated locks */
 250     bool success;
 251     malloc_zone_t* newzone = malloc_create_zone(4096, 0);
 252     malloc_set_zone_name(newzone, "Sqlite_Heap");
 253     do{
 254       success = OSAtomicCompareAndSwapPtrBarrier(NULL, newzone,
 255                                  (void * volatile *)&_sqliteZone_);
 256     }while(!_sqliteZone_);
 257     if( !success ){
 258       /* somebody registered a zone first */
 259       malloc_destroy_zone(newzone);
 260     }
 261   }
 262 #endif
 263   UNUSED_PARAMETER(NotUsed);
 264   return SQLITE_OK;
 265 }
 266
 267 /*
 268 ** Deinitialize this module.
 269 */
 270 static void sqlite3MemShutdown(void *NotUsed){
 271   UNUSED_PARAMETER(NotUsed);
 272   return;
 273 }
 274
 275 /*
 276 ** This routine is the only routine in this file with external linkage.
 277 **
 278 ** Populate the low-level memory allocation function pointers in
 279 ** sqlite3GlobalConfig.m with pointers to the routines in this file.
 280 */
 281 void sqlite3MemSetDefault(void){
 282   static const sqlite3_mem_methods defaultMethods = {
 283      sqlite3MemMalloc,
 284      sqlite3MemFree,
 285      sqlite3MemRealloc,
 286      sqlite3MemSize,
 287      sqlite3MemRoundup,
 288      sqlite3MemInit,
 289      sqlite3MemShutdown,
 290      0
 291   };
 292   sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
 293 }
 294
 295 #endif /* SQLITE_SYSTEM_MALLOC */