← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/ut0byte.ic

  • Committer: Brian Aker
  • Date: 2008-10-28 08:36:02 UTC
  • mfrom: (520.4.13 merge-innodb-plugin)
  • Revision ID: brian@tangent.org-20081028083602-0p3zzlhlxr5q2sqo
Merging Monty's work

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/ut0byte.ic
52
52
}
53
53
 
54
54
/***********************************************************
55
 
Converts a dulint (a struct of 2 ulints) to ib_longlong, which is a 64-bit
 
55
Converts a dulint (a struct of 2 ulints) to ib_int64_t, which is a 64-bit
56
56
integer type. */
57
57
UNIV_INLINE
58
 
ib_longlong
 
58
ib_int64_t
59
59
ut_conv_dulint_to_longlong(
60
60
/*=======================*/
61
 
                        /* out: value in ib_longlong type */
 
61
                        /* out: value in ib_int64_t type */
62
62
        dulint  d)      /* in: dulint */
63
63
{
64
 
        return((ib_longlong)d.low
65
 
               + (((ib_longlong)d.high) << 32));
 
64
        return((ib_int64_t)d.low
 
65
               + (((ib_int64_t)d.high) << 32));
66
66
}
67
67
 
68
68
/***********************************************************
261
261
}
262
262
 
263
263
/************************************************************
264
 
The following function calculates the value of an integer n rounded
265
 
to the least product of align_no which is >= n. align_no
266
 
has to be a power of 2. */
267
 
UNIV_INLINE
268
 
ulint
269
 
ut_calc_align(
270
 
/*==========*/
271
 
                                /* out: rounded value */
272
 
        ulint    n,             /* in: number to be rounded */
273
 
        ulint    align_no)      /* in: align by this number */
274
 
{
275
 
        ut_ad(align_no > 0);
276
 
        ut_ad(((align_no - 1) & align_no) == 0);
277
 
 
278
 
        return((n + align_no - 1) & ~(align_no - 1));
 
264
Rounds ib_uint64_t downward to a multiple of a power of 2. */
 
265
UNIV_INLINE
 
266
ib_uint64_t
 
267
ut_uint64_align_down(
 
268
/*=================*/
 
269
                                        /* out: rounded value */
 
270
        ib_uint64_t      n,             /* in: number to be rounded */
 
271
        ulint            align_no)      /* in: align by this number
 
272
                                        which must be a power of 2 */
 
273
{
 
274
        ut_ad(align_no > 0);
 
275
        ut_ad(ut_is_2pow(align_no));
 
276
 
 
277
        return(n & ~((ib_uint64_t) align_no - 1));
 
278
}
 
279
 
 
280
/************************************************************
 
281
Rounds ib_uint64_t upward to a multiple of a power of 2. */
 
282
UNIV_INLINE
 
283
ib_uint64_t
 
284
ut_uint64_align_up(
 
285
/*===============*/
 
286
                                        /* out: rounded value */
 
287
        ib_uint64_t      n,             /* in: number to be rounded */
 
288
        ulint            align_no)      /* in: align by this number
 
289
                                        which must be a power of 2 */
 
290
{
 
291
        ib_uint64_t     align_1 = (ib_uint64_t) align_no - 1;
 
292
 
 
293
        ut_ad(align_no > 0);
 
294
        ut_ad(ut_is_2pow(align_no));
 
295
 
 
296
        return((n + align_1) & ~align_1);
279
297
}
280
298
 
281
299
/*************************************************************
285
303
ut_align(
286
304
/*=====*/
287
305
                                /* out: aligned pointer */
288
 
        const void*     ptr,            /* in: pointer */
 
306
        void*   ptr,            /* in: pointer */
289
307
        ulint   align_no)       /* in: align by this number */
290
308
{
291
309
        ut_ad(align_no > 0);
297
315
        return((void*)((((ulint)ptr) + align_no - 1) & ~(align_no - 1)));
298
316
}
299
317
 
300
 
/************************************************************
301
 
The following function calculates the value of an integer n rounded
302
 
to the biggest product of align_no which is <= n. align_no has to be a
303
 
power of 2. */
304
 
UNIV_INLINE
305
 
ulint
306
 
ut_calc_align_down(
307
 
/*===============*/
308
 
                                /* out: rounded value */
309
 
        ulint    n,              /* in: number to be rounded */
310
 
        ulint    align_no)       /* in: align by this number */
311
 
{
312
 
        ut_ad(align_no > 0);
313
 
        ut_ad(((align_no - 1) & align_no) == 0);
314
 
 
315
 
        return(n & ~(align_no - 1));
316
 
}
317
 
 
318
318
/*************************************************************
319
319
The following function rounds down a pointer to the nearest
320
320
aligned address. */
322
322
void*
323
323
ut_align_down(
324
324
/*==========*/
325
 
                                /* out: aligned pointer */
 
325
                                        /* out: aligned pointer */
326
326
        const void*     ptr,            /* in: pointer */
327
 
        ulint   align_no)       /* in: align by this number */
 
327
        ulint           align_no)       /* in: align by this number */
328
328
{
329
329
        ut_ad(align_no > 0);
330
330
        ut_ad(((align_no - 1) & align_no) == 0);