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 #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 */
 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 intercepted and dealt with
 160 ** by higher-level routines.
 161 */
 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 */
 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 */
 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 */
 232 static int sqlite3MemRoundup(int n){
 233   return ROUND8(n);
 234 }
 235
 236 /*
 237 ** Initialize this module.
 238 */
 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.activecpu 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 */
 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 */
 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 */