/*

** 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: mem4.cpp 1282 2008-11-13 09:31:33Z LarsPson $

*/

/*

** This version of the memory allocator attempts to obtain memory

** from mmap() if the size of the allocation is close to the size

** of a virtual memory page.  If the size of the allocation is different

** from the virtual memory page size, then ordinary malloc() is used.

** Ordinary malloc is also used if space allocated to mmap() is

** exhausted.

**

** Enable this memory allocation by compiling with -DSQLITE_MMAP_HEAP_SIZE=nnn

** where nnn is the maximum number of bytes of mmap-ed memory you want 

** to support.   This module may choose to use less memory than requested.

**

*/

#if defined(SQLITE_MMAP_HEAP_SIZE)

#if defined(SQLITE_MEMDEBUG) || defined(SQLITE_MEMORY_SIZE)

# error cannot use SQLITE_MMAP_HEAP_SIZE with either SQLITE_MEMDEBUG \

        or SQLITE_MEMORY_SIZE

#endif

/*

** This is a test version of the memory allocator that attempts to

** use mmap() and madvise() for allocations and frees of approximately

** the virtual memory page size.

*/

#include <sys/types.h>

#include <sys/mman.h>

#include <errno.h>

#include "sqliteInt.h"

#include <unistd.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;

  /*

  ** Current allocation and high-water marks for mmap allocated memory.

  */

  sqlite3_int64 nowUsedMMap;

  sqlite3_int64 mxUsedMMap;

  /*

  ** Size of a single mmap page.  Obtained from sysconf().

  */

  int szPage;

  int mnPage;

  /*

  ** The number of available mmap pages.

  */

  int nPage;

  /*

  ** Index of the first free page.  0 means no pages have been freed.

  */

  int firstFree;

  /* First unused page on the top of the heap.

  */

  int firstUnused;

  /*

  ** Bulk memory obtained from from mmap().

  */

  char *mmapHeap;   /* first byte of the heap */ 

} mem;

/*

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

** The mmap() region is initialized the first time this routine is called.

*/

static void memsys4Enter(void){

  if( mem.mutex==0 ){

    mem.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM);

  }

  sqlite3_mutex_enter(mem.mutex);

}

/*

** Attempt to free memory to the mmap heap.  This only works if

** the pointer p is within the range of memory addresses that

** comprise the mmap heap.  Return 1 if the memory was freed

** successfully.  Return 0 if the pointer is out of range.

*/

static int mmapFree(void *p){

  char *z;

  int idx, *a;

  if( mem.mmapHeap==MAP_FAILED || mem.nPage==0 ){

    return 0;

  }

  z = (char*)p;

  idx = (z - mem.mmapHeap)/mem.szPage;

  if( idx<1 || idx>=mem.nPage ){

    return 0;

  }

  a = (int*)mem.mmapHeap;

  a[idx] = a[mem.firstFree];

  mem.firstFree = idx;

  mem.nowUsedMMap -= mem.szPage;

  madvise(p, mem.szPage, MADV_DONTNEED);

  return 1;

}

/*

** Attempt to allocate nBytes from the mmap heap.  Return a pointer

** to the allocated page.  Or, return NULL if the allocation fails.

** 

** The allocation will fail if nBytes is not the right size.

** Or, the allocation will fail if the mmap heap has been exhausted.

*/

static void *mmapAlloc(int nBytes){

  int idx = 0;

  if( nBytes>mem.szPage || nBytes<mem.mnPage ){

    return 0;

  }

  if( mem.nPage==0 ){

    mem.szPage = sysconf(_SC_PAGE_SIZE);

    mem.mnPage = mem.szPage - mem.szPage/10;

    mem.nPage = SQLITE_MMAP_HEAP_SIZE/mem.szPage;

    if( mem.nPage * sizeof(int) > mem.szPage ){

      mem.nPage = mem.szPage/sizeof(int);

    }

    mem.mmapHeap =  mmap(0, mem.szPage*mem.nPage, PROT_WRITE|PROT_READ,

                         MAP_ANONYMOUS|MAP_SHARED, -1, 0);

    if( mem.mmapHeap==MAP_FAILED ){

      mem.firstUnused = errno;

    }else{

      mem.firstUnused = 1;

      mem.nowUsedMMap = mem.szPage;

    }

  }

  if( mem.mmapHeap==MAP_FAILED ){

    return 0;

  }

  if( mem.firstFree ){

    int idx = mem.firstFree;

    int *a = (int*)mem.mmapHeap;

    mem.firstFree = a[idx];

  }else if( mem.firstUnused<mem.nPage ){

    idx = mem.firstUnused++;

  }

  if( idx ){

    mem.nowUsedMMap += mem.szPage;

    if( mem.nowUsedMMap>mem.mxUsedMMap ){

      mem.mxUsedMMap = mem.nowUsedMMap;

    }

    return (void*)&mem.mmapHeap[idx*mem.szPage];

  }else{

    return 0;

  }

}

