/*

 ** 2007 August 14

 **

 ** The author disclaims copyright to this source code.  In place of

 ** a legal notice, here is a blessing:

 **

 **    May you do good and not evil.

 **    May you find forgiveness for yourself and forgive others.

 **    May you share freely, never taking more than you give.

 **

 *************************************************************************

 ** This file contains the C functions that implement a memory

 ** allocation subsystem for use by SQLite.  

 **

 ** $Id$

 */

 /*

 ** This version of the memory allocator is the default.  It is

 ** used when no other memory allocator is specified using compile-time

 ** macros.

 */

 #if !defined(SQLITE_MEMDEBUG) && !defined(SQLITE_OMIT_MEMORY_ALLOCATION)

 /*

 ** We will eventually construct multiple memory allocation subsystems

 ** suitable for use in various contexts:

 **

 **    *  Normal multi-threaded builds

 **    *  Normal single-threaded builds

 **    *  Debugging builds

 **

 ** This initial version is suitable for use in normal multi-threaded

 ** builds.  We envision that alternative versions will be stored in

 ** separate source files.  #ifdefs will be used to select the code from

 ** one of the various memN.c source files for use in any given build.

 */

 #include "sqliteInt.h"

 /*

 ** All of the static variables used by this module are collected

 ** into a single structure named "mem".  This is to keep the

 ** static variables organized and to reduce namespace pollution

 ** when this module is combined with other in the amalgamation.

 */

 static struct {

   /*

   ** The alarm callback and its arguments.  The mem.mutex lock will

   ** be held while the callback is running.  Recursive calls into

   ** the memory subsystem are allowed, but no new callbacks will be

   ** issued.  The alarmBusy variable is set to prevent recursive

   ** callbacks.

   */

   sqlite3_int64 alarmThreshold;

   void (*alarmCallback)(void*, sqlite3_int64,int);

   void *alarmArg;

   int alarmBusy;

   /*

   ** Mutex to control access to the memory allocation subsystem.

   */

   sqlite3_mutex *mutex;

   /*

   ** Current allocation and high-water mark.

   */

   sqlite3_int64 nowUsed;

   sqlite3_int64 mxUsed;

 } mem;

 /*

 ** Enter the mutex mem.mutex. Allocate it if it is not already allocated.

 */

 static void enterMem(void){

   if( mem.mutex==0 ){

     mem.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM);

   }

   sqlite3_mutex_enter(mem.mutex);

 }

 /*

 ** Return the amount of memory currently checked out.

 */

 sqlite3_int64 sqlite3_memory_used(void){

   sqlite3_int64 n;

   enterMem();

   n = mem.nowUsed;

   sqlite3_mutex_leave(mem.mutex);  

   return n;

 }

 /*

 ** Return the maximum amount of memory that has ever been

 ** checked out since either the beginning of this process

 ** or since the most recent reset.

 */

 sqlite3_int64 sqlite3_memory_highwater(int resetFlag){

   sqlite3_int64 n;

   enterMem();

   n = mem.mxUsed;

   if( resetFlag ){

     mem.mxUsed = mem.nowUsed;

   }

   sqlite3_mutex_leave(mem.mutex);  

   return n;

 }

 /*

 ** Change the alarm callback

 */

 int sqlite3_memory_alarm(

   void(*xCallback)(void *pArg, sqlite3_int64 used,int N),

   void *pArg,

   sqlite3_int64 iThreshold

 ){

   enterMem();

   mem.alarmCallback = xCallback;

   mem.alarmArg = pArg;

   mem.alarmThreshold = iThreshold;

   sqlite3_mutex_leave(mem.mutex);

   return SQLITE_OK;

 }

 /*

 ** Trigger the alarm 

 */

 static void sqlite3MemsysAlarm(int nByte){

   void (*xCallback)(void*,sqlite3_int64,int);

   sqlite3_int64 nowUsed;

   void *pArg;

   if( mem.alarmCallback==0 || mem.alarmBusy  ) return;

   mem.alarmBusy = 1;

   xCallback = mem.alarmCallback;

   nowUsed = mem.nowUsed;

   pArg = mem.alarmArg;

   sqlite3_mutex_leave(mem.mutex);

   xCallback(pArg, nowUsed, nByte);

   sqlite3_mutex_enter(mem.mutex);

   mem.alarmBusy = 0;

 }

 /*

 ** Allocate nBytes of memory

 */

 void *sqlite3_malloc(int nBytes){

   sqlite3_int64 *p = 0;

   if( nBytes>0 ){

     enterMem();

     if( mem.alarmCallback!=0 && mem.nowUsed+nBytes>=mem.alarmThreshold ){

       sqlite3MemsysAlarm(nBytes);

     }

     p = malloc(nBytes+8);

     if( p==0 ){

       sqlite3MemsysAlarm(nBytes);

       p = malloc(nBytes+8);

     }

     if( p ){

       p[0] = nBytes;

       p++;

       mem.nowUsed += nBytes;

       if( mem.nowUsed>mem.mxUsed ){

         mem.mxUsed = mem.nowUsed;

       }

     }

     sqlite3_mutex_leave(mem.mutex);

   }

   return (void*)p; 

 }

 /*

 ** Free memory.

 */

 void sqlite3_free(void *pPrior){

   sqlite3_int64 *p;

   int nByte;

   if( pPrior==0 ){

     return;

   }

   assert( mem.mutex!=0 );

   p = pPrior;

   p--;

   nByte = (int)*p;

   sqlite3_mutex_enter(mem.mutex);

   mem.nowUsed -= nByte;

   free(p);

   sqlite3_mutex_leave(mem.mutex);  

 }

 /*

 ** Change the size of an existing memory allocation

 */

 void *sqlite3_realloc(void *pPrior, int nBytes){

   int nOld;

   sqlite3_int64 *p;

   if( pPrior==0 ){

     return sqlite3_malloc(nBytes);

   }

   if( nBytes<=0 ){

     sqlite3_free(pPrior);

     return 0;

   }

   p = pPrior;

   p--;

   nOld = (int)p[0];

   assert( mem.mutex!=0 );

   sqlite3_mutex_enter(mem.mutex);

   if( mem.nowUsed+nBytes-nOld>=mem.alarmThreshold ){

     sqlite3MemsysAlarm(nBytes-nOld);

   }

   p = realloc(p, nBytes+8);

   if( p==0 ){

     sqlite3MemsysAlarm(nBytes);

     p = realloc(p, nBytes+8);

   }

   if( p ){

     p[0] = nBytes;

     p++;

     mem.nowUsed += nBytes-nOld;

     if( mem.nowUsed>mem.mxUsed ){

       mem.mxUsed = mem.nowUsed;

     }

   }

   sqlite3_mutex_leave(mem.mutex);

   return (void*)p;

 }

 #endif /* !SQLITE_MEMDEBUG && !SQLITE_OMIT_MEMORY_ALLOCATION */