/*

 ** 2008 June 18

 **

 ** 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.

 **

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

 ** 

 ** $Id: test_mutex.c,v 1.11 2008/07/19 13:43:24 danielk1977 Exp $

 */

 #include "tcl.h"

 #include "sqlite3.h"

 #include "sqliteInt.h"

 #include <stdlib.h>

 #include <assert.h>

 #include <string.h>

 /* defined in test1.c */

 const char *sqlite3TestErrorName(int);

 /* A countable mutex */

 struct sqlite3_mutex {

   sqlite3_mutex *pReal;

   int eType;

 };

 /* State variables */

 static struct test_mutex_globals {

   int isInstalled;              /* True if installed */

   int disableInit;              /* True to cause sqlite3_initalize() to fail */

   int disableTry;               /* True to force sqlite3_mutex_try() to fail */

   int isInit;                   /* True if initialized */

   sqlite3_mutex_methods m;      /* Interface to "real" mutex system */

   int aCounter[8];              /* Number of grabs of each type of mutex */

   sqlite3_mutex aStatic[6];     /* The six static mutexes */

 } g;

 /* Return true if the countable mutex is currently held */

 static int counterMutexHeld(sqlite3_mutex *p){

   return g.m.xMutexHeld(p->pReal);

 }

 /* Return true if the countable mutex is not currently held */

 static int counterMutexNotheld(sqlite3_mutex *p){

   return g.m.xMutexNotheld(p->pReal);

 }

 /* Initialize the countable mutex interface

 ** Or, if g.disableInit is non-zero, then do not initialize but instead

 ** return the value of g.disableInit as the result code.  This can be used

 ** to simulate an initialization failure.

 */

 static int counterMutexInit(void){ 

   int rc;

   if( g.disableInit ) return g.disableInit;

   rc = g.m.xMutexInit();

   g.isInit = 1;

   return rc;

 }

 /*

 ** Uninitialize the mutex subsystem

 */

 static int counterMutexEnd(void){ 

   g.isInit = 0;

   return g.m.xMutexEnd();

 }

 /*

 ** Allocate a countable mutex

 */

 static sqlite3_mutex *counterMutexAlloc(int eType){

   sqlite3_mutex *pReal;

   sqlite3_mutex *pRet = 0;

   assert( g.isInit );

   assert(eType<8 && eType>=0);

   pReal = g.m.xMutexAlloc(eType);

   if( !pReal ) return 0;

   if( eType==SQLITE_MUTEX_FAST || eType==SQLITE_MUTEX_RECURSIVE ){

     pRet = (sqlite3_mutex *)malloc(sizeof(sqlite3_mutex));

   }else{

     pRet = &g.aStatic[eType-2];

   }

   pRet->eType = eType;

   pRet->pReal = pReal;

   return pRet;

 }

 /*

 ** Free a countable mutex

 */

 static void counterMutexFree(sqlite3_mutex *p){

   assert( g.isInit );

   g.m.xMutexFree(p->pReal);

   if( p->eType==SQLITE_MUTEX_FAST || p->eType==SQLITE_MUTEX_RECURSIVE ){

     free(p);

   }

 }

 /*

 ** Enter a countable mutex.  Block until entry is safe.

 */

 static void counterMutexEnter(sqlite3_mutex *p){

   assert( g.isInit );

   g.aCounter[p->eType]++;

   g.m.xMutexEnter(p->pReal);

 }

 /*

 ** Try to enter a mutex.  Return true on success.

 */

 static int counterMutexTry(sqlite3_mutex *p){

   assert( g.isInit );

   g.aCounter[p->eType]++;

   if( g.disableTry ) return SQLITE_BUSY;

   return g.m.xMutexTry(p->pReal);

 }

 /* Leave a mutex

 */

 static void counterMutexLeave(sqlite3_mutex *p){

   assert( g.isInit );

   g.m.xMutexLeave(p->pReal);

 }

 /*

 ** sqlite3_shutdown

 */

 static int test_shutdown(

   void * clientData,

   Tcl_Interp *interp,

   int objc,

   Tcl_Obj *CONST objv[]

 ){

   int rc;

   if( objc!=1 ){

     Tcl_WrongNumArgs(interp, 1, objv, "");

     return TCL_ERROR;

   }

   rc = sqlite3_shutdown();

   Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);

   return TCL_OK;

 }

 /*

 ** sqlite3_initialize

 */

 static int test_initialize(

   void * clientData,

   Tcl_Interp *interp,

   int objc,

   Tcl_Obj *CONST objv[]

 ){

   int rc;

   if( objc!=1 ){

     Tcl_WrongNumArgs(interp, 1, objv, "");

     return TCL_ERROR;

   }

   rc = sqlite3_initialize();

   Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);

   return TCL_OK;

 }

 /*

 ** install_mutex_counters BOOLEAN

 */

 static int test_install_mutex_counters(

   void * clientData,

   Tcl_Interp *interp,

   int objc,

   Tcl_Obj *CONST objv[]

 ){

   int rc = SQLITE_OK;

   int isInstall;

   sqlite3_mutex_methods counter_methods = {

     counterMutexInit,

     counterMutexEnd,

     counterMutexAlloc,

     counterMutexFree,

     counterMutexEnter,

     counterMutexTry,

     counterMutexLeave,

     counterMutexHeld,

     counterMutexNotheld

   };

   if( objc!=2 ){

     Tcl_WrongNumArgs(interp, 1, objv, "BOOLEAN");

     return TCL_ERROR;

   }

   if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[1], &isInstall) ){

     return TCL_ERROR;

   }

   assert(isInstall==0 || isInstall==1);

   assert(g.isInstalled==0 || g.isInstalled==1);

   if( isInstall==g.isInstalled ){

     Tcl_AppendResult(interp, "mutex counters are ", 0);

     Tcl_AppendResult(interp, isInstall?"already installed":"not installed", 0);

     return TCL_ERROR;

   }

   if( isInstall ){

     assert( g.m.xMutexAlloc==0 );

     rc = sqlite3_config(SQLITE_CONFIG_GETMUTEX, &g.m);

     if( rc==SQLITE_OK ){

       sqlite3_config(SQLITE_CONFIG_MUTEX, &counter_methods);

     }

     g.disableTry = 0;

   }else{

     assert( g.m.xMutexAlloc );

     rc = sqlite3_config(SQLITE_CONFIG_MUTEX, &g.m);

     memset(&g.m, 0, sizeof(sqlite3_mutex_methods));

   }

   if( rc==SQLITE_OK ){

     g.isInstalled = isInstall;

   }

   Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);

   return TCL_OK;

 }

 /*

 ** read_mutex_counters

 */

 static int test_read_mutex_counters(

   void * clientData,

   Tcl_Interp *interp,

   int objc,

   Tcl_Obj *CONST objv[]

 ){

   Tcl_Obj *pRet;

   int ii;

   char *aName[8] = {

     "fast",        "recursive",   "static_master", "static_mem", 

     "static_mem2", "static_prng", "static_lru",    "static_lru2"

   };

   if( objc!=1 ){

     Tcl_WrongNumArgs(interp, 1, objv, "");

     return TCL_ERROR;

   }

   pRet = Tcl_NewObj();

   Tcl_IncrRefCount(pRet);

   for(ii=0; ii<8; ii++){

     Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj(aName[ii], -1));

     Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(g.aCounter[ii]));

   }

   Tcl_SetObjResult(interp, pRet);

   Tcl_DecrRefCount(pRet);

   return TCL_OK;

 }

 /*

 ** clear_mutex_counters

 */

 static int test_clear_mutex_counters(

   void * clientData,

   Tcl_Interp *interp,

   int objc,

   Tcl_Obj *CONST objv[]

 ){

   int ii;

   if( objc!=1 ){

     Tcl_WrongNumArgs(interp, 1, objv, "");

     return TCL_ERROR;

   }

   for(ii=0; ii<8; ii++){

     g.aCounter[ii] = 0;

   }

   return TCL_OK;

 }

 /*

 ** Create and free a mutex.  Return the mutex pointer.  The pointer

 ** will be invalid since the mutex has already been freed.  The

 ** return pointer just checks to see if the mutex really was allocated.

 */

 static int test_alloc_mutex(

   void * clientData,

   Tcl_Interp *interp,

   int objc,

   Tcl_Obj *CONST objv[]

 ){

 #if SQLITE_THREADSAFE

   sqlite3_mutex *p = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);

   char zBuf[100];

   sqlite3_mutex_free(p);

   sqlite3_snprintf(sizeof(zBuf), zBuf, "%p", p);

   Tcl_AppendResult(interp, zBuf, (char*)0);

 #endif

   return TCL_OK;

 }

 /*

 ** sqlite3_config OPTION

 **

 ** OPTION can be either one of the keywords:

 **

 **            SQLITE_CONFIG_SINGLETHREAD

 **            SQLITE_CONFIG_MULTITHREAD

 **            SQLITE_CONFIG_SERIALIZED

 **

 ** Or OPTION can be an raw integer.

 */

 static int test_config(

   void * clientData,

   Tcl_Interp *interp,

   int objc,

   Tcl_Obj *CONST objv[]

 ){

   struct ConfigOption {

     const char *zName;

     int iValue;

   } aOpt[] = {

     {"singlethread", SQLITE_CONFIG_SINGLETHREAD},

     {"multithread",  SQLITE_CONFIG_MULTITHREAD},

     {"serialized",   SQLITE_CONFIG_SERIALIZED},

     {0, 0}

   };

   int s = sizeof(struct ConfigOption);

   int i;

   int rc;

   if( objc!=2 ){

     Tcl_WrongNumArgs(interp, 1, objv, "");

     return TCL_ERROR;

   }

   if( Tcl_GetIndexFromObjStruct(interp, objv[1], aOpt, s, "flag", 0, &i) ){

     if( Tcl_GetIntFromObj(interp, objv[1], &i) ){

       return TCL_ERROR;

     }

   }else{

     i = aOpt[i].iValue;

   }

   rc = sqlite3_config(i);

   Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_VOLATILE);

   return TCL_OK;

 }

 int Sqlitetest_mutex_Init(Tcl_Interp *interp){

   static struct {

     char *zName;

     Tcl_ObjCmdProc *xProc;

   } aCmd[] = {

     { "sqlite3_shutdown",        (Tcl_ObjCmdProc*)test_shutdown },

     { "sqlite3_initialize",      (Tcl_ObjCmdProc*)test_initialize },

     { "sqlite3_config",          (Tcl_ObjCmdProc*)test_config },

     { "alloc_dealloc_mutex",     (Tcl_ObjCmdProc*)test_alloc_mutex },

     { "install_mutex_counters",  (Tcl_ObjCmdProc*)test_install_mutex_counters },

     { "read_mutex_counters",     (Tcl_ObjCmdProc*)test_read_mutex_counters },

     { "clear_mutex_counters",    (Tcl_ObjCmdProc*)test_clear_mutex_counters },

   };

   int i;

   for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){

     Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);

   }

   memset(&g, 0, sizeof(g));

   Tcl_LinkVar(interp, "disable_mutex_init", 

               (char*)&g.disableInit, TCL_LINK_INT);

   Tcl_LinkVar(interp, "disable_mutex_try", 

               (char*)&g.disableTry, TCL_LINK_INT);

   return SQLITE_OK;

 }