Below is the list of changes that have just been committed into a local
5.0 repository of marko. When marko does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html
ChangeSet
1.1905 05/07/11 13:50:27 marko@stripped +9 -0
InnoDB: Small optimizations
innobase/row/row0sel.c
1.95 05/07/11 13:50:16 marko@stripped +9 -10
Add some UNIV_UNLIKELY hints
innobase/page/page0page.c
1.32 05/07/11 13:50:16 marko@stripped +47 -53
page_copy_rec_list_end_no_locks(),
page_copy_rec_list_end(),
page_copy_rec_list_start(),
page_delete_rec_list_end(),
page_delete_rec_list_start(),
page_move_rec_list_end(),
page_move_rec_list_start():
Remove redundant parameter "page" and eliminate some local variables
innobase/page/page0cur.c
1.28 05/07/11 13:50:16 marko@stripped +144 -114
page_cur_open_on_rnd_user_rec(): Move condition to end of loop
page_cur_insert_rec_write_log(): Eliminate some local variables
page_cur_parse_insert_rec(): Eliminate extra_info_yes to reduce
register spilling on x86
page_cur_insert_rec_low(): Eliminate some local variables
page_copy_rec_list_end_to_created_page(): Remove 2nd parameter;
move termination condition to end of loop, branch less on comp flag
innobase/include/page0page.ic
1.15 05/07/11 13:50:16 marko@stripped +21 -5
page_rec_set_next(): Remove variable "page"
Add page_rec_get_base_extra_size()
innobase/include/page0page.h
1.9 05/07/11 13:50:16 marko@stripped +10 -7
Add page_rec_get_base_extra_size().
page_copy_rec_list_end_no_locks(), page_copy_rec_list_start(),
page_delete_rec_list_end(), page_delete_rec_list_start(),
page_move_rec_list_end(), page_move_rec_list_start():
Remove redundant parameter "page".
innobase/include/page0cur.h
1.9 05/07/11 13:50:16 marko@stripped +0 -1
page_copy_rec_list_end_to_created_page(): Remove 2nd parameter
innobase/include/buf0buf.ic
1.21 05/07/11 13:50:16 marko@stripped +1 -4
Remove temporary variable
innobase/btr/btr0cur.c
1.55 05/07/11 13:50:15 marko@stripped +16 -14
btr_cur_search_to_nth_level(): Move a condition to the end of the
loop, as it cannot hold on the first iteration.
innobase/btr/btr0btr.c
1.45 05/07/11 13:50:15 marko@stripped +7 -7
Remove redundant "page" parameters of some page0page.c functions.
# This is a BitKeeper patch. What follows are the unified diffs for the
# set of deltas contained in the patch. The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User: marko
# Host: hundin.mysql.fi
# Root: /home/marko/mysql-5.0-current
--- 1.44/innobase/btr/btr0btr.c 2005-06-27 18:57:25 +03:00
+++ 1.45/innobase/btr/btr0btr.c 2005-07-11 13:50:15 +03:00
@@ -876,7 +876,7 @@
/* Copy the records from the temporary space to the recreated page;
do not copy the lock bits yet */
- page_copy_rec_list_end_no_locks(page, new_page,
+ page_copy_rec_list_end_no_locks(page,
page_get_infimum_rec(new_page), index, mtr);
/* Copy max trx id to recreated page */
page_set_max_trx_id(page, page_get_max_trx_id(new_page));
@@ -1025,7 +1025,7 @@
/* Move the records from root to the new page */
- page_move_rec_list_end(new_page, root, page_get_infimum_rec(root),
+ page_move_rec_list_end(new_page, page_get_infimum_rec(root),
cursor->index, mtr);
/* If this is a pessimistic insert which is actually done to
perform a pessimistic update then we have stored the lock
@@ -1681,7 +1681,7 @@
if (direction == FSP_DOWN) {
/* fputs("Split left\n", stderr); */
- page_move_rec_list_start(new_page, page, move_limit,
+ page_move_rec_list_start(new_page, move_limit,
cursor->index, mtr);
left_page = new_page;
right_page = page;
@@ -1690,7 +1690,7 @@
} else {
/* fputs("Split right\n", stderr); */
- page_move_rec_list_end(new_page, page, move_limit,
+ page_move_rec_list_end(new_page, move_limit,
cursor->index, mtr);
left_page = page;
right_page = new_page;
@@ -1958,7 +1958,7 @@
btr_page_empty(father_page, mtr);
/* Move records to the father */
- page_copy_rec_list_end(father_page, page, page_get_infimum_rec(page),
+ page_copy_rec_list_end(father_page, page_get_infimum_rec(page),
index, mtr);
lock_update_copy_and_discard(father_page, page);
@@ -2120,14 +2120,14 @@
if (is_left) {
orig_pred = page_rec_get_prev(
page_get_supremum_rec(merge_page));
- page_copy_rec_list_start(merge_page, page,
+ page_copy_rec_list_start(merge_page,
page_get_supremum_rec(page), cursor->index, mtr);
lock_update_merge_left(merge_page, orig_pred, page);
} else {
orig_succ = page_rec_get_next(
page_get_infimum_rec(merge_page));
- page_copy_rec_list_end(merge_page, page,
+ page_copy_rec_list_end(merge_page,
page_get_infimum_rec(page), cursor->index, mtr);
lock_update_merge_right(orig_succ, page);
--- 1.54/innobase/btr/btr0cur.c 2005-07-05 12:10:10 +03:00
+++ 1.55/innobase/btr/btr0cur.c 2005-07-11 13:50:15 +03:00
@@ -405,19 +405,6 @@
/* Loop and search until we arrive at the desired level */
for (;;) {
- if ((height == 0) && (latch_mode <= BTR_MODIFY_LEAF)) {
-
- rw_latch = latch_mode;
-
- if (insert_planned && ibuf_should_try(index,
- ignore_sec_unique)) {
-
- /* Try insert to the insert buffer if the
- page is not in the buffer pool */
-
- buf_mode = BUF_GET_IF_IN_POOL;
- }
- }
retry_page_get:
page = buf_page_get_gen(space, page_no, rw_latch, guess,
buf_mode,
@@ -460,7 +447,7 @@
ut_ad(0 == ut_dulint_cmp(tree->id,
btr_page_get_index_id(page)));
- if (height == ULINT_UNDEFINED) {
+ if (UNIV_UNLIKELY(height == ULINT_UNDEFINED)) {
/* We are in the root node */
height = btr_page_get_level(page, mtr);
@@ -522,6 +509,21 @@
ut_ad(height > 0);
height--;
+
+ if ((height == 0) && (latch_mode <= BTR_MODIFY_LEAF)) {
+
+ rw_latch = latch_mode;
+
+ if (insert_planned && ibuf_should_try(index,
+ ignore_sec_unique)) {
+
+ /* Try insert to the insert buffer if the
+ page is not in the buffer pool */
+
+ buf_mode = BUF_GET_IF_IN_POOL;
+ }
+ }
+
guess = NULL;
node_ptr = page_cur_get_rec(page_cursor);
--- 1.20/innobase/include/buf0buf.ic 2005-06-15 12:50:18 +03:00
+++ 1.21/innobase/include/buf0buf.ic 2005-07-11 13:50:16 +03:00
@@ -614,8 +614,6 @@
RW_NO_LATCH */
mtr_t* mtr) /* in: mtr */
{
- ulint buf_fix_count;
-
ut_ad(block);
mutex_enter_fast(&(buf_pool->mutex));
@@ -631,8 +629,7 @@
#ifdef UNIV_SYNC_DEBUG
rw_lock_s_unlock(&(block->debug_latch));
#endif
- buf_fix_count = block->buf_fix_count;
- block->buf_fix_count = buf_fix_count - 1;
+ block->buf_fix_count--;
mutex_exit(&(buf_pool->mutex));
--- 1.8/innobase/include/page0cur.h 2005-06-30 11:14:57 +03:00
+++ 1.9/innobase/include/page0cur.h 2005-07-11 13:50:16 +03:00
@@ -173,7 +173,6 @@
page_copy_rec_list_end_to_created_page(
/*===================================*/
page_t* new_page, /* in: index page to copy to */
- page_t* page, /* in: index page */
rec_t* rec, /* in: first record to copy */
dict_index_t* index, /* in: record descriptor */
mtr_t* mtr); /* in: mtr */
--- 1.8/innobase/include/page0page.h 2005-04-25 10:14:26 +03:00
+++ 1.9/innobase/include/page0page.h 2005-07-11 13:50:16 +03:00
@@ -513,6 +513,16 @@
/* out: free space */
ulint comp) /* in: nonzero=compact page format */
__attribute__((const));
+/**************************************************************
+Returns the base extra size of a physical record. This is the
+size of the fixed header, independent of the record size. */
+UNIV_INLINE
+ulint
+page_rec_get_base_extra_size(
+/*=========================*/
+ /* out: REC_N_NEW_EXTRA_BYTES
+ or REC_N_OLD_EXTRA_BYTES */
+ const rec_t* rec); /* in: physical record */
/****************************************************************
Returns the sum of the sizes of the records in the record list
excluding the infimum and supremum records. */
@@ -564,7 +574,6 @@
page_copy_rec_list_end_no_locks(
/*============================*/
page_t* new_page, /* in: index page to copy to */
- page_t* page, /* in: index page */
rec_t* rec, /* in: record on page */
dict_index_t* index, /* in: record descriptor */
mtr_t* mtr); /* in: mtr */
@@ -577,7 +586,6 @@
page_copy_rec_list_end(
/*===================*/
page_t* new_page, /* in: index page to copy to */
- page_t* page, /* in: index page */
rec_t* rec, /* in: record on page */
dict_index_t* index, /* in: record descriptor */
mtr_t* mtr); /* in: mtr */
@@ -590,7 +598,6 @@
page_copy_rec_list_start(
/*=====================*/
page_t* new_page, /* in: index page to copy to */
- page_t* page, /* in: index page */
rec_t* rec, /* in: record on page */
dict_index_t* index, /* in: record descriptor */
mtr_t* mtr); /* in: mtr */
@@ -601,7 +608,6 @@
void
page_delete_rec_list_end(
/*=====================*/
- page_t* page, /* in: index page */
rec_t* rec, /* in: record on page */
dict_index_t* index, /* in: record descriptor */
ulint n_recs, /* in: number of records to delete,
@@ -617,7 +623,6 @@
void
page_delete_rec_list_start(
/*=======================*/
- page_t* page, /* in: index page */
rec_t* rec, /* in: record on page */
dict_index_t* index, /* in: record descriptor */
mtr_t* mtr); /* in: mtr */
@@ -629,7 +634,6 @@
page_move_rec_list_end(
/*===================*/
page_t* new_page, /* in: index page where to move */
- page_t* page, /* in: index page */
rec_t* split_rec, /* in: first record to move */
dict_index_t* index, /* in: record descriptor */
mtr_t* mtr); /* in: mtr */
@@ -641,7 +645,6 @@
page_move_rec_list_start(
/*=====================*/
page_t* new_page, /* in: index page where to move */
- page_t* page, /* in: index page */
rec_t* split_rec, /* in: first record not to move */
dict_index_t* index, /* in: record descriptor */
mtr_t* mtr); /* in: mtr */
--- 1.14/innobase/include/page0page.ic 2005-06-16 16:59:41 +03:00
+++ 1.15/innobase/include/page0page.ic 2005-07-11 13:50:16 +03:00
@@ -588,22 +588,21 @@
rec_t* next) /* in: pointer to next record, must not be page
infimum */
{
- page_t* page;
ulint offs;
ut_ad(page_rec_check(rec));
ut_ad(!page_rec_is_supremum(rec));
- page = ut_align_down(rec, UNIV_PAGE_SIZE);
if (next) {
ut_ad(!page_rec_is_infimum(next));
- ut_ad(page == ut_align_down(next, UNIV_PAGE_SIZE));
- offs = (ulint) (next - page);
+ ut_ad(ut_align_down(rec, UNIV_PAGE_SIZE)
+ == ut_align_down(next, UNIV_PAGE_SIZE));
+ offs = ut_align_offset(next, UNIV_PAGE_SIZE);
} else {
offs = 0;
}
- rec_set_next_offs(rec, page_is_comp(page), offs);
+ rec_set_next_offs(rec, page_rec_is_comp(rec), offs);
}
/****************************************************************
@@ -668,6 +667,23 @@
}
return(rec);
+}
+
+/**************************************************************
+Returns the base extra size of a physical record. This is the
+size of the fixed header, independent of the record size. */
+UNIV_INLINE
+ulint
+page_rec_get_base_extra_size(
+/*=========================*/
+ /* out: REC_N_NEW_EXTRA_BYTES
+ or REC_N_OLD_EXTRA_BYTES */
+ const rec_t* rec) /* in: physical record */
+{
+#if REC_N_NEW_EXTRA_BYTES + 1 != REC_N_OLD_EXTRA_BYTES
+# error "REC_N_NEW_EXTRA_BYTES + 1 != REC_N_OLD_EXTRA_BYTES"
+#endif
+ return(REC_N_NEW_EXTRA_BYTES + !page_rec_is_comp(rec));
}
/****************************************************************
--- 1.27/innobase/page/page0cur.c 2005-07-05 12:10:10 +03:00
+++ 1.28/innobase/page/page0cur.c 2005-07-11 13:50:16 +03:00
@@ -483,7 +483,7 @@
ulint rnd;
rec_t* rec;
- if (page_get_n_recs(page) == 0) {
+ if (UNIV_UNLIKELY(page_get_n_recs(page) == 0)) {
page_cur_position(page_get_infimum_rec(page), cursor);
return;
@@ -495,13 +495,9 @@
rec = page_get_infimum_rec(page);
- rec = page_rec_get_next(rec);
-
- while (rnd > 0) {
+ do {
rec = page_rec_get_next(rec);
-
- rnd--;
- }
+ } while (rnd-- > 0);
page_cur_position(rec, cursor);
}
@@ -522,19 +518,14 @@
ulint cur_rec_size;
ulint extra_size;
ulint cur_extra_size;
- ulint min_rec_size;
- byte* ins_ptr;
- byte* cur_ptr;
- ulint extra_info_yes;
+ const byte* ins_ptr;
byte* log_ptr;
- byte* log_end;
+ const byte* log_end;
ulint i;
- ulint comp;
ut_a(rec_size < UNIV_PAGE_SIZE);
ut_ad(buf_frame_align(insert_rec) == buf_frame_align(cursor_rec));
ut_ad(!page_rec_is_comp(insert_rec) == !index->table->comp);
- comp = page_rec_is_comp(insert_rec);
{
mem_heap_t* heap = NULL;
@@ -567,45 +558,55 @@
i = 0;
if (cur_extra_size == extra_size) {
- min_rec_size = ut_min(cur_rec_size, rec_size);
+ ulint min_rec_size = ut_min(cur_rec_size, rec_size);
- cur_ptr = cursor_rec - cur_extra_size;
+ const byte* cur_ptr = cursor_rec - cur_extra_size;
/* Find out the first byte in insert_rec which differs from
cursor_rec; skip the bytes in the record info */
- for (;;) {
- if (i >= min_rec_size) {
-
- break;
- } else if (*ins_ptr == *cur_ptr) {
+ do {
+ if (*ins_ptr == *cur_ptr) {
i++;
ins_ptr++;
cur_ptr++;
} else if ((i < extra_size)
- && (i >= extra_size - (comp
- ? REC_N_NEW_EXTRA_BYTES
- : REC_N_OLD_EXTRA_BYTES))) {
+ && (i >= extra_size -
+ page_rec_get_base_extra_size(
+ insert_rec))) {
i = extra_size;
ins_ptr = insert_rec;
cur_ptr = cursor_rec;
} else {
break;
}
- }
+ } while (i < min_rec_size);
}
if (mtr_get_log_mode(mtr) != MTR_LOG_SHORT_INSERTS) {
- log_ptr = mlog_open_and_write_index(mtr, insert_rec, index,
- comp
- ? MLOG_COMP_REC_INSERT : MLOG_REC_INSERT,
- 2 + 5 + 1 + 5 + 5 + MLOG_BUF_MARGIN);
+ if (page_rec_is_comp(insert_rec)) {
+ log_ptr = mlog_open_and_write_index(mtr, insert_rec,
+ index, MLOG_COMP_REC_INSERT,
+ 2 + 5 + 1 + 5 + 5 + MLOG_BUF_MARGIN);
+ if (UNIV_UNLIKELY(!log_ptr)) {
+ /* Logging in mtr is switched off
+ during crash recovery: in that case
+ mlog_open returns NULL */
+ return;
+ }
+ } else {
+ log_ptr = mlog_open(mtr, 11
+ + 2 + 5 + 1 + 5 + 5 + MLOG_BUF_MARGIN);
+ if (UNIV_UNLIKELY(!log_ptr)) {
+ /* Logging in mtr is switched off
+ during crash recovery: in that case
+ mlog_open returns NULL */
+ return;
+ }
- if (!log_ptr) {
- /* Logging in mtr is switched off during crash
- recovery: in that case mlog_open returns NULL */
- return;
+ log_ptr = mlog_write_initial_log_record_fast(
+ insert_rec, MLOG_REC_INSERT, log_ptr, mtr);
}
log_end = &log_ptr[2 + 5 + 1 + 5 + 5 + MLOG_BUF_MARGIN];
@@ -623,24 +624,33 @@
log_end = &log_ptr[5 + 1 + 5 + 5 + MLOG_BUF_MARGIN];
}
- if ((rec_get_info_and_status_bits(insert_rec, comp) !=
- rec_get_info_and_status_bits(cursor_rec, comp))
- || (extra_size != cur_extra_size)
- || (rec_size != cur_rec_size)) {
+ if (page_rec_is_comp(insert_rec)) {
+ if (UNIV_UNLIKELY
+ (rec_get_info_and_status_bits(insert_rec, TRUE) !=
+ rec_get_info_and_status_bits(cursor_rec, TRUE))) {
- extra_info_yes = 1;
+ goto need_extra_info;
+ }
} else {
- extra_info_yes = 0;
+ if (UNIV_UNLIKELY
+ (rec_get_info_and_status_bits(insert_rec, FALSE) !=
+ rec_get_info_and_status_bits(cursor_rec, FALSE))) {
+
+ goto need_extra_info;
+ }
}
-
- /* Write the record end segment length and the extra info storage
- flag */
- log_ptr += mach_write_compressed(log_ptr, 2 * (rec_size - i)
- + extra_info_yes);
- if (extra_info_yes) {
+
+ if (extra_size != cur_extra_size || rec_size != cur_rec_size) {
+need_extra_info:
+ /* Write the record end segment length
+ and the extra info storage flag */
+ log_ptr += mach_write_compressed(log_ptr,
+ 2 * (rec_size - i) + 1);
+
/* Write the info bits */
mach_write_to_1(log_ptr,
- rec_get_info_and_status_bits(insert_rec, comp));
+ rec_get_info_and_status_bits(insert_rec,
+ page_rec_is_comp(insert_rec)));
log_ptr++;
/* Write the record origin offset */
@@ -651,8 +661,12 @@
ut_a(i < UNIV_PAGE_SIZE);
ut_a(extra_size < UNIV_PAGE_SIZE);
+ } else {
+ /* Write the record end segment length
+ and the extra info storage flag */
+ log_ptr += mach_write_compressed(log_ptr, 2 * (rec_size - i));
}
-
+
/* Write to the log the inserted index record end segment which
differs from the cursor record */
@@ -682,7 +696,6 @@
page_t* page, /* in: page or NULL */
mtr_t* mtr) /* in: mtr or NULL */
{
- ulint extra_info_yes;
ulint offset = 0; /* remove warning */
ulint origin_offset;
ulint end_seg_len;
@@ -725,16 +738,13 @@
return(NULL);
}
- extra_info_yes = end_seg_len & 0x1UL;
- end_seg_len >>= 1;
-
- if (end_seg_len >= UNIV_PAGE_SIZE) {
+ if (UNIV_UNLIKELY(end_seg_len >= UNIV_PAGE_SIZE << 1)) {
recv_sys->found_corrupt_log = TRUE;
return(NULL);
}
- if (extra_info_yes) {
+ if (end_seg_len & 0x1UL) {
/* Read the info bits */
if (end_ptr < ptr + 1) {
@@ -764,17 +774,17 @@
ut_a(mismatch_index < UNIV_PAGE_SIZE);
}
- if (end_ptr < ptr + end_seg_len) {
+ if (end_ptr < ptr + (end_seg_len >> 1)) {
return(NULL);
}
if (page == NULL) {
- return(ptr + end_seg_len);
+ return(ptr + (end_seg_len >> 1));
}
- ut_ad(!!page_is_comp(page) == index->table->comp);
+ ut_ad((ibool) !!page_is_comp(page) == index->table->comp);
/* Read from the log the inserted index record end segment which
differs from the cursor record */
@@ -788,12 +798,14 @@
offsets = rec_get_offsets(cursor_rec, index, offsets,
ULINT_UNDEFINED, &heap);
- if (extra_info_yes == 0) {
+ if (!(end_seg_len & 0x1UL)) {
info_and_status_bits = rec_get_info_and_status_bits(
cursor_rec, page_is_comp(page));
origin_offset = rec_offs_extra_size(offsets);
- mismatch_index = rec_offs_size(offsets) - end_seg_len;
+ mismatch_index = rec_offs_size(offsets) - (end_seg_len >> 1);
}
+
+ end_seg_len >>= 1;
if (mismatch_index + end_seg_len < sizeof buf1) {
buf = buf1;
@@ -873,14 +885,7 @@
ulint heap_no; /* heap number of the inserted record */
rec_t* current_rec; /* current record after which the
new record is inserted */
- rec_t* next_rec; /* next record after current before
- the insertion */
- ulint owner_slot; /* the slot which owns the
- inserted record */
- rec_t* owner_rec;
- ulint n_owned;
mem_heap_t* heap = NULL;
- ulint comp;
ut_ad(cursor && mtr);
ut_ad(tuple || rec);
@@ -888,10 +893,9 @@
ut_ad(rec || dtuple_check_typed(tuple));
page = page_cur_get_page(cursor);
- comp = page_is_comp(page);
- ut_ad(index->table->comp == !!comp);
+ ut_ad(index->table->comp == (ibool) !!page_is_comp(page));
- ut_ad(cursor->rec != page_get_supremum_rec(page));
+ ut_ad(!page_rec_is_supremum(cursor->rec));
/* 1. Get the size of the physical record in the page */
if (tuple != NULL) {
@@ -908,7 +912,7 @@
/* 2. Try to find suitable space from page memory management */
insert_buf = page_mem_alloc(page, rec_size, index, &heap_no);
- if (insert_buf == NULL) {
+ if (UNIV_UNLIKELY(insert_buf == NULL)) {
if (UNIV_LIKELY_NULL(heap)) {
mem_heap_free(heap);
}
@@ -933,30 +937,41 @@
/* 4. Insert the record in the linked list of records */
current_rec = cursor->rec;
- ut_ad(!comp || rec_get_status(current_rec) <= REC_STATUS_INFIMUM);
- ut_ad(!comp || rec_get_status(insert_rec) < REC_STATUS_INFIMUM);
-
- next_rec = page_rec_get_next(current_rec);
- ut_ad(!comp || rec_get_status(next_rec) != REC_STATUS_INFIMUM);
- page_rec_set_next(insert_rec, next_rec);
- page_rec_set_next(current_rec, insert_rec);
+ {
+ /* next record after current before the insertion */
+ rec_t* next_rec = page_rec_get_next(current_rec);
+#ifdef UNIV_DEBUG
+ if (page_is_comp(page)) {
+ ut_ad(rec_get_status(current_rec)
+ <= REC_STATUS_INFIMUM);
+ ut_ad(rec_get_status(insert_rec) < REC_STATUS_INFIMUM);
+ ut_ad(rec_get_status(next_rec) != REC_STATUS_INFIMUM);
+ }
+#endif
+ page_rec_set_next(insert_rec, next_rec);
+ page_rec_set_next(current_rec, insert_rec);
+ }
page_header_set_field(page, PAGE_N_RECS, 1 + page_get_n_recs(page));
/* 5. Set the n_owned field in the inserted record to zero,
and set the heap_no field */
-
- rec_set_n_owned(insert_rec, comp, 0);
- rec_set_heap_no(insert_rec, comp, heap_no);
+ if (page_is_comp(page)) {
+ rec_set_n_owned(insert_rec, TRUE, 0);
+ rec_set_heap_no(insert_rec, TRUE, heap_no);
+ } else {
+ rec_set_n_owned(insert_rec, FALSE, 0);
+ rec_set_heap_no(insert_rec, FALSE, heap_no);
+ }
/* 6. Update the last insertion info in page header */
last_insert = page_header_get_ptr(page, PAGE_LAST_INSERT);
- ut_ad(!last_insert || !comp
+ ut_ad(!last_insert || !page_is_comp(page)
|| rec_get_node_ptr_flag(last_insert)
== rec_get_node_ptr_flag(insert_rec));
- if (last_insert == NULL) {
+ if (UNIV_UNLIKELY(last_insert == NULL)) {
page_header_set_field(page, PAGE_DIRECTION, PAGE_NO_DIRECTION);
page_header_set_field(page, PAGE_N_DIRECTION, 0);
@@ -981,18 +996,25 @@
page_header_set_ptr(page, PAGE_LAST_INSERT, insert_rec);
/* 7. It remains to update the owner record. */
-
- owner_rec = page_rec_find_owner_rec(insert_rec);
- n_owned = rec_get_n_owned(owner_rec, comp);
- rec_set_n_owned(owner_rec, comp, n_owned + 1);
-
- /* 8. Now we have incremented the n_owned field of the owner
- record. If the number exceeds PAGE_DIR_SLOT_MAX_N_OWNED,
- we have to split the corresponding directory slot in two. */
-
- if (n_owned == PAGE_DIR_SLOT_MAX_N_OWNED) {
- owner_slot = page_dir_find_owner_slot(owner_rec);
- page_dir_split_slot(page, owner_slot);
+ {
+ rec_t* owner_rec = page_rec_find_owner_rec(insert_rec);
+ ulint n_owned;
+ if (page_is_comp(page)) {
+ n_owned = rec_get_n_owned(owner_rec, TRUE);
+ rec_set_n_owned(owner_rec, TRUE, n_owned + 1);
+ } else {
+ n_owned = rec_get_n_owned(owner_rec, FALSE);
+ rec_set_n_owned(owner_rec, FALSE, n_owned + 1);
+ }
+
+ /* 8. Now we have incremented the n_owned field of the owner
+ record. If the number exceeds PAGE_DIR_SLOT_MAX_N_OWNED,
+ we have to split the corresponding directory slot in two. */
+
+ if (UNIV_UNLIKELY(n_owned == PAGE_DIR_SLOT_MAX_N_OWNED)) {
+ page_dir_split_slot(page,
+ page_dir_find_owner_slot(owner_rec));
+ }
}
/* 9. Write log record of the insert */
@@ -1089,7 +1111,6 @@
page_copy_rec_list_end_to_created_page(
/*===================================*/
page_t* new_page, /* in: index page to copy to */
- page_t* page, /* in: index page */
rec_t* rec, /* in: first record to copy */
dict_index_t* index, /* in: record descriptor */
mtr_t* mtr) /* in: mtr */
@@ -1105,22 +1126,21 @@
ulint log_mode;
byte* log_ptr;
ulint log_data_len;
- ulint comp = page_is_comp(page);
mem_heap_t* heap = NULL;
ulint offsets_[REC_OFFS_NORMAL_SIZE];
ulint* offsets = offsets_;
*offsets_ = (sizeof offsets_) / sizeof *offsets_;
ut_ad(page_dir_get_n_heap(new_page) == 2);
- ut_ad(page != new_page);
- ut_ad(comp == page_is_comp(new_page));
+ ut_ad(ut_align_down(rec, UNIV_PAGE_SIZE) != new_page);
+ ut_ad(page_rec_is_comp(rec) == page_is_comp(new_page));
- if (rec == page_get_infimum_rec(page)) {
+ if (page_rec_is_infimum(rec)) {
rec = page_rec_get_next(rec);
}
- if (rec == page_get_supremum_rec(page)) {
+ if (page_rec_is_supremum(rec)) {
return;
}
@@ -1143,7 +1163,7 @@
log_mode = mtr_set_log_mode(mtr, MTR_LOG_SHORT_INSERTS);
prev_rec = page_get_infimum_rec(new_page);
- if (comp) {
+ if (page_is_comp(new_page)) {
heap_top = new_page + PAGE_NEW_SUPREMUM_END;
} else {
heap_top = new_page + PAGE_OLD_SUPREMUM_END;
@@ -1152,16 +1172,24 @@
slot_index = 0;
n_recs = 0;
- /* should be do ... until, comment by Jani */
- while (rec != page_get_supremum_rec(page)) {
+ do {
offsets = rec_get_offsets(rec, index, offsets,
ULINT_UNDEFINED, &heap);
insert_rec = rec_copy(heap_top, rec, offsets);
- rec_set_next_offs(prev_rec, comp, insert_rec - new_page);
+ if (page_is_comp(new_page)) {
+ rec_set_next_offs(prev_rec, TRUE,
+ ut_align_offset(insert_rec, UNIV_PAGE_SIZE));
+
+ rec_set_n_owned(insert_rec, TRUE, 0);
+ rec_set_heap_no(insert_rec, TRUE, 2 + n_recs);
+ } else {
+ rec_set_next_offs(prev_rec, FALSE,
+ ut_align_offset(insert_rec, UNIV_PAGE_SIZE));
- rec_set_n_owned(insert_rec, comp, 0);
- rec_set_heap_no(insert_rec, comp, 2 + n_recs);
+ rec_set_n_owned(insert_rec, FALSE, 0);
+ rec_set_heap_no(insert_rec, FALSE, 2 + n_recs);
+ }
rec_size = rec_offs_size(offsets);
@@ -1188,7 +1216,7 @@
index, mtr);
prev_rec = insert_rec;
rec = page_rec_get_next(rec);
- }
+ } while (!page_rec_is_supremum(rec));
if ((slot_index > 0) && (count + 1
+ (PAGE_DIR_SLOT_MAX_N_OWNED + 1) / 2
@@ -1216,9 +1244,12 @@
ut_a(log_data_len < 100 * UNIV_PAGE_SIZE);
mach_write_to_4(log_ptr, log_data_len);
-
- rec_set_next_offs(insert_rec, comp,
- comp ? PAGE_NEW_SUPREMUM : PAGE_OLD_SUPREMUM);
+
+ if (page_is_comp(new_page)) {
+ rec_set_next_offs(insert_rec, TRUE, PAGE_NEW_SUPREMUM);
+ } else {
+ rec_set_next_offs(insert_rec, FALSE, PAGE_OLD_SUPREMUM);
+ }
slot = page_dir_get_nth_slot(new_page, 1 + slot_index);
@@ -1251,7 +1282,7 @@
{
byte* log_ptr;
- ut_ad(!!page_rec_is_comp(rec) == index->table->comp);
+ ut_ad((ibool) !!page_rec_is_comp(rec) == index->table->comp);
log_ptr = mlog_open_and_write_index(mtr, rec, index,
page_rec_is_comp(rec)
@@ -1343,12 +1374,11 @@
page = page_cur_get_page(cursor);
current_rec = cursor->rec;
ut_ad(rec_offs_validate(current_rec, index, offsets));
- ut_ad(!!page_is_comp(page) == index->table->comp);
+ ut_ad((ibool) !!page_is_comp(page) == index->table->comp);
/* The record must not be the supremum or infimum record. */
- ut_ad(current_rec != page_get_supremum_rec(page));
- ut_ad(current_rec != page_get_infimum_rec(page));
-
+ ut_ad(page_rec_is_user_rec(current_rec));
+
/* Save to local variables some data associated with current_rec */
cur_slot_no = page_dir_find_owner_slot(current_rec);
cur_dir_slot = page_dir_get_nth_slot(page, cur_slot_no);
--- 1.31/innobase/page/page0page.c 2005-06-27 18:58:06 +03:00
+++ 1.32/innobase/page/page0page.c 2005-07-11 13:50:16 +03:00
@@ -463,7 +463,6 @@
page_copy_rec_list_end_no_locks(
/*============================*/
page_t* new_page, /* in: index page to copy to */
- page_t* page, /* in: index page */
rec_t* rec, /* in: record on page */
dict_index_t* index, /* in: record descriptor */
mtr_t* mtr) /* in: mtr */
@@ -484,7 +483,7 @@
}
ut_a((ibool)!!page_is_comp(new_page) == index->table->comp);
- ut_a(page_is_comp(new_page) == page_is_comp(page));
+ ut_a(page_is_comp(new_page) == page_rec_is_comp(rec));
ut_a(mach_read_from_2(new_page + UNIV_PAGE_SIZE - 10) == (ulint)
(page_is_comp(new_page)
? PAGE_NEW_INFIMUM : PAGE_OLD_INFIMUM));
@@ -493,7 +492,7 @@
/* Copy records from the original page to the new page */
- sup = page_get_supremum_rec(page);
+ sup = page_get_supremum_rec(ut_align_down(rec, UNIV_PAGE_SIZE));
for (;;) {
rec_t* cur1_rec = page_cur_get_rec(&cur1);
@@ -508,14 +507,16 @@
list on June 18th, 2003 */
buf_page_print(new_page);
- buf_page_print(page);
+ buf_page_print(ut_align_down(rec, UNIV_PAGE_SIZE));
ut_print_timestamp(stderr);
fprintf(stderr,
"InnoDB: rec offset %lu, cur1 offset %lu, cur2 offset %lu\n",
- (ulong)(rec - page),
- (ulong)(page_cur_get_rec(&cur1) - page),
- (ulong)(page_cur_get_rec(&cur2) - new_page));
+ (ulong)ut_align_offset(rec, UNIV_PAGE_SIZE),
+ (ulong)ut_align_offset(page_cur_get_rec(&cur1),
+ UNIV_PAGE_SIZE),
+ (ulong)ut_align_offset(page_cur_get_rec(&cur2),
+ UNIV_PAGE_SIZE));
ut_error;
}
@@ -537,19 +538,20 @@
page_copy_rec_list_end(
/*===================*/
page_t* new_page, /* in: index page to copy to */
- page_t* page, /* in: index page */
rec_t* rec, /* in: record on page */
dict_index_t* index, /* in: record descriptor */
mtr_t* mtr) /* in: mtr */
{
+ page_t* page;
if (page_dir_get_n_heap(new_page) == 2) {
- page_copy_rec_list_end_to_created_page(new_page, page, rec,
+ page_copy_rec_list_end_to_created_page(new_page, rec,
index, mtr);
} else {
- page_copy_rec_list_end_no_locks(new_page, page, rec,
- index, mtr);
+ page_copy_rec_list_end_no_locks(new_page, rec, index, mtr);
}
+ page = ut_align_down(rec, UNIV_PAGE_SIZE);
+
/* Update the lock table, MAX_TRX_ID, and possible hash index */
lock_move_rec_list_end(new_page, page, rec);
@@ -568,26 +570,27 @@
page_copy_rec_list_start(
/*=====================*/
page_t* new_page, /* in: index page to copy to */
- page_t* page, /* in: index page */
rec_t* rec, /* in: record on page */
dict_index_t* index, /* in: record descriptor */
mtr_t* mtr) /* in: mtr */
{
page_cur_t cur1;
page_cur_t cur2;
+ page_t* page;
rec_t* old_end;
mem_heap_t* heap = NULL;
ulint offsets_[REC_OFFS_NORMAL_SIZE];
ulint* offsets = offsets_;
*offsets_ = (sizeof offsets_) / sizeof *offsets_;
- page_cur_set_before_first(page, &cur1);
-
- if (rec == page_cur_get_rec(&cur1)) {
+ if (page_rec_is_infimum(rec)) {
return;
}
+ page = ut_align_down(rec, UNIV_PAGE_SIZE);
+
+ page_cur_set_before_first(page, &cur1);
page_cur_move_to_next(&cur1);
page_cur_set_after_last(new_page, &cur2);
@@ -687,14 +690,14 @@
return(ptr);
}
- ut_ad(!!page_is_comp(page) == index->table->comp);
+ ut_ad((ibool) !!page_is_comp(page) == index->table->comp);
if (type == MLOG_LIST_END_DELETE
|| type == MLOG_COMP_LIST_END_DELETE) {
- page_delete_rec_list_end(page, page + offset, index,
+ page_delete_rec_list_end(page + offset, index,
ULINT_UNDEFINED, ULINT_UNDEFINED, mtr);
} else {
- page_delete_rec_list_start(page, page + offset, index, mtr);
+ page_delete_rec_list_start(page + offset, index, mtr);
}
return(ptr);
@@ -707,7 +710,6 @@
void
page_delete_rec_list_end(
/*=====================*/
- page_t* page, /* in: index page */
rec_t* rec, /* in: record on page */
dict_index_t* index, /* in: record descriptor */
ulint n_recs, /* in: number of records to delete,
@@ -721,17 +723,17 @@
ulint slot_index;
rec_t* last_rec;
rec_t* prev_rec;
- rec_t* free;
rec_t* rec2;
ulint count;
ulint n_owned;
- rec_t* sup;
- ulint comp;
+ page_t* page;
/* Reset the last insert info in the page header and increment
the modify clock for the frame */
ut_ad(size == ULINT_UNDEFINED || size < UNIV_PAGE_SIZE);
+
+ page = ut_align_down(rec, UNIV_PAGE_SIZE);
page_header_set_ptr(page, PAGE_LAST_INSERT, NULL);
/* The page gets invalid for optimistic searches: increment the
@@ -739,24 +741,22 @@
buf_frame_modify_clock_inc(page);
- sup = page_get_supremum_rec(page);
-
- comp = page_is_comp(page);
- if (page_rec_is_infimum_low(rec - page)) {
+ if (page_rec_is_infimum(rec)) {
rec = page_rec_get_next(rec);
}
- page_delete_rec_list_write_log(rec, index,
- comp ? MLOG_COMP_LIST_END_DELETE : MLOG_LIST_END_DELETE, mtr);
+ page_delete_rec_list_write_log(rec, index, page_is_comp(page)
+ ? MLOG_COMP_LIST_END_DELETE
+ : MLOG_LIST_END_DELETE, mtr);
- if (rec == sup) {
+ if (page_rec_is_supremum(rec)) {
return;
}
prev_rec = page_rec_get_prev(rec);
- last_rec = page_rec_get_prev(sup);
+ last_rec = page_rec_get_prev(page_get_supremum_rec(page));
if ((size == ULINT_UNDEFINED) || (n_recs == ULINT_UNDEFINED)) {
mem_heap_t* heap = NULL;
@@ -768,7 +768,7 @@
n_recs = 0;
rec2 = rec;
- while (rec2 != sup) {
+ do {
ulint s;
offsets = rec_get_offsets(rec2, index, offsets,
ULINT_UNDEFINED, &heap);
@@ -780,7 +780,7 @@
n_recs++;
rec2 = page_rec_get_next(rec2);
- }
+ } while (!page_rec_is_supremum(rec2));
if (UNIV_LIKELY_NULL(heap)) {
mem_heap_free(heap);
@@ -795,21 +795,21 @@
rec2 = rec;
count = 0;
-
- while (rec_get_n_owned(rec2, comp) == 0) {
+
+ while (rec_get_n_owned(rec2, page_is_comp(page)) == 0) {
count++;
rec2 = page_rec_get_next(rec2);
}
- ut_ad(rec_get_n_owned(rec2, comp) - count > 0);
+ ut_ad(rec_get_n_owned(rec2, page_is_comp(page)) > count);
+
+ n_owned = rec_get_n_owned(rec2, page_is_comp(page)) - count;
- n_owned = rec_get_n_owned(rec2, comp) - count;
-
slot_index = page_dir_find_owner_slot(rec2);
slot = page_dir_get_nth_slot(page, slot_index);
- page_dir_slot_set_rec(slot, sup);
+ page_dir_slot_set_rec(slot, page_get_supremum_rec(page));
page_dir_slot_set_n_owned(slot, n_owned);
page_dir_set_n_slots(page, slot_index + 1);
@@ -819,9 +819,7 @@
/* Catenate the deleted chain segment to the page free list */
- free = page_header_get_ptr(page, PAGE_FREE);
-
- page_rec_set_next(last_rec, free);
+ page_rec_set_next(last_rec, page_header_get_ptr(page, PAGE_FREE));
page_header_set_ptr(page, PAGE_FREE, rec);
page_header_set_field(page, PAGE_GARBAGE,
@@ -838,7 +836,6 @@
void
page_delete_rec_list_start(
/*=======================*/
- page_t* page, /* in: index page */
rec_t* rec, /* in: record on page */
dict_index_t* index, /* in: record descriptor */
mtr_t* mtr) /* in: mtr */
@@ -851,9 +848,9 @@
byte type;
*offsets_ = (sizeof offsets_) / sizeof *offsets_;
- ut_ad(!!page_is_comp(page) == index->table->comp);
+ ut_ad((ibool) !!page_rec_is_comp(rec) == index->table->comp);
- if (page_is_comp(page)) {
+ if (page_rec_is_comp(rec)) {
type = MLOG_COMP_LIST_START_DELETE;
} else {
type = MLOG_LIST_START_DELETE;
@@ -861,13 +858,12 @@
page_delete_rec_list_write_log(rec, index, type, mtr);
- page_cur_set_before_first(page, &cur1);
-
- if (rec == page_cur_get_rec(&cur1)) {
+ if (page_rec_is_infimum(rec)) {
return;
}
+ page_cur_set_before_first(ut_align_down(rec, UNIV_PAGE_SIZE), &cur1);
page_cur_move_to_next(&cur1);
/* Individual deletes are not logged */
@@ -897,7 +893,6 @@
page_move_rec_list_end(
/*===================*/
page_t* new_page, /* in: index page where to move */
- page_t* page, /* in: index page */
rec_t* split_rec, /* in: first record to move */
dict_index_t* index, /* in: record descriptor */
mtr_t* mtr) /* in: mtr */
@@ -910,14 +905,14 @@
old_data_size = page_get_data_size(new_page);
old_n_recs = page_get_n_recs(new_page);
- page_copy_rec_list_end(new_page, page, split_rec, index, mtr);
+ page_copy_rec_list_end(new_page, split_rec, index, mtr);
new_data_size = page_get_data_size(new_page);
new_n_recs = page_get_n_recs(new_page);
ut_ad(new_data_size >= old_data_size);
- page_delete_rec_list_end(page, split_rec, index,
+ page_delete_rec_list_end(split_rec, index,
new_n_recs - old_n_recs, new_data_size - old_data_size, mtr);
}
@@ -929,14 +924,13 @@
page_move_rec_list_start(
/*=====================*/
page_t* new_page, /* in: index page where to move */
- page_t* page, /* in: index page */
rec_t* split_rec, /* in: first record not to move */
dict_index_t* index, /* in: record descriptor */
mtr_t* mtr) /* in: mtr */
{
- page_copy_rec_list_start(new_page, page, split_rec, index, mtr);
+ page_copy_rec_list_start(new_page, split_rec, index, mtr);
- page_delete_rec_list_start(page, split_rec, index, mtr);
+ page_delete_rec_list_start(split_rec, index, mtr);
}
/***************************************************************************
--- 1.94/innobase/row/row0sel.c 2005-07-02 00:39:22 +03:00
+++ 1.95/innobase/row/row0sel.c 2005-07-11 13:50:16 +03:00
@@ -2059,7 +2059,7 @@
dfield = dtuple_get_nth_field(tuple, 0);
field = dict_index_get_nth_field(index, 0);
- if (dfield_get_type(dfield)->mtype == DATA_SYS) {
+ if (UNIV_UNLIKELY(dfield_get_type(dfield)->mtype == DATA_SYS)) {
/* A special case: we are looking for a position in the
generated clustered index which InnoDB automatically added
to a table with no primary key: the first and the only
@@ -2077,8 +2077,9 @@
while (key_ptr < key_end) {
- ut_a(dict_col_get_type(field->col)->mtype
- == dfield_get_type(dfield)->mtype);
+ type = dfield_get_type(dfield)->mtype;
+
+ ut_a(dict_col_get_type(field->col)->mtype == type);
data_offset = 0;
is_null = FALSE;
@@ -2096,8 +2097,6 @@
}
}
- type = dfield_get_type(dfield)->mtype;
-
/* Calculate data length and data field total length */
if (type == DATA_BLOB) {
@@ -2143,9 +2142,9 @@
data_field_len = data_offset + data_len;
}
- if (dtype_get_mysql_type(dfield_get_type(dfield))
- == DATA_MYSQL_TRUE_VARCHAR
- && dfield_get_type(dfield)->mtype != DATA_INT) {
+ if (UNIV_UNLIKELY(dtype_get_mysql_type(dfield_get_type(dfield))
+ == DATA_MYSQL_TRUE_VARCHAR)
+ && UNIV_LIKELY(type != DATA_INT)) {
/* In a MySQL key value format, a true VARCHAR is
always preceded by 2 bytes of a length field.
dfield_get_type(dfield)->len returns the maximum
@@ -2161,7 +2160,7 @@
/* Storing may use at most data_len bytes of buf */
- if (!is_null) {
+ if (UNIV_LIKELY(!is_null)) {
row_mysql_store_col_in_innobase_format(
dfield,
buf,
@@ -2174,7 +2173,7 @@
key_ptr += data_field_len;
- if (key_ptr > key_end) {
+ if (UNIV_UNLIKELY(key_ptr > key_end)) {
/* The last field in key was not a complete key field
but a prefix of it.
| Thread |
|---|
| • bk commit into 5.0 tree (marko:1.1905) | Marko Mäkelä | 11 Jul |
