lock_util.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:4k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  8. #ifndef lint
  9. static const char revid[] = "$Id: lock_util.c,v 11.8 2002/03/27 04:32:20 bostic Exp $";
  10. #endif /* not lint */
  11. #ifndef NO_SYSTEM_INCLUDES
  12. #include <sys/types.h>
  13. #include <string.h>
  14. #endif
  15. #include "db_int.h"
  16. #include "dbinc/db_page.h"
  17. #include "dbinc/db_shash.h"
  18. #include "dbinc/hash.h"
  19. #include "dbinc/lock.h"
  20. /*
  21.  * __lock_cmp --
  22.  * This function is used to compare a DBT that is about to be entered
  23.  * into a hash table with an object already in the hash table.  Note
  24.  * that it just returns true on equal and 0 on not-equal.  Therefore
  25.  * this function cannot be used as a sort function; its purpose is to
  26.  * be used as a hash comparison function.
  27.  *
  28.  * PUBLIC: int __lock_cmp __P((const DBT *, DB_LOCKOBJ *));
  29.  */
  30. int
  31. __lock_cmp(dbt, lock_obj)
  32. const DBT *dbt;
  33. DB_LOCKOBJ *lock_obj;
  34. {
  35. void *obj_data;
  36. obj_data = SH_DBT_PTR(&lock_obj->lockobj);
  37. return (dbt->size == lock_obj->lockobj.size &&
  38. memcmp(dbt->data, obj_data, dbt->size) == 0);
  39. }
  40. /*
  41.  * PUBLIC: int __lock_locker_cmp __P((u_int32_t, DB_LOCKER *));
  42.  */
  43. int
  44. __lock_locker_cmp(locker, sh_locker)
  45. u_int32_t locker;
  46. DB_LOCKER *sh_locker;
  47. {
  48. return (locker == sh_locker->id);
  49. }
  50. /*
  51.  * The next two functions are the hash functions used to store objects in the
  52.  * lock hash tables.  They are hashing the same items, but one (__lock_ohash)
  53.  * takes a DBT (used for hashing a parameter passed from the user) and the
  54.  * other (__lock_lhash) takes a DB_LOCKOBJ (used for hashing something that is
  55.  * already in the lock manager).  In both cases, we have a special check to
  56.  * fast path the case where we think we are doing a hash on a DB page/fileid
  57.  * pair.  If the size is right, then we do the fast hash.
  58.  *
  59.  * We know that DB uses DB_LOCK_ILOCK types for its lock objects.  The first
  60.  * four bytes are the 4-byte page number and the next DB_FILE_ID_LEN bytes
  61.  * are a unique file id, where the first 4 bytes on UNIX systems are the file
  62.  * inode number, and the first 4 bytes on Windows systems are the FileIndexLow
  63.  * bytes.  So, we use the XOR of the page number and the first four bytes of
  64.  * the file id to produce a 32-bit hash value.
  65.  *
  66.  * We have no particular reason to believe that this algorithm will produce
  67.  * a good hash, but we want a fast hash more than we want a good one, when
  68.  * we're coming through this code path.
  69.  */
  70. #define FAST_HASH(P) {
  71. u_int32_t __h;
  72. u_int8_t *__cp, *__hp;
  73. __hp = (u_int8_t *)&__h;
  74. __cp = (u_int8_t *)(P);
  75. __hp[0] = __cp[0] ^ __cp[4];
  76. __hp[1] = __cp[1] ^ __cp[5];
  77. __hp[2] = __cp[2] ^ __cp[6];
  78. __hp[3] = __cp[3] ^ __cp[7];
  79. return (__h);
  80. }
  81. /*
  82.  * __lock_ohash --
  83.  *
  84.  * PUBLIC: u_int32_t __lock_ohash __P((const DBT *));
  85.  */
  86. u_int32_t
  87. __lock_ohash(dbt)
  88. const DBT *dbt;
  89. {
  90. if (dbt->size == sizeof(DB_LOCK_ILOCK))
  91. FAST_HASH(dbt->data);
  92. return (__ham_func5(NULL, dbt->data, dbt->size));
  93. }
  94. /*
  95.  * __lock_lhash --
  96.  *
  97.  * PUBLIC: u_int32_t __lock_lhash __P((DB_LOCKOBJ *));
  98.  */
  99. u_int32_t
  100. __lock_lhash(lock_obj)
  101. DB_LOCKOBJ *lock_obj;
  102. {
  103. void *obj_data;
  104. obj_data = SH_DBT_PTR(&lock_obj->lockobj);
  105. if (lock_obj->lockobj.size == sizeof(DB_LOCK_ILOCK))
  106. FAST_HASH(obj_data);
  107. return (__ham_func5(NULL, obj_data, lock_obj->lockobj.size));
  108. }
  109. /*
  110.  * __lock_locker_hash --
  111.  * Hash function for entering lockers into the locker hash table.
  112.  * Since these are simply 32-bit unsigned integers, just return
  113.  * the locker value.
  114.  *
  115.  * PUBLIC: u_int32_t __lock_locker_hash __P((u_int32_t));
  116.  */
  117. u_int32_t
  118. __lock_locker_hash(locker)
  119. u_int32_t locker;
  120. {
  121. return (locker);
  122. }