Annotation of embedaddon/sqlite3/src/mem1.c, revision 1.1
1.1 ! misho 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.
! 19: */
! 20: #include "sqliteInt.h"
! 21:
! 22: /*
! 23: ** This version of the memory allocator is the default. It is
! 24: ** used when no other memory allocator is specified using compile-time
! 25: ** macros.
! 26: */
! 27: #ifdef SQLITE_SYSTEM_MALLOC
! 28:
! 29: /*
! 30: ** Windows systems have malloc_usable_size() but it is called _msize()
! 31: */
! 32: #if !defined(HAVE_MALLOC_USABLE_SIZE) && SQLITE_OS_WIN
! 33: # define HAVE_MALLOC_USABLE_SIZE 1
! 34: # define malloc_usable_size _msize
! 35: #endif
! 36:
! 37: #if defined(__APPLE__)
! 38:
! 39: /*
! 40: ** Use the zone allocator available on apple products
! 41: */
! 42: #include <sys/sysctl.h>
! 43: #include <malloc/malloc.h>
! 44: #include <libkern/OSAtomic.h>
! 45: static malloc_zone_t* _sqliteZone_;
! 46: #define SQLITE_MALLOC(x) malloc_zone_malloc(_sqliteZone_, (x))
! 47: #define SQLITE_FREE(x) malloc_zone_free(_sqliteZone_, (x));
! 48: #define SQLITE_REALLOC(x,y) malloc_zone_realloc(_sqliteZone_, (x), (y))
! 49: #define SQLITE_MALLOCSIZE(x) \
! 50: (_sqliteZone_ ? _sqliteZone_->size(_sqliteZone_,x) : malloc_size(x))
! 51:
! 52: #else /* if not __APPLE__ */
! 53:
! 54: /*
! 55: ** Use standard C library malloc and free on non-Apple systems.
! 56: */
! 57: #define SQLITE_MALLOC(x) malloc(x)
! 58: #define SQLITE_FREE(x) free(x)
! 59: #define SQLITE_REALLOC(x,y) realloc((x),(y))
! 60:
! 61: #ifdef HAVE_MALLOC_USABLE_SIZE
! 62: #include <malloc.h>
! 63: #define SQLITE_MALLOCSIZE(x) malloc_usable_size(x)
! 64: #else
! 65: #undef SQLITE_MALLOCSIZE
! 66: #endif
! 67:
! 68: #endif /* __APPLE__ or not __APPLE__ */
! 69:
! 70: /*
! 71: ** Like malloc(), but remember the size of the allocation
! 72: ** so that we can find it later using sqlite3MemSize().
! 73: **
! 74: ** For this low-level routine, we are guaranteed that nByte>0 because
! 75: ** cases of nByte<=0 will be intercepted and dealt with by higher level
! 76: ** routines.
! 77: */
! 78: static void *sqlite3MemMalloc(int nByte){
! 79: #ifdef SQLITE_MALLOCSIZE
! 80: void *p = SQLITE_MALLOC( nByte );
! 81: if( p==0 ){
! 82: testcase( sqlite3GlobalConfig.xLog!=0 );
! 83: sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
! 84: }
! 85: return p;
! 86: #else
! 87: sqlite3_int64 *p;
! 88: assert( nByte>0 );
! 89: nByte = ROUND8(nByte);
! 90: p = SQLITE_MALLOC( nByte+8 );
! 91: if( p ){
! 92: p[0] = nByte;
! 93: p++;
! 94: }else{
! 95: testcase( sqlite3GlobalConfig.xLog!=0 );
! 96: sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
! 97: }
! 98: return (void *)p;
! 99: #endif
! 100: }
! 101:
! 102: /*
! 103: ** Like free() but works for allocations obtained from sqlite3MemMalloc()
! 104: ** or sqlite3MemRealloc().
! 105: **
! 106: ** For this low-level routine, we already know that pPrior!=0 since
! 107: ** cases where pPrior==0 will have been intecepted and dealt with
! 108: ** by higher-level routines.
! 109: */
! 110: static void sqlite3MemFree(void *pPrior){
! 111: #ifdef SQLITE_MALLOCSIZE
! 112: SQLITE_FREE(pPrior);
! 113: #else
! 114: sqlite3_int64 *p = (sqlite3_int64*)pPrior;
! 115: assert( pPrior!=0 );
! 116: p--;
! 117: SQLITE_FREE(p);
! 118: #endif
! 119: }
! 120:
! 121: /*
! 122: ** Report the allocated size of a prior return from xMalloc()
! 123: ** or xRealloc().
! 124: */
! 125: static int sqlite3MemSize(void *pPrior){
! 126: #ifdef SQLITE_MALLOCSIZE
! 127: return pPrior ? (int)SQLITE_MALLOCSIZE(pPrior) : 0;
! 128: #else
! 129: sqlite3_int64 *p;
! 130: if( pPrior==0 ) return 0;
! 131: p = (sqlite3_int64*)pPrior;
! 132: p--;
! 133: return (int)p[0];
! 134: #endif
! 135: }
! 136:
! 137: /*
! 138: ** Like realloc(). Resize an allocation previously obtained from
! 139: ** sqlite3MemMalloc().
! 140: **
! 141: ** For this low-level interface, we know that pPrior!=0. Cases where
! 142: ** pPrior==0 while have been intercepted by higher-level routine and
! 143: ** redirected to xMalloc. Similarly, we know that nByte>0 becauses
! 144: ** cases where nByte<=0 will have been intercepted by higher-level
! 145: ** routines and redirected to xFree.
! 146: */
! 147: static void *sqlite3MemRealloc(void *pPrior, int nByte){
! 148: #ifdef SQLITE_MALLOCSIZE
! 149: void *p = SQLITE_REALLOC(pPrior, nByte);
! 150: if( p==0 ){
! 151: testcase( sqlite3GlobalConfig.xLog!=0 );
! 152: sqlite3_log(SQLITE_NOMEM,
! 153: "failed memory resize %u to %u bytes",
! 154: SQLITE_MALLOCSIZE(pPrior), nByte);
! 155: }
! 156: return p;
! 157: #else
! 158: sqlite3_int64 *p = (sqlite3_int64*)pPrior;
! 159: assert( pPrior!=0 && nByte>0 );
! 160: assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */
! 161: p--;
! 162: p = SQLITE_REALLOC(p, nByte+8 );
! 163: if( p ){
! 164: p[0] = nByte;
! 165: p++;
! 166: }else{
! 167: testcase( sqlite3GlobalConfig.xLog!=0 );
! 168: sqlite3_log(SQLITE_NOMEM,
! 169: "failed memory resize %u to %u bytes",
! 170: sqlite3MemSize(pPrior), nByte);
! 171: }
! 172: return (void*)p;
! 173: #endif
! 174: }
! 175:
! 176: /*
! 177: ** Round up a request size to the next valid allocation size.
! 178: */
! 179: static int sqlite3MemRoundup(int n){
! 180: return ROUND8(n);
! 181: }
! 182:
! 183: /*
! 184: ** Initialize this module.
! 185: */
! 186: static int sqlite3MemInit(void *NotUsed){
! 187: #if defined(__APPLE__)
! 188: int cpuCount;
! 189: size_t len;
! 190: if( _sqliteZone_ ){
! 191: return SQLITE_OK;
! 192: }
! 193: len = sizeof(cpuCount);
! 194: /* One usually wants to use hw.acctivecpu for MT decisions, but not here */
! 195: sysctlbyname("hw.ncpu", &cpuCount, &len, NULL, 0);
! 196: if( cpuCount>1 ){
! 197: /* defer MT decisions to system malloc */
! 198: _sqliteZone_ = malloc_default_zone();
! 199: }else{
! 200: /* only 1 core, use our own zone to contention over global locks,
! 201: ** e.g. we have our own dedicated locks */
! 202: bool success;
! 203: malloc_zone_t* newzone = malloc_create_zone(4096, 0);
! 204: malloc_set_zone_name(newzone, "Sqlite_Heap");
! 205: do{
! 206: success = OSAtomicCompareAndSwapPtrBarrier(NULL, newzone,
! 207: (void * volatile *)&_sqliteZone_);
! 208: }while(!_sqliteZone_);
! 209: if( !success ){
! 210: /* somebody registered a zone first */
! 211: malloc_destroy_zone(newzone);
! 212: }
! 213: }
! 214: #endif
! 215: UNUSED_PARAMETER(NotUsed);
! 216: return SQLITE_OK;
! 217: }
! 218:
! 219: /*
! 220: ** Deinitialize this module.
! 221: */
! 222: static void sqlite3MemShutdown(void *NotUsed){
! 223: UNUSED_PARAMETER(NotUsed);
! 224: return;
! 225: }
! 226:
! 227: /*
! 228: ** This routine is the only routine in this file with external linkage.
! 229: **
! 230: ** Populate the low-level memory allocation function pointers in
! 231: ** sqlite3GlobalConfig.m with pointers to the routines in this file.
! 232: */
! 233: void sqlite3MemSetDefault(void){
! 234: static const sqlite3_mem_methods defaultMethods = {
! 235: sqlite3MemMalloc,
! 236: sqlite3MemFree,
! 237: sqlite3MemRealloc,
! 238: sqlite3MemSize,
! 239: sqlite3MemRoundup,
! 240: sqlite3MemInit,
! 241: sqlite3MemShutdown,
! 242: 0
! 243: };
! 244: sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
! 245: }
! 246:
! 247: #endif /* SQLITE_SYSTEM_MALLOC */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mem1.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src