/*

** Release the mmap-ed memory region if it is currently allocated and

** is not in use.

*/

static void mmapUnmap(void){

  if( mem.mmapHeap==MAP_FAILED ) return;

  if( mem.nPage==0 ) return;

  if( mem.nowUsedMMap>mem.szPage ) return;

  munmap(mem.mmapHeap, mem.nPage*mem.szPage);

  mem.nowUsedMMap = 0;

  mem.nPage = 0;

}

/*

** Return the amount of memory currently checked out.

*/

sqlite3_int64 sqlite3_memory_used(void){

  sqlite3_int64 n;

  memsys4Enter();

  n = mem.nowUsed + mem.nowUsedMMap;

  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;

  memsys4Enter();

  n = mem.mxUsed + mem.mxUsedMMap;

  if( resetFlag ){

    mem.mxUsed = mem.nowUsed;

    mem.mxUsedMMap = mem.nowUsedMMap;

  }

  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

){

  memsys4Enter();

  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

*/

static void *memsys4Malloc(int nBytes){

  sqlite3_int64 *p = 0;

  if( mem.alarmCallback!=0

         && mem.nowUsed+mem.nowUsedMMap+nBytes>=mem.alarmThreshold ){

    sqlite3MemsysAlarm(nBytes);

  }

  if( (p = mmapAlloc(nBytes))==0 ){

    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;

      }

    }

  }

  return (void*)p; 

}

/*

** Return the size of a memory allocation

*/

static int memsys4Size(void *pPrior){

  char *z = (char*)pPrior;

  int idx = mem.nPage ? (z - mem.mmapHeap)/mem.szPage : 0;

  int nByte;

  if( idx>=1 && idx<mem.nPage ){

    nByte = mem.szPage;

  }else{

    sqlite3_int64 *p = pPrior;

    p--;

    nByte = (int)*p;

  }

  return nByte;

}

/*

** Free memory.

*/

static void memsys4Free(void *pPrior){

  sqlite3_int64 *p;

  int nByte;

  if( mmapFree(pPrior)==0 ){

    p = pPrior;

    p--;

    nByte = (int)*p;

    mem.nowUsed -= nByte;

    free(p);

    if( mem.nowUsed==0 ){

      mmapUnmap();

    }      

  }

}

/*

** Allocate nBytes of memory

*/

void *sqlite3_malloc(int nBytes){

  sqlite3_int64 *p = 0;

  if( nBytes>0 ){

    memsys4Enter();

    p = memsys4Malloc(nBytes);

    sqlite3_mutex_leave(mem.mutex);

  }

  return (void*)p; 

}

/*

** Free memory.

*/

void sqlite3_free(void *pPrior){

  if( pPrior==0 ){

    return;

  }

  assert( mem.mutex!=0 );

  sqlite3_mutex_enter(mem.mutex);

  memsys4Free(pPrior);

  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;

  }

  nOld = memsys4Size(pPrior);

  if( nBytes<=nOld && nBytes>=nOld-128 ){

    return pPrior;

  }

  assert( mem.mutex!=0 );

  sqlite3_mutex_enter(mem.mutex);

  p = memsys4Malloc(nBytes);

  if( p ){

    if( nOld<nBytes ){

      memcpy(p, pPrior, nOld);

    }else{

      memcpy(p, pPrior, nBytes);

    }

    memsys4Free(pPrior);

  }

  assert( mem.mutex!=0 );

  sqlite3_mutex_leave(mem.mutex);

  return (void*)p;

}

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