sl@0: /*
sl@0: ** 2007 August 14
sl@0: **
sl@0: ** The author disclaims copyright to this source code.  In place of
sl@0: ** a legal notice, here is a blessing:
sl@0: **
sl@0: **    May you do good and not evil.
sl@0: **    May you find forgiveness for yourself and forgive others.
sl@0: **    May you share freely, never taking more than you give.
sl@0: **
sl@0: *************************************************************************
sl@0: ** This file contains the C functions that implement a memory
sl@0: ** allocation subsystem for use by SQLite.  
sl@0: **
sl@0: ** $Id: mem4.c,v 1.3 2008/06/18 17:09:10 danielk1977 Exp $
sl@0: */
sl@0: #include "sqliteInt.h"
sl@0: 
sl@0: /*
sl@0: ** This version of the memory allocator attempts to obtain memory
sl@0: ** from mmap() if the size of the allocation is close to the size
sl@0: ** of a virtual memory page.  If the size of the allocation is different
sl@0: ** from the virtual memory page size, then ordinary malloc() is used.
sl@0: ** Ordinary malloc is also used if space allocated to mmap() is
sl@0: ** exhausted.
sl@0: **
sl@0: ** Enable this memory allocation by compiling with -DSQLITE_MMAP_HEAP_SIZE=nnn
sl@0: ** where nnn is the maximum number of bytes of mmap-ed memory you want 
sl@0: ** to support.   This module may choose to use less memory than requested.
sl@0: **
sl@0: */
sl@0: #ifdef SQLITE_MMAP_HEAP_SIZE
sl@0: 
sl@0: /*
sl@0: ** This is a test version of the memory allocator that attempts to
sl@0: ** use mmap() and madvise() for allocations and frees of approximately
sl@0: ** the virtual memory page size.
sl@0: */
sl@0: #include <sys/types.h>
sl@0: #include <sys/mman.h>
sl@0: #include <errno.h>
sl@0: #include <unistd.h>
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** All of the static variables used by this module are collected
sl@0: ** into a single structure named "mem".  This is to keep the
sl@0: ** static variables organized and to reduce namespace pollution
sl@0: ** when this module is combined with other in the amalgamation.
sl@0: */
sl@0: static struct {
sl@0:   /*
sl@0:   ** The alarm callback and its arguments.  The mem.mutex lock will
sl@0:   ** be held while the callback is running.  Recursive calls into
sl@0:   ** the memory subsystem are allowed, but no new callbacks will be
sl@0:   ** issued.  The alarmBusy variable is set to prevent recursive
sl@0:   ** callbacks.
sl@0:   */
sl@0:   sqlite3_int64 alarmThreshold;
sl@0:   void (*alarmCallback)(void*, sqlite3_int64,int);
sl@0:   void *alarmArg;
sl@0:   int alarmBusy;
sl@0:   
sl@0:   /*
sl@0:   ** Mutex to control access to the memory allocation subsystem.
sl@0:   */
sl@0:   sqlite3_mutex *mutex;
sl@0:   
sl@0:   /*
sl@0:   ** Current allocation and high-water mark.
sl@0:   */
sl@0:   sqlite3_int64 nowUsed;
sl@0:   sqlite3_int64 mxUsed;
sl@0: 
sl@0:   /*
sl@0:   ** Current allocation and high-water marks for mmap allocated memory.
sl@0:   */
sl@0:   sqlite3_int64 nowUsedMMap;
sl@0:   sqlite3_int64 mxUsedMMap;
sl@0: 
sl@0:   /*
sl@0:   ** Size of a single mmap page.  Obtained from sysconf().
sl@0:   */
sl@0:   int szPage;
sl@0:   int mnPage;
sl@0: 
sl@0:   /*
sl@0:   ** The number of available mmap pages.
sl@0:   */
sl@0:   int nPage;
sl@0: 
sl@0:   /*
sl@0:   ** Index of the first free page.  0 means no pages have been freed.
sl@0:   */
sl@0:   int firstFree;
sl@0: 
sl@0:   /* First unused page on the top of the heap.
sl@0:   */
sl@0:   int firstUnused;
sl@0: 
sl@0:   /*
sl@0:   ** Bulk memory obtained from from mmap().
sl@0:   */
sl@0:   char *mmapHeap;   /* first byte of the heap */ 
sl@0: 
sl@0: } mem;
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Enter the mutex mem.mutex. Allocate it if it is not already allocated.
sl@0: ** The mmap() region is initialized the first time this routine is called.
sl@0: */
sl@0: static void memsys4Enter(void){
sl@0:   if( mem.mutex==0 ){
sl@0:     mem.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
sl@0:   }
sl@0:   sqlite3_mutex_enter(mem.mutex);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Attempt to free memory to the mmap heap.  This only works if
sl@0: ** the pointer p is within the range of memory addresses that
sl@0: ** comprise the mmap heap.  Return 1 if the memory was freed
sl@0: ** successfully.  Return 0 if the pointer is out of range.
sl@0: */
sl@0: static int mmapFree(void *p){
sl@0:   char *z;
sl@0:   int idx, *a;
sl@0:   if( mem.mmapHeap==MAP_FAILED || mem.nPage==0 ){
sl@0:     return 0;
sl@0:   }
sl@0:   z = (char*)p;
sl@0:   idx = (z - mem.mmapHeap)/mem.szPage;
sl@0:   if( idx<1 || idx>=mem.nPage ){
sl@0:     return 0;
sl@0:   }
sl@0:   a = (int*)mem.mmapHeap;
sl@0:   a[idx] = a[mem.firstFree];
sl@0:   mem.firstFree = idx;
sl@0:   mem.nowUsedMMap -= mem.szPage;
sl@0:   madvise(p, mem.szPage, MADV_DONTNEED);
sl@0:   return 1;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Attempt to allocate nBytes from the mmap heap.  Return a pointer
sl@0: ** to the allocated page.  Or, return NULL if the allocation fails.
sl@0: ** 
sl@0: ** The allocation will fail if nBytes is not the right size.
sl@0: ** Or, the allocation will fail if the mmap heap has been exhausted.
sl@0: */
sl@0: static void *mmapAlloc(int nBytes){
sl@0:   int idx = 0;
sl@0:   if( nBytes>mem.szPage || nBytes<mem.mnPage ){
sl@0:     return 0;
sl@0:   }
sl@0:   if( mem.nPage==0 ){
sl@0:     mem.szPage = sysconf(_SC_PAGE_SIZE);
sl@0:     mem.mnPage = mem.szPage - mem.szPage/10;
sl@0:     mem.nPage = SQLITE_MMAP_HEAP_SIZE/mem.szPage;
sl@0:     if( mem.nPage * sizeof(int) > mem.szPage ){
sl@0:       mem.nPage = mem.szPage/sizeof(int);
sl@0:     }
sl@0:     mem.mmapHeap =  mmap(0, mem.szPage*mem.nPage, PROT_WRITE|PROT_READ,
sl@0:                          MAP_ANONYMOUS|MAP_SHARED, -1, 0);
sl@0:     if( mem.mmapHeap==MAP_FAILED ){
sl@0:       mem.firstUnused = errno;
sl@0:     }else{
sl@0:       mem.firstUnused = 1;
sl@0:       mem.nowUsedMMap = mem.szPage;
sl@0:     }
sl@0:   }
sl@0:   if( mem.mmapHeap==MAP_FAILED ){
sl@0:     return 0;
sl@0:   }
sl@0:   if( mem.firstFree ){
sl@0:     int idx = mem.firstFree;
sl@0:     int *a = (int*)mem.mmapHeap;
sl@0:     mem.firstFree = a[idx];
sl@0:   }else if( mem.firstUnused<mem.nPage ){
sl@0:     idx = mem.firstUnused++;
sl@0:   }
sl@0:   if( idx ){
sl@0:     mem.nowUsedMMap += mem.szPage;
sl@0:     if( mem.nowUsedMMap>mem.mxUsedMMap ){
sl@0:       mem.mxUsedMMap = mem.nowUsedMMap;
sl@0:     }
sl@0:     return (void*)&mem.mmapHeap[idx*mem.szPage];
sl@0:   }else{
sl@0:     return 0;
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Release the mmap-ed memory region if it is currently allocated and
sl@0: ** is not in use.
sl@0: */
sl@0: static void mmapUnmap(void){
sl@0:   if( mem.mmapHeap==MAP_FAILED ) return;
sl@0:   if( mem.nPage==0 ) return;
sl@0:   if( mem.nowUsedMMap>mem.szPage ) return;
sl@0:   munmap(mem.mmapHeap, mem.nPage*mem.szPage);
sl@0:   mem.nowUsedMMap = 0;
sl@0:   mem.nPage = 0;
sl@0: }
sl@0:     
sl@0: 
sl@0: /*
sl@0: ** Return the amount of memory currently checked out.
sl@0: */
sl@0: sqlite3_int64 sqlite3_memory_used(void){
sl@0:   sqlite3_int64 n;
sl@0:   memsys4Enter();
sl@0:   n = mem.nowUsed + mem.nowUsedMMap;
sl@0:   sqlite3_mutex_leave(mem.mutex);  
sl@0:   return n;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the maximum amount of memory that has ever been
sl@0: ** checked out since either the beginning of this process
sl@0: ** or since the most recent reset.
sl@0: */
sl@0: sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
sl@0:   sqlite3_int64 n;
sl@0:   memsys4Enter();
sl@0:   n = mem.mxUsed + mem.mxUsedMMap;
sl@0:   if( resetFlag ){
sl@0:     mem.mxUsed = mem.nowUsed;
sl@0:     mem.mxUsedMMap = mem.nowUsedMMap;
sl@0:   }
sl@0:   sqlite3_mutex_leave(mem.mutex);  
sl@0:   return n;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Change the alarm callback
sl@0: */
sl@0: int sqlite3_memory_alarm(
sl@0:   void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
sl@0:   void *pArg,
sl@0:   sqlite3_int64 iThreshold
sl@0: ){
sl@0:   memsys4Enter();
sl@0:   mem.alarmCallback = xCallback;
sl@0:   mem.alarmArg = pArg;
sl@0:   mem.alarmThreshold = iThreshold;
sl@0:   sqlite3_mutex_leave(mem.mutex);
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Trigger the alarm 
sl@0: */
sl@0: static void sqlite3MemsysAlarm(int nByte){
sl@0:   void (*xCallback)(void*,sqlite3_int64,int);
sl@0:   sqlite3_int64 nowUsed;
sl@0:   void *pArg;
sl@0:   if( mem.alarmCallback==0 || mem.alarmBusy  ) return;
sl@0:   mem.alarmBusy = 1;
sl@0:   xCallback = mem.alarmCallback;
sl@0:   nowUsed = mem.nowUsed;
sl@0:   pArg = mem.alarmArg;
sl@0:   sqlite3_mutex_leave(mem.mutex);
sl@0:   xCallback(pArg, nowUsed, nByte);
sl@0:   sqlite3_mutex_enter(mem.mutex);
sl@0:   mem.alarmBusy = 0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Allocate nBytes of memory
sl@0: */
sl@0: static void *memsys4Malloc(int nBytes){
sl@0:   sqlite3_int64 *p = 0;
sl@0:   if( mem.alarmCallback!=0
sl@0:          && mem.nowUsed+mem.nowUsedMMap+nBytes>=mem.alarmThreshold ){
sl@0:     sqlite3MemsysAlarm(nBytes);
sl@0:   }
sl@0:   if( (p = mmapAlloc(nBytes))==0 ){
sl@0:     p = malloc(nBytes+8);
sl@0:     if( p==0 ){
sl@0:       sqlite3MemsysAlarm(nBytes);
sl@0:       p = malloc(nBytes+8);
sl@0:     }
sl@0:     if( p ){
sl@0:       p[0] = nBytes;
sl@0:       p++;
sl@0:       mem.nowUsed += nBytes;
sl@0:       if( mem.nowUsed>mem.mxUsed ){
sl@0:         mem.mxUsed = mem.nowUsed;
sl@0:       }
sl@0:     }
sl@0:   }
sl@0:   return (void*)p; 
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the size of a memory allocation
sl@0: */
sl@0: static int memsys4Size(void *pPrior){
sl@0:   char *z = (char*)pPrior;
sl@0:   int idx = mem.nPage ? (z - mem.mmapHeap)/mem.szPage : 0;
sl@0:   int nByte;
sl@0:   if( idx>=1 && idx<mem.nPage ){
sl@0:     nByte = mem.szPage;
sl@0:   }else{
sl@0:     sqlite3_int64 *p = pPrior;
sl@0:     p--;
sl@0:     nByte = (int)*p;
sl@0:   }
sl@0:   return nByte;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Free memory.
sl@0: */
sl@0: static void memsys4Free(void *pPrior){
sl@0:   sqlite3_int64 *p;
sl@0:   int nByte;
sl@0:   if( mmapFree(pPrior)==0 ){
sl@0:     p = pPrior;
sl@0:     p--;
sl@0:     nByte = (int)*p;
sl@0:     mem.nowUsed -= nByte;
sl@0:     free(p);
sl@0:     if( mem.nowUsed==0 ){
sl@0:       mmapUnmap();
sl@0:     }      
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Allocate nBytes of memory
sl@0: */
sl@0: void *sqlite3_malloc(int nBytes){
sl@0:   sqlite3_int64 *p = 0;
sl@0:   if( nBytes>0 ){
sl@0:     memsys4Enter();
sl@0:     p = memsys4Malloc(nBytes);
sl@0:     sqlite3_mutex_leave(mem.mutex);
sl@0:   }
sl@0:   return (void*)p; 
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Free memory.
sl@0: */
sl@0: void sqlite3_free(void *pPrior){
sl@0:   if( pPrior==0 ){
sl@0:     return;
sl@0:   }
sl@0:   assert( mem.mutex!=0 );
sl@0:   sqlite3_mutex_enter(mem.mutex);
sl@0:   memsys4Free(pPrior);
sl@0:   sqlite3_mutex_leave(mem.mutex);  
sl@0: }
sl@0: 
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Change the size of an existing memory allocation
sl@0: */
sl@0: void *sqlite3_realloc(void *pPrior, int nBytes){
sl@0:   int nOld;
sl@0:   sqlite3_int64 *p;
sl@0:   if( pPrior==0 ){
sl@0:     return sqlite3_malloc(nBytes);
sl@0:   }
sl@0:   if( nBytes<=0 ){
sl@0:     sqlite3_free(pPrior);
sl@0:     return 0;
sl@0:   }
sl@0:   nOld = memsys4Size(pPrior);
sl@0:   if( nBytes<=nOld && nBytes>=nOld-128 ){
sl@0:     return pPrior;
sl@0:   }
sl@0:   assert( mem.mutex!=0 );
sl@0:   sqlite3_mutex_enter(mem.mutex);
sl@0:   p = memsys4Malloc(nBytes);
sl@0:   if( p ){
sl@0:     if( nOld<nBytes ){
sl@0:       memcpy(p, pPrior, nOld);
sl@0:     }else{
sl@0:       memcpy(p, pPrior, nBytes);
sl@0:     }
sl@0:     memsys4Free(pPrior);
sl@0:   }
sl@0:   assert( mem.mutex!=0 );
sl@0:   sqlite3_mutex_leave(mem.mutex);
sl@0:   return (void*)p;
sl@0: }
sl@0: 
sl@0: #endif /* SQLITE_MMAP_HEAP_SIZE */