mirror of
https://github.com/MariaDB/server.git
synced 2025-01-19 13:32:33 +01:00
f0ae3ce9b9
Fixed compile-pentium64 scripts Fixed wrong estimate of update_with_key_prefix in sql-bench Merge bk-internal.mysql.com:/home/bk/mysql-5.1 into mysql.com:/home/my/mysql-5.1 Fixed unsafe define of uint4korr() Fixed that --extern works with mysql-test-run.pl Small trivial cleanups This also fixes a bug in counting number of rows that are updated when we have many simultanous queries Move all connection handling and command exectuion main loop from sql_parse.cc to sql_connection.cc Split handle_one_connection() into reusable sub functions. Split create_new_thread() into reusable sub functions. Added thread_scheduler; Preliminary interface code for future thread_handling code. Use 'my_thread_id' for internal thread id's Make thr_alarm_kill() to depend on thread_id instead of thread Make thr_abort_locks_for_thread() depend on thread_id instead of thread In store_globals(), set my_thread_var->id to be thd->thread_id. Use my_thread_var->id as basis for my_thread_name() The above changes makes the connection we have between THD and threads more soft. Added a lot of DBUG_PRINT() and DBUG_ASSERT() functions Fixed compiler warnings Fixed core dumps when running with --debug Removed setting of signal masks (was never used) Made event code call pthread_exit() (portability fix) Fixed that event code doesn't call DBUG_xxx functions before my_thread_init() is called. Made handling of thread_id and thd->variables.pseudo_thread_id uniform. Removed one common 'not freed memory' warning from mysqltest Fixed a couple of usage of not initialized warnings (unlikely cases) Suppress compiler warnings from bdb and (for the moment) warnings from ndb
397 lines
8.2 KiB
Text
397 lines
8.2 KiB
Text
/******************************************************************
|
|
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;
|
|
|
|
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);
|
|
}
|
|
|
|
/***********************************************************
|
|
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);
|
|
}
|
|
|
|
/***********************************************************
|
|
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));
|
|
}
|
|
|
|
/***********************************************************
|
|
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);
|
|
}
|
|
|
|
return(a);
|
|
}
|
|
|
|
/***********************************************************
|
|
Adds a ulint to a dulint. */
|
|
UNIV_INLINE
|
|
dulint
|
|
ut_dulint_add(
|
|
/*==========*/
|
|
/* out: sum a + b */
|
|
dulint a, /* in: dulint */
|
|
ulint b) /* in: ulint */
|
|
{
|
|
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);
|
|
}
|
|
|
|
/************************************************************
|
|
Rounds a dulint downward to a multiple of a power of 2. */
|
|
UNIV_INLINE
|
|
dulint
|
|
ut_dulint_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 */
|
|
{
|
|
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);
|
|
|
|
return(ut_dulint_create(high, low));
|
|
}
|
|
|
|
/************************************************************
|
|
Rounds a dulint upward to a multiple of a power of 2. */
|
|
UNIV_INLINE
|
|
dulint
|
|
ut_dulint_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 */
|
|
{
|
|
return(ut_dulint_align_down(ut_dulint_add(n, align_no - 1), align_no));
|
|
}
|
|
|
|
/************************************************************
|
|
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);
|
|
|
|
return((n + align_no - 1) & ~(align_no - 1));
|
|
}
|
|
|
|
/*************************************************************
|
|
The following function rounds up a pointer to the nearest aligned address. */
|
|
UNIV_INLINE
|
|
void*
|
|
ut_align(
|
|
/*=====*/
|
|
/* out: aligned pointer */
|
|
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);
|
|
ut_ad(ptr);
|
|
|
|
ut_ad(sizeof(void*) == sizeof(ulint));
|
|
|
|
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. */
|
|
UNIV_INLINE
|
|
void*
|
|
ut_align_down(
|
|
/*==========*/
|
|
/* out: aligned pointer */
|
|
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);
|
|
ut_ad(ptr);
|
|
|
|
ut_ad(sizeof(void*) == sizeof(ulint));
|
|
|
|
return((void*)((((ulint)ptr)) & ~(align_no - 1)));
|
|
}
|
|
|
|
/*************************************************************
|
|
The following function computes the offset of a pointer from the nearest
|
|
aligned address. */
|
|
UNIV_INLINE
|
|
ulint
|
|
ut_align_offset(
|
|
/*============*/
|
|
/* out: distance from
|
|
aligned pointer */
|
|
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);
|
|
ut_ad(ptr);
|
|
|
|
ut_ad(sizeof(void*) == sizeof(ulint));
|
|
|
|
return(((ulint)ptr) & (align_no - 1));
|
|
}
|
|
|
|
/*********************************************************************
|
|
Gets the nth bit of a ulint. */
|
|
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 */
|
|
{
|
|
ut_ad(n < 8 * sizeof(ulint));
|
|
#if TRUE != 1
|
|
# error "TRUE != 1"
|
|
#endif
|
|
return(1 & (a >> n));
|
|
}
|
|
|
|
/*********************************************************************
|
|
Sets the nth bit of a ulint. */
|
|
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 */
|
|
{
|
|
ut_ad(n < 8 * sizeof(ulint));
|
|
#if TRUE != 1
|
|
# error "TRUE != 1"
|
|
#endif
|
|
if (val) {
|
|
return(((ulint) 1 << n) | a);
|
|
} else {
|
|
return(~((ulint) 1 << n) & a);
|
|
}
|
|
}
|