diff options
Diffstat (limited to 'storage/innobase/include/ut0byte.ic')
| -rw-r--r-- | storage/innobase/include/ut0byte.ic | 372 |
1 files changed, 74 insertions, 298 deletions
diff --git a/storage/innobase/include/ut0byte.ic b/storage/innobase/include/ut0byte.ic index 01b6c29d08f..2892c5429fb 100644 --- a/storage/innobase/include/ut0byte.ic +++ b/storage/innobase/include/ut0byte.ic @@ -1,292 +1,88 @@ -/****************************************************************** -Utilities for byte operations - -(c) 1994, 1995 Innobase Oy +/***************************************************************************** -Created 5/30/1994 Heikki Tuuri -*******************************************************************/ - -/*********************************************************** -Creates a 64-bit dulint out of two ulints. */ -UNIV_INLINE -dulint -ut_dulint_create( -/*=============*/ - /* out: created dulint */ - ulint high, /* in: high-order 32 bits */ - ulint low) /* in: low-order 32 bits */ -{ - dulint res; +Copyright (c) 1994, 2009, Innobase Oy. All Rights Reserved. - ut_ad(high <= 0xFFFFFFFF); - ut_ad(low <= 0xFFFFFFFF); - - res.high = high; - res.low = low; - - return(res); -} - -/*********************************************************** -Gets the high-order 32 bits of a dulint. */ -UNIV_INLINE -ulint -ut_dulint_get_high( -/*===============*/ - /* out: 32 bits in ulint */ - dulint d) /* in: dulint */ -{ - return(d.high); -} +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. -/*********************************************************** -Gets the low-order 32 bits of a dulint. */ -UNIV_INLINE -ulint -ut_dulint_get_low( -/*==============*/ - /* out: 32 bits in ulint */ - dulint d) /* in: dulint */ -{ - return(d.low); -} +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. -/*********************************************************** -Converts a dulint (a struct of 2 ulints) to ib_longlong, which is a 64-bit -integer type. */ -UNIV_INLINE -ib_longlong -ut_conv_dulint_to_longlong( -/*=======================*/ - /* out: value in ib_longlong type */ - dulint d) /* in: dulint */ -{ - return((ib_longlong)d.low - + (((ib_longlong)d.high) << 32)); -} +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 St, Fifth Floor, Boston, MA 02110-1301 USA -/*********************************************************** -Tests if a dulint is zero. */ -UNIV_INLINE -ibool -ut_dulint_is_zero( -/*==============*/ - /* out: TRUE if zero */ - dulint a) /* in: dulint */ -{ - if ((a.low == 0) && (a.high == 0)) { +*****************************************************************************/ - return(TRUE); - } - - return(FALSE); -} - -/*********************************************************** -Compares two dulints. */ -UNIV_INLINE -int -ut_dulint_cmp( -/*==========*/ - /* out: -1 if a < b, 0 if a == b, - 1 if a > b */ - dulint a, /* in: dulint */ - dulint b) /* in: dulint */ -{ - if (a.high > b.high) { - return(1); - } else if (a.high < b.high) { - return(-1); - } else if (a.low > b.low) { - return(1); - } else if (a.low < b.low) { - return(-1); - } else { - return(0); - } -} - -/*********************************************************** -Calculates the max of two dulints. */ -UNIV_INLINE -dulint -ut_dulint_get_max( -/*==============*/ - /* out: max(a, b) */ - dulint a, /* in: dulint */ - dulint b) /* in: dulint */ -{ - if (ut_dulint_cmp(a, b) > 0) { - - return(a); - } - - return(b); -} - -/*********************************************************** -Calculates the min of two dulints. */ -UNIV_INLINE -dulint -ut_dulint_get_min( -/*==============*/ - /* out: min(a, b) */ - dulint a, /* in: dulint */ - dulint b) /* in: dulint */ -{ - if (ut_dulint_cmp(a, b) > 0) { - - return(b); - } +/**************************************************************//** +@file include/ut0byte.ic +Utilities for byte operations - return(a); -} +Created 5/30/1994 Heikki Tuuri +*******************************************************************/ -/*********************************************************** -Adds a ulint to a dulint. */ +/*******************************************************//** +Creates a 64-bit integer out of two 32-bit integers. +@return created dulint */ UNIV_INLINE -dulint -ut_dulint_add( +ib_uint64_t +ut_ull_create( /*==========*/ - /* out: sum a + b */ - dulint a, /* in: dulint */ - ulint b) /* in: ulint */ + ulint high, /*!< in: high-order 32 bits */ + ulint low) /*!< in: low-order 32 bits */ { - if (0xFFFFFFFFUL - b >= a.low) { - a.low += b; - - return(a); - } - - a.low = a.low - (0xFFFFFFFFUL - b) - 1; - - a.high++; - - return(a); -} - -/*********************************************************** -Subtracts a ulint from a dulint. */ -UNIV_INLINE -dulint -ut_dulint_subtract( -/*===============*/ - /* out: a - b */ - dulint a, /* in: dulint */ - ulint b) /* in: ulint, b <= a */ -{ - if (a.low >= b) { - a.low -= b; - - return(a); - } - - b -= a.low + 1; - - a.low = 0xFFFFFFFFUL - b; - - ut_ad(a.high > 0); - - a.high--; - - return(a); -} - -/*********************************************************** -Subtracts a dulint from another. NOTE that the difference must be positive -and smaller that 4G. */ -UNIV_INLINE -ulint -ut_dulint_minus( -/*============*/ - /* out: a - b */ - dulint a, /* in: dulint; NOTE a must be >= b and at most - 2 to power 32 - 1 greater */ - dulint b) /* in: dulint */ -{ - ulint diff; - - if (a.high == b.high) { - ut_ad(a.low >= b.low); - - return(a.low - b.low); - } - - ut_ad(a.high == b.high + 1); - - diff = (ulint)(0xFFFFFFFFUL - b.low); - diff += 1 + a.low; - - ut_ad(diff > a.low); - - return(diff); + ut_ad(high <= ULINT32_MASK); + ut_ad(low <= ULINT32_MASK); + return(((ib_uint64_t) high) << 32 | low); } -/************************************************************ -Rounds a dulint downward to a multiple of a power of 2. */ +/********************************************************//** +Rounds a 64-bit integer downward to a multiple of a power of 2. +@return rounded value */ UNIV_INLINE -dulint -ut_dulint_align_down( +ib_uint64_t +ut_uint64_align_down( /*=================*/ - /* out: rounded value */ - dulint n, /* in: number to be rounded */ - ulint align_no) /* in: align by this number which must be a - power of 2 */ + ib_uint64_t n, /*!< in: number to be rounded */ + ulint align_no) /*!< in: align by this number + which must be a power of 2 */ { - ulint low, high; - ut_ad(align_no > 0); - ut_ad(((align_no - 1) & align_no) == 0); - - low = ut_dulint_get_low(n); - high = ut_dulint_get_high(n); - - low = low & ~(align_no - 1); + ut_ad(ut_is_2pow(align_no)); - return(ut_dulint_create(high, low)); + return(n & ~((ib_uint64_t) align_no - 1)); } -/************************************************************ -Rounds a dulint upward to a multiple of a power of 2. */ +/********************************************************//** +Rounds ib_uint64_t upward to a multiple of a power of 2. +@return rounded value */ UNIV_INLINE -dulint -ut_dulint_align_up( +ib_uint64_t +ut_uint64_align_up( /*===============*/ - /* out: rounded value */ - dulint n, /* in: number to be rounded */ - ulint align_no) /* in: align by this number which must be a - power of 2 */ + ib_uint64_t n, /*!< in: number to be rounded */ + ulint align_no) /*!< in: align by this number + which must be a power of 2 */ { - return(ut_dulint_align_down(ut_dulint_add(n, align_no - 1), align_no)); -} + ib_uint64_t align_1 = (ib_uint64_t) align_no - 1; -/************************************************************ -The following function calculates the value of an integer n rounded -to the least product of align_no which is >= n. align_no -has to be a power of 2. */ -UNIV_INLINE -ulint -ut_calc_align( -/*==========*/ - /* out: rounded value */ - ulint n, /* in: number to be rounded */ - ulint align_no) /* in: align by this number */ -{ ut_ad(align_no > 0); - ut_ad(((align_no - 1) & align_no) == 0); + ut_ad(ut_is_2pow(align_no)); - return((n + align_no - 1) & ~(align_no - 1)); + return((n + align_1) & ~align_1); } -/************************************************************* -The following function rounds up a pointer to the nearest aligned address. */ +/*********************************************************//** +The following function rounds up a pointer to the nearest aligned address. +@return aligned pointer */ UNIV_INLINE void* ut_align( /*=====*/ - /* out: aligned pointer */ - void* ptr, /* in: pointer */ - ulint align_no) /* in: align by this number */ + const void* ptr, /*!< in: pointer */ + ulint align_no) /*!< in: align by this number */ { ut_ad(align_no > 0); ut_ad(((align_no - 1) & align_no) == 0); @@ -297,34 +93,16 @@ ut_align( return((void*)((((ulint)ptr) + align_no - 1) & ~(align_no - 1))); } -/************************************************************ -The following function calculates the value of an integer n rounded -to the biggest product of align_no which is <= n. align_no has to be a -power of 2. */ -UNIV_INLINE -ulint -ut_calc_align_down( -/*===============*/ - /* out: rounded value */ - ulint n, /* in: number to be rounded */ - ulint align_no) /* in: align by this number */ -{ - ut_ad(align_no > 0); - ut_ad(((align_no - 1) & align_no) == 0); - - return(n & ~(align_no - 1)); -} - -/************************************************************* +/*********************************************************//** The following function rounds down a pointer to the nearest -aligned address. */ +aligned address. +@return aligned pointer */ UNIV_INLINE void* ut_align_down( /*==========*/ - /* out: aligned pointer */ - void* ptr, /* in: pointer */ - ulint align_no) /* in: align by this number */ + const void* ptr, /*!< in: pointer */ + ulint align_no) /*!< in: align by this number */ { ut_ad(align_no > 0); ut_ad(((align_no - 1) & align_no) == 0); @@ -335,17 +113,16 @@ ut_align_down( return((void*)((((ulint)ptr)) & ~(align_no - 1))); } -/************************************************************* +/*********************************************************//** The following function computes the offset of a pointer from the nearest -aligned address. */ +aligned address. +@return distance from aligned pointer */ UNIV_INLINE ulint ut_align_offset( /*============*/ - /* out: distance from - aligned pointer */ - const void* ptr, /* in: pointer */ - ulint align_no) /* in: align by this number */ + const void* ptr, /*!< in: pointer */ + ulint align_no) /*!< in: align by this number */ { ut_ad(align_no > 0); ut_ad(((align_no - 1) & align_no) == 0); @@ -356,16 +133,15 @@ ut_align_offset( return(((ulint)ptr) & (align_no - 1)); } -/********************************************************************* -Gets the nth bit of a ulint. */ +/*****************************************************************//** +Gets the nth bit of a ulint. +@return TRUE if nth bit is 1; 0th bit is defined to be the least significant */ UNIV_INLINE ibool ut_bit_get_nth( /*===========*/ - /* out: TRUE if nth bit is 1; 0th bit is defined to - be the least significant */ - ulint a, /* in: ulint */ - ulint n) /* in: nth bit requested */ + ulint a, /*!< in: ulint */ + ulint n) /*!< in: nth bit requested */ { ut_ad(n < 8 * sizeof(ulint)); #if TRUE != 1 @@ -374,16 +150,16 @@ ut_bit_get_nth( return(1 & (a >> n)); } -/********************************************************************* -Sets the nth bit of a ulint. */ +/*****************************************************************//** +Sets the nth bit of a ulint. +@return the ulint with the bit set as requested */ UNIV_INLINE ulint ut_bit_set_nth( /*===========*/ - /* out: the ulint with the bit set as requested */ - ulint a, /* in: ulint */ - ulint n, /* in: nth bit requested */ - ibool val) /* in: value for the bit to set */ + ulint a, /*!< in: ulint */ + ulint n, /*!< in: nth bit requested */ + ibool val) /*!< in: value for the bit to set */ { ut_ad(n < 8 * sizeof(ulint)); #if TRUE != 1 |