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

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************************
  2. Random numbers and hashing
  3. (c) 1994, 1995 Innobase Oy
  4. Created 5/30/1994 Heikki Tuuri
  5. *******************************************************************/
  6. #define UT_HASH_RANDOM_MASK     1463735687
  7. #define UT_HASH_RANDOM_MASK2    1653893711
  8. #define UT_RND1                 151117737
  9. #define UT_RND2                 119785373
  10. #define UT_RND3                  85689495
  11. #define UT_RND4                  76595339
  12. #define UT_SUM_RND2              98781234 
  13. #define UT_SUM_RND3             126792457
  14. #define UT_SUM_RND4              63498502
  15. #define UT_XOR_RND1             187678878
  16. #define UT_XOR_RND2             143537923
  17. extern  ulint    ut_rnd_ulint_counter;
  18. /************************************************************
  19. This is used to set the random number seed. */
  20. UNIV_INLINE
  21. void
  22. ut_rnd_set_seed(
  23. /*============*/
  24. ulint    seed)           /* in: seed */
  25. {
  26. ut_rnd_ulint_counter = seed;
  27. }
  28. /************************************************************
  29. The following function generates a series of 'random' ulint integers. */
  30. UNIV_INLINE
  31. ulint
  32. ut_rnd_gen_next_ulint(
  33. /*==================*/
  34. /* out: the next 'random' number */
  35. ulint rnd) /* in: the previous random number value */
  36. {
  37. ulint n_bits;
  38. n_bits = 8 * sizeof(ulint);
  39. rnd = UT_RND2 * rnd + UT_SUM_RND3;
  40. rnd = UT_XOR_RND1 ^ rnd;
  41. rnd = (rnd << 20) + (rnd >> (n_bits - 20));
  42. rnd = UT_RND3 * rnd + UT_SUM_RND4;
  43. rnd = UT_XOR_RND2 ^ rnd;
  44. rnd = (rnd << 20) + (rnd >> (n_bits - 20));
  45. rnd = UT_RND1 * rnd + UT_SUM_RND2;
  46. return(rnd);
  47. }
  48. /************************************************************
  49. The following function generates 'random' ulint integers which
  50. enumerate the value space of ulint integers in a pseudo random
  51. fashion. Note that the same integer is repeated always after
  52. 2 to power 32 calls to the generator (if ulint is 32-bit). */
  53. UNIV_INLINE
  54. ulint
  55. ut_rnd_gen_ulint(void)
  56. /*==================*/
  57. /* out: the 'random' number */
  58. {
  59. ulint   rnd;
  60. ulint n_bits;
  61. n_bits = 8 * sizeof(ulint);
  62. ut_rnd_ulint_counter =
  63. UT_RND1 * ut_rnd_ulint_counter + UT_RND2;
  64. rnd = ut_rnd_gen_next_ulint(ut_rnd_ulint_counter);
  65. return(rnd);
  66. }
  67. /************************************************************
  68. Generates a random integer from a given interval. */
  69. UNIV_INLINE
  70. ulint
  71. ut_rnd_interval(
  72. /*============*/
  73. /* out: the 'random' number */
  74. ulint low, /* in: low limit; can generate also this value */
  75. ulint high) /* in: high limit; can generate also this value */
  76. {
  77. ulint rnd;
  78. ut_ad(high >= low);
  79. if (low == high) {
  80. return(low);
  81. }
  82. rnd = ut_rnd_gen_ulint();
  83. return(low + (rnd % (high - low + 1)));
  84. }
  85. /*************************************************************
  86. Generates a random iboolean value. */
  87. UNIV_INLINE
  88. ibool
  89. ut_rnd_gen_ibool(void)
  90. /*=================*/
  91. /* out: the random value */
  92. {
  93. ulint    x;
  94. x = ut_rnd_gen_ulint();
  95. if (((x >> 20) + (x >> 15)) & 1) {
  96. return(TRUE);
  97. }
  98. return(FALSE);
  99. /***********************************************************
  100. The following function generates a hash value for a ulint integer
  101. to a hash table of size table_size, which should be a prime
  102. or some random number for the hash table to work reliably. */
  103. UNIV_INLINE
  104. ulint
  105. ut_hash_ulint(
  106. /*=========*/
  107. /* out: hash value */
  108. ulint    key,       /* in: value to be hashed */
  109. ulint    table_size)  /* in: hash table size */
  110. {
  111. key = key ^ UT_HASH_RANDOM_MASK2;
  112. return(key % table_size);
  113. }
  114. /*****************************************************************
  115. Folds a pair of ulints. */
  116. UNIV_INLINE
  117. ulint
  118. ut_fold_ulint_pair(
  119. /*===============*/
  120. /* out: folded value */
  121. ulint n1, /* in: ulint */
  122. ulint n2) /* in: ulint */
  123. {
  124. return(((((n1 ^ n2 ^ UT_HASH_RANDOM_MASK2) << 8) + n1)
  125. ^ UT_HASH_RANDOM_MASK) + n2);
  126. /*****************************************************************
  127. Folds a dulint. */
  128. UNIV_INLINE
  129. ulint
  130. ut_fold_dulint(
  131. /*===========*/
  132. /* out: folded value */
  133. dulint d) /* in: dulint */
  134. {
  135. return(ut_fold_ulint_pair(ut_dulint_get_low(d),
  136. ut_dulint_get_high(d)));
  137. /*****************************************************************
  138. Folds a character string ending in the null character. */
  139. UNIV_INLINE
  140. ulint
  141. ut_fold_string(
  142. /*===========*/
  143. /* out: folded value */
  144. const char* str) /* in: null-terminated string */
  145. {
  146. #ifdef UNIV_DEBUG
  147. ulint i = 0;
  148. #endif
  149. ulint fold = 0;
  150. ut_ad(str);
  151. while (*str != '') {
  152. #ifdef UNIV_DEBUG
  153. i++;
  154. ut_a(i < 100);
  155. #endif
  156. fold = ut_fold_ulint_pair(fold, (ulint)(*str));
  157. str++;
  158. }
  159. return(fold);
  160. }
  161. /*****************************************************************
  162. Folds a binary string. */
  163. UNIV_INLINE
  164. ulint
  165. ut_fold_binary(
  166. /*===========*/
  167. /* out: folded value */
  168. const byte* str, /* in: string of bytes */
  169. ulint len) /* in: length */
  170. {
  171. ulint i;
  172. ulint fold = 0;
  173. ut_ad(str);
  174. for (i = 0; i < len; i++) {
  175. fold = ut_fold_ulint_pair(fold, (ulint)(*str));
  176. str++;
  177. }
  178. return(fold);
  179. }