mutex_ecos.c
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:7k
源码类别:

数据库系统

开发平台:

C/C++

  1. /*
  2. ** 2007 August 14
  3. **
  4. ** The author disclaims copyright to this source code.  In place of
  5. ** a legal notice, here is a blessing:
  6. **
  7. **    May you do good and not evil.
  8. **    May you find forgiveness for yourself and forgive others.
  9. **    May you share freely, never taking more than you give.
  10. **
  11. *************************************************************************
  12. ** This file contains the C functions that implement mutexes for win32
  13. **
  14. ** $Id: mutex_w32.c,v 1.6 2008/03/26 18:34:43 danielk1977 Exp $
  15. */
  16. #include "sqliteInt.h"
  17. /*
  18. ** The code in this file is only used if we are compiling multithreaded
  19. ** on a win32 system.
  20. */
  21. #ifdef SQLITE_MUTEX_FYF
  22. #include "../inc/fyf_com.h"
  23. /*
  24. ** Each recursive mutex is an instance of the following structure.
  25. */
  26. struct sqlite3_mutex {
  27.   BU32 mutex;    /* Mutex controlling the lock */
  28.   int id;                    /* Mutex type */
  29.   int nRef;                  /* Number of enterances */
  30.   BU32 owner;               /* Thread holding this mutex */
  31. };
  32. #if 0
  33. /*
  34. ** Return true (non-zero) if we are running under WinNT, Win2K, WinXP,
  35. ** or WinCE.  Return false (zero) for Win95, Win98, or WinME.
  36. **
  37. ** Here is an interesting observation:  Win95, Win98, and WinME lack
  38. ** the LockFileEx() API.  But we can still statically link against that
  39. ** API as long as we don't call it win running Win95/98/ME.  A call to
  40. ** this routine is used to determine if the host is Win95/98/ME or
  41. ** WinNT/2K/XP so that we will know whether or not we can safely call
  42. ** the LockFileEx() API.
  43. */
  44. #if OS_WINCE
  45. # define mutexIsNT()  (1)
  46. #else
  47.   static int mutexIsNT(void){
  48.     static int osType = 0;
  49.     if( osType==0 ){
  50.       OSVERSIONINFO sInfo;
  51.       sInfo.dwOSVersionInfoSize = sizeof(sInfo);
  52.       GetVersionEx(&sInfo);
  53.       osType = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
  54.     }
  55.     return osType==2;
  56.   }
  57. #endif /* OS_WINCE */
  58. #endif
  59. /*
  60. ** The sqlite3_mutex_alloc() routine allocates a new
  61. ** mutex and returns a pointer to it.  If it returns NULL
  62. ** that means that a mutex could not be allocated.  SQLite
  63. ** will unwind its stack and return an error.  The argument
  64. ** to sqlite3_mutex_alloc() is one of these integer constants:
  65. **
  66. ** <ul>
  67. ** <li>  SQLITE_MUTEX_FAST               0
  68. ** <li>  SQLITE_MUTEX_RECURSIVE          1
  69. ** <li>  SQLITE_MUTEX_STATIC_MASTER      2
  70. ** <li>  SQLITE_MUTEX_STATIC_MEM         3
  71. ** <li>  SQLITE_MUTEX_STATIC_PRNG        4
  72. ** </ul>
  73. **
  74. ** The first two constants cause sqlite3_mutex_alloc() to create
  75. ** a new mutex.  The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
  76. ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
  77. ** The mutex implementation does not need to make a distinction
  78. ** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
  79. ** not want to.  But SQLite will only request a recursive mutex in
  80. ** cases where it really needs one.  If a faster non-recursive mutex
  81. ** implementation is available on the host platform, the mutex subsystem
  82. ** might return such a mutex in response to SQLITE_MUTEX_FAST.
  83. **
  84. ** The other allowed parameters to sqlite3_mutex_alloc() each return
  85. ** a pointer to a static preexisting mutex.  Three static mutexes are
  86. ** used by the current version of SQLite.  Future versions of SQLite
  87. ** may add additional static mutexes.  Static mutexes are for internal
  88. ** use by SQLite only.  Applications that use SQLite mutexes should
  89. ** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
  90. ** SQLITE_MUTEX_RECURSIVE.
  91. **
  92. ** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
  93. ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
  94. ** returns a different mutex on every call.  But for the static 
  95. ** mutex types, the same mutex is returned on every call that has
  96. ** the same type number.
  97. */
  98. sqlite3_mutex *sqlite3_mutex_alloc(int iType){
  99.   sqlite3_mutex *p;
  100.   switch( iType ){
  101.     case SQLITE_MUTEX_FAST:
  102.     case SQLITE_MUTEX_RECURSIVE: {
  103.       p = sqlite3MallocZero( sizeof(*p) );
  104.       if( p ){
  105.         p->id = iType;
  106.     p->mutex = FYF_API_mutex_create ();
  107.       }
  108.       break;
  109.     }
  110.     default: {
  111.       static sqlite3_mutex staticMutexes[6];
  112.       static int isInit = 0;
  113.       while( !isInit ){
  114.         static long lock = 0;
  115.         if( /*InterlockedIncrement(&lock)==1 */ (++lock) == 1){
  116.           int i;
  117.           for(i=0; i<sizeof(staticMutexes)/sizeof(staticMutexes[0]); i++){
  118.           staticMutexes[i].mutex = FYF_API_mutex_create ();
  119.           }
  120.           isInit = 1;
  121.         }else{
  122.   FYF_API_thread_sleep (1);
  123.         }
  124.       }
  125.       assert( iType-2 >= 0 );
  126.       assert( iType-2 < sizeof(staticMutexes)/sizeof(staticMutexes[0]) );
  127.       p = &staticMutexes[iType-2];
  128.       p->id = iType;
  129.       break;
  130.     }
  131.   }
  132.   return p;
  133. }
  134. /*
  135. ** This routine deallocates a previously
  136. ** allocated mutex.  SQLite is careful to deallocate every
  137. ** mutex that it allocates.
  138. */
  139. void sqlite3_mutex_free(sqlite3_mutex *p){
  140.   assert( p );
  141.   assert( p->nRef==0 );
  142.   assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
  143.   FYF_API_mutex_delete(p->mutex);
  144.   sqlite3_free(p);
  145. }
  146. /*
  147. ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
  148. ** to enter a mutex.  If another thread is already within the mutex,
  149. ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
  150. ** SQLITE_BUSY.  The sqlite3_mutex_try() interface returns SQLITE_OK
  151. ** upon successful entry.  Mutexes created using SQLITE_MUTEX_RECURSIVE can
  152. ** be entered multiple times by the same thread.  In such cases the,
  153. ** mutex must be exited an equal number of times before another thread
  154. ** can enter.  If the same thread tries to enter any other kind of mutex
  155. ** more than once, the behavior is undefined.
  156. */
  157. void sqlite3_mutex_enter(sqlite3_mutex *p){
  158.   assert( p );
  159.   assert( p->id==SQLITE_MUTEX_RECURSIVE || sqlite3_mutex_notheld(p) );
  160.   if((p->id==SQLITE_MUTEX_RECURSIVE && p->owner!=FYF_API_thread_getCurID ()) || p->id!=SQLITE_MUTEX_RECURSIVE)
  161.   {
  162.     FYF_API_mutex_lock(p->mutex, FYF_WAIT_FOREVER);
  163.    p->owner = FYF_API_thread_getCurID ();
  164.    p->nRef++;
  165.   }
  166. }
  167. int sqlite3_mutex_try(sqlite3_mutex *p){
  168.   int rc = SQLITE_BUSY;
  169.   assert( p );
  170.   assert( p->id==SQLITE_MUTEX_RECURSIVE || sqlite3_mutex_notheld(p) );
  171.   /*
  172.   ** The sqlite3_mutex_try() routine is very rarely used, and when it
  173.   ** is used it is merely an optimization.  So it is OK for it to always
  174.   ** fail.  
  175.   **
  176.   ** The TryEnterCriticalSection() interface is only available on WinNT.
  177.   ** And some windows compilers complain if you try to use it without
  178.   ** first doing some #defines that prevent SQLite from building on Win98.
  179.   ** For that reason, we will omit this optimization for now.  See
  180.   ** ticket #2685.
  181.   */
  182. #if 0
  183.   if(/* mutexIsNT() && */FYF_API_mutex_lock(p->mutex,0) ){
  184.     p->owner = FYF_API_thread_getCurID();
  185.     p->nRef++;
  186.     rc = SQLITE_OK;
  187.   }
  188. #endif
  189.   return rc;
  190. }
  191. /*
  192. ** The sqlite3_mutex_leave() routine exits a mutex that was
  193. ** previously entered by the same thread.  The behavior
  194. ** is undefined if the mutex is not currently entered or
  195. ** is not currently allocated.  SQLite will never do either.
  196. */
  197. void sqlite3_mutex_leave(sqlite3_mutex *p){
  198.   assert( p->nRef>0 );
  199.   assert( p->owner==FYF_API_thread_getCurID() );
  200.   p->nRef--;
  201.   assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE );
  202.   FYF_API_mutex_unlock (p->mutex);
  203. }
  204. /*
  205. ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
  206. ** intended for use only inside assert() statements.
  207. */
  208. int sqlite3_mutex_held(sqlite3_mutex *p){
  209.   return p==0 || (p->nRef!=0 && p->owner==FYF_API_thread_getCurID());
  210. }
  211. int sqlite3_mutex_notheld(sqlite3_mutex *p){
  212.   return p==0 || p->nRef==0 || p->owner!=FYF_API_thread_getCurID();
  213. }
  214. #endif /* SQLITE_MUTEX_W32 */