Commit b2474e7a authored by unknown's avatar unknown
Browse files

rem0rec.ic: 

  Do not use short int in rem0rec.ic, since its size is not fixed in ANSI C; improve comments of the relative offset field in a record; use mach_read_from_2() to read the relative offset field to save CPU time, if the compiler does not optimize a more complex access function


innobase/include/rem0rec.ic:
  Do not use short int in rem0rec.ic, since its size is not fixed in ANSI C; improve comments of the relative offset field in a record; use mach_read_from_2() to read the relative offset field to save CPU time, if the compiler does not optimize a more complex access function
parent e3f1d562

innobase/include/rem0rec.ic

+56 −25
Original line number Diff line number Diff line
@@ -40,8 +40,18 @@ most significant bytes and bits are written below less significant. 


	(1) byte offset		(2) bit usage within byte

	downward from

	origin ->	1	8 bits pointer to next record (relative)

			2	8 bits pointer to next record (relative)

	origin ->	1	8 bits relative offset of next record

			2	8 bits relative offset of next record

				  the relative offset is an unsigned 16-bit

				  integer:

				  (offset_of_next_record

				   - offset_of_this_record) mod 64Ki,

				  where mod is the modulo as a non-negative

				  number;

				  we can calculate the the offset of the next

				  record with the formula:

				  relative_offset + offset_of_this_record

				  mod UNIV_PAGE_SIZE

			3	3 bits status:

					000=conventional record

					001=node pointer record (inside B-tree)
@@ -252,26 +262,37 @@ UNIV_INLINE 
ulint 

rec_get_next_offs(

/*==============*/

			/* out: the page offset of the next chained record */

			/* out: the page offset of the next chained record, or

			0 if none */

	rec_t*	rec,	/* in: physical record */

	ibool	comp)	/* in: TRUE=compact page format */

{	

	ulint	field_value;

		

	ut_ad(REC_NEXT_MASK == 0xFFFFUL);

	ut_ad(REC_NEXT_SHIFT == 0);



	field_value = mach_read_from_2(rec - REC_NEXT);



	if (comp) {

		lint ret = (signed short) rec_get_bit_field_2(rec, REC_NEXT,

						REC_NEXT_MASK, REC_NEXT_SHIFT);

#if UNIV_PAGE_SIZE <= 32768

		/* with 64 KiB page size, the pointer will "wrap around",

		and the following assertions are invalid */

		ut_ad(ret + ut_align_offset(rec, UNIV_PAGE_SIZE) <

							UNIV_PAGE_SIZE);

		/* Note that for 64 KiB pages, field_value can 'wrap around'

		and the debug assertion is not valid */



		ut_ad((int16_t)field_value

		       + ut_align_offset(rec, UNIV_PAGE_SIZE)

		      < UNIV_PAGE_SIZE);

#endif

		return(ret ? ut_align_offset(rec + ret, UNIV_PAGE_SIZE) : 0);

		if (field_value == 0) {



			return(0);

		}

	else {

		ulint ret = rec_get_bit_field_2(rec, REC_NEXT,

						REC_NEXT_MASK, REC_NEXT_SHIFT);

		ut_ad(ret < UNIV_PAGE_SIZE);

		return(ret);

		

		return(ut_align_offset(rec + field_value, UNIV_PAGE_SIZE));

	} else {

		ut_ad(field_value < UNIV_PAGE_SIZE);



		return(field_value);

	}

}
@@ -284,21 +305,31 @@ rec_set_next_offs( 
/*==============*/

	rec_t*	rec,	/* in: physical record */

	ibool	comp,	/* in: TRUE=compact page format */

	ulint	next)	/* in: offset of the next record */

	ulint	next)	/* in: offset of the next record, or 0 if none */

{

	ut_ad(rec);

	ut_ad(UNIV_PAGE_SIZE > next);

	ut_ad(REC_NEXT_MASK == 0xFFFFUL);

	ut_ad(REC_NEXT_SHIFT == 0);



	if (comp) {

		rec_set_bit_field_2(rec, next

				? (next - ut_align_offset(rec, UNIV_PAGE_SIZE))

#ifdef UNIV_DEBUG /* avoid an assertion failure */

				& (REC_NEXT_MASK >> REC_NEXT_SHIFT)

#endif

				: 0, REC_NEXT, REC_NEXT_MASK, REC_NEXT_SHIFT);

		ulint field_value;



		if (next) {

			/* The following two statements calculate

			next - offset_of_rec mod 64Ki, where mod is the modulo

			as a non-negative number */

		

			field_value = (ulint)((lint)next 

				- (lint)ut_align_offset(rec, UNIV_PAGE_SIZE));

			field_value &= REC_NEXT_MASK;

		} else {

			field_value = 0;

		}



		mach_write_to_2(rec - REC_NEXT, field_value);

	} else {

		rec_set_bit_field_2(rec, next,

				REC_NEXT, REC_NEXT_MASK, REC_NEXT_SHIFT);

		mach_write_to_2(rec - REC_NEXT, next);

	}

}