[SQLite3] memory debugging

Sqlite3 Memory mode

• Basically Sliqte3 Provided interface , As long as it's operated correctly , There is no memory leak . It has a strict memory theory , And implementation mechanism . The main discussion here is , How to perform memory mode 、 confirm .

Sqlite3 Dynamic memory

• see sqllite3 The size of the dynamic memory currently held （byte）. This interface is accessed through the SQLITE_STATUS_MEMORY_USED Status value implementation . The general principle is ,sqlite3 When dynamic memory is requested or released , Will SQLITE_STATUS_MEMORY_USED Add or subtract the allocated value from the corresponding status value bytpe The operation of .

//  Interface 
sqlite3_int64 sqlite3_memory_used(void);

//  Interface implementation 
//  The interface will return sqlite3 The size of dynamically allocated memory held .
sqlite3_int64 sqlite3_memory_used(void){
    
  int n, mx;
  sqlite3_int64 res;
  sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, 0);
  res = (sqlite3_int64)n;  /* Work around bug in Borland C. Ticket #3216 */
  return res;
}

// sqlite3 Internal implementation logic 
/* ** Free memory previously obtained from sqlite3Malloc(). */
void sqlite3_free(void *p){
    
 	//  Omit 
 	//  Record the number of bytes of memory released ( negative )
   sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -     sqlite3MallocSize(p));
}


/* ** Do a memory allocation with statistics and alarms. Assume the ** lock is already held. */
static int mallocWithAlarm(int n, void **pp){
    
     //  Record the requested memory szie（ Positive numbers ）
    nFull = sqlite3MallocSize(p);
    sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nFull);
}

• obtain sqlite3 Internal state interface , first in The parameter indicates the state type , the second out The parameter represents the current value of the status , Third output The parameter is the highest value of the status record , The fourth parameter is ture Indicates that the highest value of the record is cleared after the function .

int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);

• Available status values

//  Current memory 
#define SQLITE_STATUS_MEMORY_USED 0
//  Page memory 
#define SQLITE_STATUS_PAGECACHE_USED 1
#define SQLITE_STATUS_PAGECACHE_OVERFLOW 2
#define SQLITE_STATUS_SCRATCH_USED 3
#define SQLITE_STATUS_SCRATCH_OVERFLOW 4
#define SQLITE_STATUS_MALLOC_SIZE 5
#define SQLITE_STATUS_PARSER_STACK 6
#define SQLITE_STATUS_PAGECACHE_SIZE 7
#define SQLITE_STATUS_SCRATCH_SIZE 8
//  Executed malloc The number of （malloc when +1,free when -1）
#define SQLITE_STATUS_MALLOC_COUNT 9

• modify sqlite Code , Check for memory leaks . modify sqlite3StatusAdd function , Let it execute , Output of allocated memory size. At the same time to modify sqlite3MemSize and sqlite3MemFree function , Let it output the address of the pointer . example ：

//  Output memory increases / Released size
void sqlite3StatusAdd(int op, int N){
    
  if (SQLITE_STATUS_MEMORY_USED == op) {
    
    printf("sqlite3StatusAdd memory change [%d]", N);
  }
  // ....
}

//  In general , Memory allocation 、 Release will call this function , perhaps size, And then use sqlite3StatusAdd Record . So it can be added to this function .
static int sqlite3MemSize(void *pPrior){
    
#ifdef SQLITE_MALLOCSIZE
  return pPrior ? (int)SQLITE_MALLOCSIZE(pPrior) : 0;
#else
  sqlite3_int64 *p;
  if( pPrior==0 ) return 0;
  p = (sqlite3_int64*)pPrior;
  p--;
  printf("sqlite3MemSize buffer addr[%p]", p);
  return (int)p[0];
#endif
}

//  Look at the address of the freed memory .
static void sqlite3MemFree(void *pPrior){
    
#ifdef SQLITE_MALLOCSIZE
  SQLITE_FREE(pPrior);
#else
  sqlite3_int64 *p = (sqlite3_int64*)pPrior;
  assert( pPrior!=0 );
  p--;
  printf("sqlite3MemFree addr[%p]", p);
  SQLITE_FREE(p);
#endif
}

• In the source code , Append output information , Can be observed more directly sqlite Allocated memory information .

• in addition , You can also use varglind Perform memory mode .

About Sqlite3 Memory can not be released

• Recently I met a Sqlite3 Memory can not be released , adopt sqlite3_finalize Post release function , The memory of the viewing process is still not reduced . On this question , After analysis , Finally found sqlite3 For all dynamically requested memory , They all called. free operation . The real cause of the problem is , Running the process On the system , about malloc Of memory ,free It will not be released immediately after （ About the cause and solution , There are some articles on the Internet , Can own Baidu ）.