1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
/*****************************************************************************
Copyright (c) 1994, 2015, Oracle and/or its affiliates. All Rights Reserved.
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA
*****************************************************************************/
/**************************************************************//**
@file include/ut0ut.ic
Various utilities
Created 5/30/1994 Heikki Tuuri
*******************************************************************/
#include <algorithm>
/** Calculate the minimum of two pairs.
@param[out] min_hi MSB of the minimum pair
@param[out] min_lo LSB of the minimum pair
@param[in] a_hi MSB of the first pair
@param[in] a_lo LSB of the first pair
@param[in] b_hi MSB of the second pair
@param[in] b_lo LSB of the second pair */
UNIV_INLINE
void
ut_pair_min(
ulint* min_hi,
ulint* min_lo,
ulint a_hi,
ulint a_lo,
ulint b_hi,
ulint b_lo)
{
if (a_hi == b_hi) {
*min_hi = a_hi;
*min_lo = std::min(a_lo, b_lo);
} else if (a_hi < b_hi) {
*min_hi = a_hi;
*min_lo = a_lo;
} else {
*min_hi = b_hi;
*min_lo = b_lo;
}
}
/******************************************************//**
Compares two ulints.
@return 1 if a > b, 0 if a == b, -1 if a < b */
UNIV_INLINE
int
ut_ulint_cmp(
/*=========*/
ulint a, /*!< in: ulint */
ulint b) /*!< in: ulint */
{
if (a < b) {
return(-1);
} else if (a == b) {
return(0);
} else {
return(1);
}
}
/** Compare two pairs of integers.
@param[in] a_h more significant part of first pair
@param[in] a_l less significant part of first pair
@param[in] b_h more significant part of second pair
@param[in] b_l less significant part of second pair
@return comparison result of (a_h,a_l) and (b_h,b_l)
@retval -1 if (a_h,a_l) is less than (b_h,b_l)
@retval 0 if (a_h,a_l) is equal to (b_h,b_l)
@retval 1 if (a_h,a_l) is greater than (b_h,b_l) */
UNIV_INLINE
int
ut_pair_cmp(
ulint a_h,
ulint a_l,
ulint b_h,
ulint b_l)
{
if (a_h < b_h) {
return(-1);
}
if (a_h > b_h) {
return(1);
}
return(ut_ulint_cmp(a_l, b_l));
}
/*************************************************************//**
Calculates fast the 2-logarithm of a number, rounded upward to an
integer.
@return logarithm in the base 2, rounded upward */
UNIV_INLINE
ulint
ut_2_log(
/*=====*/
ulint n) /*!< in: number != 0 */
{
ulint res;
res = 0;
ut_ad(n > 0);
n = n - 1;
for (;;) {
n = n / 2;
if (n == 0) {
break;
}
res++;
}
return(res + 1);
}
/*************************************************************//**
Calculates 2 to power n.
@return 2 to power n */
UNIV_INLINE
ulint
ut_2_exp(
/*=====*/
ulint n) /*!< in: number */
{
return((ulint) 1 << n);
}
|
