Merge hundin.mysql.fi:/home/marko/mysql-5.0

into hundin.mysql.fi:/home/marko/mysql-5.0-current

innobase/btr/btr0pcur.c

@@ -78,6 +78,7 @@ btr_pcur_store_position(
 	rec_t*		rec;
 	dict_tree_t*	tree;
 	page_t*		page;
+	ulint		offs;
 	
 	ut_a(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 	ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
@@ -87,7 +88,8 @@ btr_pcur_store_position(
 	page_cursor = btr_pcur_get_page_cur(cursor);
 
 	rec = page_cur_get_rec(page_cursor);
-	page = buf_frame_align(rec);
+	page = ut_align_down(rec, UNIV_PAGE_SIZE);
+	offs = ut_align_offset(rec, UNIV_PAGE_SIZE);
 
 	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
 							MTR_MEMO_PAGE_S_FIX)
@@ -95,35 +97,33 @@ btr_pcur_store_position(
 							MTR_MEMO_PAGE_X_FIX));
 	ut_a(cursor->latch_mode != BTR_NO_LATCHES);
 
-	if (page_get_n_recs(page) == 0) {
+	if (UNIV_UNLIKELY(page_get_n_recs(page) == 0)) {
 		/* It must be an empty index tree; NOTE that in this case
 		we do not store the modify_clock, but always do a search
 		if we restore the cursor position */
 
-		ut_a(btr_page_get_next(page, mtr) == FIL_NULL
-		     && btr_page_get_prev(page, mtr) == FIL_NULL);
+		ut_a(btr_page_get_next(page, mtr) == FIL_NULL);
+		ut_a(btr_page_get_prev(page, mtr) == FIL_NULL);
 
-		if (rec == page_get_supremum_rec(page)) {
+		cursor->old_stored = BTR_PCUR_OLD_STORED;
 
-			cursor->rel_pos = BTR_PCUR_AFTER_LAST_IN_TREE;
-			cursor->old_stored = BTR_PCUR_OLD_STORED;
+		if (page_rec_is_supremum_low(offs)) {
 
-			return;
+			cursor->rel_pos = BTR_PCUR_AFTER_LAST_IN_TREE;
+		} else {
+			cursor->rel_pos = BTR_PCUR_BEFORE_FIRST_IN_TREE;
 		}
 
-		cursor->rel_pos = BTR_PCUR_BEFORE_FIRST_IN_TREE;
-		cursor->old_stored = BTR_PCUR_OLD_STORED;
-
 		return;
 	} 
 
-	if (rec == page_get_supremum_rec(page)) {
+	if (page_rec_is_supremum_low(offs)) {
 
 		rec = page_rec_get_prev(rec);
 
 		cursor->rel_pos = BTR_PCUR_AFTER;
 
-	} else if (rec == page_get_infimum_rec(page)) {
+	} else if (page_rec_is_infimum_low(offs)) {
 
 		rec = page_rec_get_next(rec);
 
@@ -139,7 +139,8 @@ btr_pcur_store_position(
 						&cursor->buf_size);
 
 	cursor->block_when_stored = buf_block_align(page);	
-	cursor->modify_clock = buf_frame_get_modify_clock(page);
+	cursor->modify_clock = buf_block_get_modify_clock(
+				cursor->block_when_stored);
 }
 
 /******************************************************************
@@ -202,33 +203,27 @@ btr_pcur_restore_position(
 	dtuple_t*	tuple;
 	ulint		mode;
 	ulint		old_mode;
-	ibool		from_left;
 	mem_heap_t*	heap;
 
-	ut_a(cursor->pos_state == BTR_PCUR_WAS_POSITIONED
-			|| cursor->pos_state == BTR_PCUR_IS_POSITIONED);
-	if (cursor->old_stored != BTR_PCUR_OLD_STORED) {
+	if (UNIV_UNLIKELY(cursor->old_stored != BTR_PCUR_OLD_STORED)
+	    || UNIV_UNLIKELY(cursor->pos_state != BTR_PCUR_WAS_POSITIONED
+			     && cursor->pos_state != BTR_PCUR_IS_POSITIONED)) {
 		ut_print_buf(stderr, (const byte*)cursor, sizeof(btr_pcur_t));
 		if (cursor->trx_if_known) {
 			trx_print(stderr, cursor->trx_if_known);
 		}
 		
-		ut_a(0);
+		ut_error;
 	}
 
-	if (cursor->rel_pos == BTR_PCUR_AFTER_LAST_IN_TREE
-	    || cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE) {
+	if (UNIV_UNLIKELY(cursor->rel_pos == BTR_PCUR_AFTER_LAST_IN_TREE
+			|| cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE)) {
 
 	    	/* In these cases we do not try an optimistic restoration,
 	    	but always do a search */
 
-	    	if (cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE) {
-	    		from_left = TRUE;
-	    	} else {
-	    		from_left = FALSE;
-	    	}
-
-		btr_cur_open_at_index_side(from_left,
+		btr_cur_open_at_index_side(
+			cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE,
 			btr_pcur_get_btr_cur(cursor)->index, latch_mode,
 					btr_pcur_get_btr_cur(cursor), mtr);
 
@@ -243,12 +238,13 @@ btr_pcur_restore_position(
 
 	page = btr_cur_get_page(btr_pcur_get_btr_cur(cursor));
 
-	if (latch_mode == BTR_SEARCH_LEAF || latch_mode == BTR_MODIFY_LEAF) {
+	if (UNIV_LIKELY(latch_mode == BTR_SEARCH_LEAF)
+			|| UNIV_LIKELY(latch_mode == BTR_MODIFY_LEAF)) {
 		/* Try optimistic restoration */
 	    
-		if (buf_page_optimistic_get(latch_mode,
+		if (UNIV_LIKELY(buf_page_optimistic_get(latch_mode,
 					    cursor->block_when_stored, page,
-					    cursor->modify_clock, mtr)) {
+					    cursor->modify_clock, mtr))) {
 			cursor->pos_state = BTR_PCUR_IS_POSITIONED;
 #ifdef UNIV_SYNC_DEBUG
 			buf_page_dbg_add_level(page, SYNC_TREE_NODE);
@@ -297,7 +293,7 @@ btr_pcur_restore_position(
 	/* Save the old search mode of the cursor */
 	old_mode = cursor->search_mode;
 	
-	if (cursor->rel_pos == BTR_PCUR_ON) {
+	if (UNIV_LIKELY(cursor->rel_pos == BTR_PCUR_ON)) {
 		mode = PAGE_CUR_LE;
 	} else if (cursor->rel_pos == BTR_PCUR_AFTER) {
 		mode = PAGE_CUR_G;
@@ -323,12 +319,10 @@ btr_pcur_restore_position(
 		the cursor can now be on a different page! But we can retain
 		the value of old_rec */
 
-		cursor->modify_clock =
-			buf_frame_get_modify_clock(btr_pcur_get_page(cursor));
-
 		cursor->block_when_stored =
 			buf_block_align(btr_pcur_get_page(cursor));
-
+		cursor->modify_clock =
+			buf_block_get_modify_clock(cursor->block_when_stored);
 		cursor->old_stored = BTR_PCUR_OLD_STORED;
 
 		mem_heap_free(heap);

innobase/buf/buf0buf.c

@@ -223,13 +223,14 @@ in the free list to the frames.
 
 buf_pool_t*	buf_pool = NULL; /* The buffer buf_pool of the database */
 
+#ifdef UNIV_DEBUG
 ulint		buf_dbg_counter	= 0; /* This is used to insert validation
 					operations in excution in the
 					debug version */
 ibool		buf_debug_prints = FALSE; /* If this is set TRUE,
 					the program prints info whenever
 					read-ahead or flush occurs */
-
+#endif /* UNIV_DEBUG */
 /************************************************************************
 Calculates a page checksum which is stored to the page when it is written
 to a file. Note that we must be careful to calculate the same value on
@@ -1286,8 +1287,9 @@ buf_page_optimistic_get_func(
 
 	/* If AWE is used, block may have a different frame now, e.g., NULL */
 	
-	if (block->state != BUF_BLOCK_FILE_PAGE || block->frame != guess) {
-
+	if (UNIV_UNLIKELY(block->state != BUF_BLOCK_FILE_PAGE)
+			|| UNIV_UNLIKELY(block->frame != guess)) {
+	exit_func:
 		mutex_exit(&(buf_pool->mutex));
 
 		return(FALSE);
@@ -1320,19 +1322,17 @@ buf_page_optimistic_get_func(
 		fix_type = MTR_MEMO_PAGE_X_FIX;
 	}
 
-	if (!success) {
+	if (UNIV_UNLIKELY(!success)) {
 		mutex_enter(&(buf_pool->mutex));
 		
 		block->buf_fix_count--;
 #ifdef UNIV_SYNC_DEBUG
 		rw_lock_s_unlock(&(block->debug_latch));
-#endif			
-		mutex_exit(&(buf_pool->mutex));
-
-		return(FALSE);
+#endif
+		goto exit_func;
 	}
 
-	if (!UT_DULINT_EQ(modify_clock, block->modify_clock)) {
+	if (UNIV_UNLIKELY(!UT_DULINT_EQ(modify_clock, block->modify_clock))) {
 #ifdef UNIV_SYNC_DEBUG
 		buf_page_dbg_add_level(block->frame, SYNC_NO_ORDER_CHECK);
 #endif /* UNIV_SYNC_DEBUG */
@@ -1347,10 +1347,8 @@ buf_page_optimistic_get_func(
 		block->buf_fix_count--;
 #ifdef UNIV_SYNC_DEBUG
 		rw_lock_s_unlock(&(block->debug_latch));
-#endif			
-		mutex_exit(&(buf_pool->mutex));
-		
-		return(FALSE);
+#endif
+		goto exit_func;
 	}
 
 	mtr_memo_push(mtr, block, fix_type);
@@ -1368,7 +1366,7 @@ buf_page_optimistic_get_func(
 #ifdef UNIV_DEBUG_FILE_ACCESSES
 	ut_a(block->file_page_was_freed == FALSE);
 #endif
-	if (!accessed) {
+	if (UNIV_UNLIKELY(!accessed)) {
 		/* In the case of a first access, try to apply linear
 		read-ahead */
 
@@ -1742,10 +1740,12 @@ buf_page_create(
 
 	/* If we get here, the page was not in buf_pool: init it there */
 
+#ifdef UNIV_DEBUG
 	if (buf_debug_prints) {
 		fprintf(stderr, "Creating space %lu page %lu to buffer\n",
 			(ulong) space, (ulong) offset);
 	}
+#endif /* UNIV_DEBUG */
 
 	block = free_block;
 	
@@ -1896,9 +1896,11 @@ buf_page_io_complete(
 
 		rw_lock_x_unlock_gen(&(block->lock), BUF_IO_READ);
 
+#ifdef UNIV_DEBUG
 		if (buf_debug_prints) {
 			fputs("Has read ", stderr);
 		}
+#endif /* UNIV_DEBUG */
 	} else {
 		ut_ad(io_type == BUF_IO_WRITE);
 
@@ -1911,17 +1913,21 @@ buf_page_io_complete(
 
 		buf_pool->n_pages_written++;
 
+#ifdef UNIV_DEBUG
 		if (buf_debug_prints) {
 			fputs("Has written ", stderr);
 		}
+#endif /* UNIV_DEBUG */
 	}
 	
 	mutex_exit(&(buf_pool->mutex));
 
+#ifdef UNIV_DEBUG
 	if (buf_debug_prints) {
 		fprintf(stderr, "page space %lu page no %lu\n",
 			(ulong) block->space, (ulong) block->offset);
 	}
+#endif /* UNIV_DEBUG */
 }
 
 /*************************************************************************
@@ -1950,6 +1956,7 @@ buf_pool_invalidate(void)
 	mutex_exit(&(buf_pool->mutex));
 }
 
+#ifdef UNIV_DEBUG
 /*************************************************************************
 Validates the buffer buf_pool data structure. */
 
@@ -2149,6 +2156,7 @@ buf_print(void)
 
 	ut_a(buf_validate());
 }	
+#endif /* UNIV_DEBUG */
 
 /*************************************************************************
 Returns the number of latched pages in the buffer pool. */

innobase/buf/buf0flu.c

@@ -586,11 +586,13 @@ buf_flush_try_page(
 			rw_lock_s_lock_gen(&(block->lock), BUF_IO_WRITE);
 		}
 
+#ifdef UNIV_DEBUG
 		if (buf_debug_prints) {
 			fprintf(stderr,
 				"Flushing page space %lu, page no %lu \n",
 				(ulong) block->space, (ulong) block->offset);
 		}
+#endif /* UNIV_DEBUG */
 
 		buf_flush_write_block_low(block);
 		
@@ -674,12 +676,14 @@ buf_flush_try_page(
 
 		rw_lock_s_lock_gen(&(block->lock), BUF_IO_WRITE);
 
+#ifdef UNIV_DEBUG
 		if (buf_debug_prints) {
 			fprintf(stderr,
 			"Flushing single page space %lu, page no %lu \n",
 						(ulong) block->space,
 			                        (ulong) block->offset);
 		}
+#endif /* UNIV_DEBUG */
 
 		buf_flush_write_block_low(block);
 		
@@ -906,6 +910,7 @@ buf_flush_batch(
 
 	buf_flush_buffered_writes();
 
+#ifdef UNIV_DEBUG
 	if (buf_debug_prints && page_count > 0) {
 		ut_a(flush_type == BUF_FLUSH_LRU
 			|| flush_type == BUF_FLUSH_LIST);
@@ -914,6 +919,7 @@ buf_flush_batch(
 			: "Flushed %lu pages in flush list flush\n",
 			(ulong) page_count);
 	}
+#endif /* UNIV_DEBUG */
 	
         if (page_count != ULINT_UNDEFINED)
           srv_buf_pool_flushed+= page_count;

innobase/buf/buf0lru.c

@@ -213,12 +213,14 @@ buf_LRU_search_and_free_block(
 	        ut_a(block->in_LRU_list);
 		if (buf_flush_ready_for_replace(block)) {
 
+#ifdef UNIV_DEBUG
 			if (buf_debug_prints) {
 				fprintf(stderr,
 				"Putting space %lu page %lu to free list\n",
 					(ulong) block->space,
 				        (ulong) block->offset);
 			}
+#endif /* UNIV_DEBUG */
 
 			buf_LRU_block_remove_hashed_page(block);
 
@@ -919,7 +921,8 @@ buf_LRU_block_free_hashed_page(
 
 	buf_LRU_block_free_non_file_page(block);
 }
-				
+
+#ifdef UNIV_DEBUG
 /**************************************************************************
 Validates the LRU list. */
 
@@ -1050,3 +1053,4 @@ buf_LRU_print(void)
 
 	mutex_exit(&(buf_pool->mutex));
 }
+#endif /* UNIV_DEBUG */

innobase/buf/buf0rea.c

@@ -288,12 +288,14 @@ buf_read_ahead_random(
 	
 	os_aio_simulated_wake_handler_threads();
 
+#ifdef UNIV_DEBUG
 	if (buf_debug_prints && (count > 0)) {
 		fprintf(stderr,
 			"Random read-ahead space %lu offset %lu pages %lu\n",
 						(ulong) space, (ulong) offset,
 		       				(ulong) count);
 	}
+#endif /* UNIV_DEBUG */
 
         ++srv_read_ahead_rnd;
 	return(count);
@@ -575,11 +577,13 @@ buf_read_ahead_linear(
 	/* Flush pages from the end of the LRU list if necessary */
 	buf_flush_free_margin();
 
+#ifdef UNIV_DEBUG
 	if (buf_debug_prints && (count > 0)) {
 		fprintf(stderr,
 		"LINEAR read-ahead space %lu offset %lu pages %lu\n",
 		(ulong) space, (ulong) offset, (ulong) count);
 	}
+#endif /* UNIV_DEBUG */
 
         ++srv_read_ahead_seq;
 	return(count);
@@ -641,11 +645,13 @@ buf_read_ibuf_merge_pages(
 	/* Flush pages from the end of the LRU list if necessary */
 	buf_flush_free_margin();
 
+#ifdef UNIV_DEBUG
 	if (buf_debug_prints) {
 		fprintf(stderr,
 			"Ibuf merge read-ahead space %lu pages %lu\n",
 				(ulong) space_ids[0], (ulong) n_stored);
 	}
+#endif /* UNIV_DEBUG */
 }
 
 /************************************************************************
@@ -711,8 +717,10 @@ buf_read_recv_pages(
 	/* Flush pages from the end of the LRU list if necessary */
 	buf_flush_free_margin();
 
+#ifdef UNIV_DEBUG
 	if (buf_debug_prints) {
 		fprintf(stderr,
 			"Recovery applies read-ahead pages %lu\n", (ulong) n_stored);
 	}
+#endif /* UNIV_DEBUG */
 }

innobase/data/data0data.c

@@ -502,7 +502,7 @@ dtuple_convert_big_rec(
 
 	size = rec_get_converted_size(index, entry);
 
-	if (size > 1000000000) {
+	if (UNIV_UNLIKELY(size > 1000000000)) {
 		fprintf(stderr,
 "InnoDB: Warning: tuple size very big: %lu\n", (ulong) size);
 		fputs("InnoDB: Tuple contents: ", stderr);

innobase/data/data0type.c

@@ -39,7 +39,6 @@ column definitions, or records in the insert buffer, we use this
 charset-collation code for them. */
 
 ulint	data_mysql_default_charset_coll		= 99999999;
-ulint	data_mysql_latin1_swedish_charset_coll	= 99999999;
 
 dtype_t		dtype_binary_val = {DATA_BINARY, 0, 0, 0, 0, 0};
 dtype_t* 	dtype_binary 	= &dtype_binary_val;
@@ -64,9 +63,10 @@ dtype_get_at_most_n_mbchars(
 {
 #ifndef UNIV_HOTBACKUP
 	ut_a(data_len != UNIV_SQL_NULL);
-	ut_a(!(prefix_len % dtype->mbmaxlen));
+	ut_ad(!dtype->mbmaxlen || !(prefix_len % dtype->mbmaxlen));
 
 	if (dtype->mbminlen != dtype->mbmaxlen) {
+		ut_a(!(prefix_len % dtype->mbmaxlen));
 		return(innobase_get_at_most_n_mbchars(
 				dtype_get_charset_coll(dtype->prtype),
 				prefix_len, data_len, str));

innobase/dict/dict0boot.c

@@ -66,15 +66,6 @@ dict_hdr_get_new_id(
 	dict_hdr = dict_hdr_get(&mtr);
 
 	id = mtr_read_dulint(dict_hdr + type, &mtr); 
-
-	/* Add some dummy code here because otherwise pgcc seems to
-	compile wrong */
-
-	if (0 == ut_dulint_cmp(id, ut_dulint_max)) {
-		/* TO DO: remove this code, or make it conditional */
-		ut_dbg_null_ptr = 0;
-	}
-
 	id = ut_dulint_add(id, 1);
 	
 	mlog_write_dulint(dict_hdr + type, id, &mtr); 

innobase/dict/dict0crea.c

@@ -736,7 +736,7 @@ dict_truncate_index_tree(
 	dulint		index_id;
 	byte*		ptr;
 	ulint		len;
-	ibool		comp;
+	ulint		comp;
 	dict_index_t*	index;
 
 #ifdef UNIV_SYNC_DEBUG

innobase/dict/dict0dict.c

@@ -1453,7 +1453,7 @@ dict_index_add_to_cache(
 
 	/* Increment the ord_part counts in columns which are ordering */
 
-	if (index->type & DICT_UNIVERSAL) {
+	if (UNIV_UNLIKELY(index->type & DICT_UNIVERSAL)) {
 		n_ord = new_index->n_fields;
 	} else {
 		n_ord = dict_index_get_n_unique(new_index);
@@ -1482,7 +1482,7 @@ dict_index_add_to_cache(
 		new_index->tree = tree;
 	}
 
-	if (!(new_index->type & DICT_UNIVERSAL)) {
+	if (!UNIV_UNLIKELY(new_index->type & DICT_UNIVERSAL)) {
 
 		new_index->stat_n_diff_key_vals =
 			mem_heap_alloc(new_index->heap,
@@ -1683,7 +1683,7 @@ dict_index_copy_types(
 	dtype_t*	type;
 	ulint		i;
 
-	if (index->type & DICT_UNIVERSAL) {
+	if (UNIV_UNLIKELY(index->type & DICT_UNIVERSAL)) {
 		dtuple_set_types_binary(tuple, n_fields);
 
 		return;
@@ -1779,7 +1779,7 @@ dict_index_build_internal_clust(
 		dict_index_copy(new_index, index, 0, index->n_fields);
 	}
 
-	if (index->type & DICT_UNIVERSAL) {
+	if (UNIV_UNLIKELY(index->type & DICT_UNIVERSAL)) {
 		/* No fixed number of fields determines an entry uniquely */
 
 		new_index->n_uniq = ULINT_MAX;
@@ -3682,7 +3682,7 @@ dict_tree_find_index_low(
 	table = index->table;
 	
 	if ((index->type & DICT_CLUSTERED)
-				&& (table->type != DICT_TABLE_ORDINARY)) {
+			&& UNIV_UNLIKELY(table->type != DICT_TABLE_ORDINARY)) {
 
 		/* Get the mix id of the record */
 		ut_a(!table->comp);
@@ -3838,7 +3838,7 @@ dict_tree_build_node_ptr(
 
 	ind = dict_tree_find_index_low(tree, rec);
 	
-	if (tree->type & DICT_UNIVERSAL) {
+	if (UNIV_UNLIKELY(tree->type & DICT_UNIVERSAL)) {
 		/* In a universal index tree, we take the whole record as
 		the node pointer if the reord is on the leaf level,
 		on non-leaf levels we remove the last field, which
@@ -3903,9 +3903,10 @@ dict_tree_copy_rec_order_prefix(
 	dict_index_t*	index;
 	ulint		n;
 
+	UNIV_PREFETCH_R(rec);
 	index = dict_tree_find_index_low(tree, rec);
 
-	if (tree->type & DICT_UNIVERSAL) {
+	if (UNIV_UNLIKELY(tree->type & DICT_UNIVERSAL)) {
 		ut_a(!index->table->comp);
 		n = rec_get_n_fields_old(rec);
 	} else {
@@ -3957,7 +3958,7 @@ dict_index_calc_min_rec_len(
 	ulint	sum	= 0;
 	ulint	i;
 
-	if (index->table->comp) {
+	if (UNIV_LIKELY(index->table->comp)) {
 		ulint nullable = 0;
 		sum = REC_N_NEW_EXTRA_BYTES;
 		for (i = 0; i < dict_index_get_n_fields(index); i++) {
@@ -4277,9 +4278,11 @@ dict_index_print_low(
 
 	putc('\n', stderr);
 
-/*	btr_print_size(tree); */
+#ifdef UNIV_BTR_PRINT
+	btr_print_size(tree);
 
-/*	btr_print_tree(tree, 7); */
+	btr_print_tree(tree, 7);
+#endif /* UNIV_BTR_PRINT */
 }
 
 /**************************************************************************

innobase/dict/dict0mem.c

@@ -42,6 +42,7 @@ dict_mem_table_create(
 	mem_heap_t*	heap;
 	
 	ut_ad(name);
+	ut_ad(comp == FALSE || comp == TRUE);
 
 	heap = mem_heap_create(DICT_HEAP_SIZE);
 

innobase/fil/fil0fil.c

@@ -99,7 +99,6 @@ ulint	fil_n_pending_tablespace_flushes	= 0;
 fil_addr_t	fil_addr_null = {FIL_NULL, 0};
 
 /* File node of a tablespace or the log data space */
-typedef	struct fil_node_struct	fil_node_t;
 struct fil_node_struct {
 	fil_space_t*	space;	/* backpointer to the space where this node
 				belongs */
@@ -4046,7 +4045,7 @@ fil_aio_wait(
 	} else {
 		srv_set_io_thread_op_info(segment, "simulated aio handle");
 
-		ret = os_aio_simulated_handle(segment, (void**) &fil_node,
+		ret = os_aio_simulated_handle(segment, &fil_node,
 	                                               &message, &type);
 	}
 	

innobase/fsp/fsp0fsp.c

@@ -2325,7 +2325,6 @@ fseg_alloc_free_page_low(
 	dulint		seg_id;
 	ulint		used;
 	ulint		reserved;
-	fil_addr_t	first;
 	xdes_t*		descr;		/* extent of the hinted page */
 	ulint		ret_page;	/* the allocated page offset, FIL_NULL
 					if could not be allocated */
@@ -2428,6 +2427,8 @@ fseg_alloc_free_page_low(
 	} else if (reserved - used > 0) {
 		/* 5. We take any unused page from the segment
 		==============================================*/
+		fil_addr_t	first;
+
 		if (flst_get_len(seg_inode + FSEG_NOT_FULL, mtr) > 0) {
 			first = flst_get_first(seg_inode + FSEG_NOT_FULL,
 									mtr);
@@ -2435,6 +2436,7 @@ fseg_alloc_free_page_low(
 			first = flst_get_first(seg_inode + FSEG_FREE, mtr);
 		} else {
 			ut_error;
+			return(FIL_NULL);
 		}
 
 		ret_descr = xdes_lst_get_descriptor(space, first, mtr);

innobase/ibuf/ibuf0ibuf.c

@@ -1889,7 +1889,7 @@ ibuf_get_merge_page_nos(
 				contract the tree, FALSE if this is called
 				when a single page becomes full and we look
 				if it pays to read also nearby pages */
-	rec_t*		first_rec,/* in: record from which we read up and down
+	rec_t*		rec,	/* in: record from which we read up and down
 				in the chain of records */
 	ulint*		space_ids,/* in/out: space id's of the pages */
 	ib_longlong*	space_versions,/* in/out: tablespace version
@@ -1907,47 +1907,42 @@ ibuf_get_merge_page_nos(
 	ulint	first_space_id;
 	ulint	rec_page_no;
 	ulint	rec_space_id;
-	rec_t*	rec;
 	ulint	sum_volumes;
 	ulint	volume_for_page;
 	ulint	rec_volume;
 	ulint	limit;
-	page_t*	page;
 	ulint	n_pages;
 
 	*n_stored = 0;
 
 	limit = ut_min(IBUF_MAX_N_PAGES_MERGED, buf_pool->curr_size / 4);
 
-	page = buf_frame_align(first_rec);
-	
-	if (first_rec == page_get_supremum_rec(page)) {
+	if (page_rec_is_supremum(rec)) {
 
-		first_rec = page_rec_get_prev(first_rec);
+		rec = page_rec_get_prev(rec);
 	}
 
-	if (first_rec == page_get_infimum_rec(page)) {
+	if (page_rec_is_infimum(rec)) {
 
-		first_rec = page_rec_get_next(first_rec);
+		rec = page_rec_get_next(rec);
 	}
 
-	if (first_rec == page_get_supremum_rec(page)) {
+	if (page_rec_is_supremum(rec)) {
 
 		return(0);
 	}
 
-	rec = first_rec;
-	first_page_no = ibuf_rec_get_page_no(first_rec);
-	first_space_id = ibuf_rec_get_space(first_rec);
+	first_page_no = ibuf_rec_get_page_no(rec);
+	first_space_id = ibuf_rec_get_space(rec);
 	n_pages = 0;
 	prev_page_no = 0;
 	prev_space_id = 0;
 	
-	/* Go backwards from the first_rec until we reach the border of the
+	/* Go backwards from the first rec until we reach the border of the
 	'merge area', or the page start or the limit of storeable pages is
 	reached */
 
-	while ((rec != page_get_infimum_rec(page)) && (n_pages < limit)) {
+	while (!page_rec_is_infimum(rec) && UNIV_LIKELY(n_pages < limit)) {
 
 		rec_page_no = ibuf_rec_get_page_no(rec);
 		rec_space_id = ibuf_rec_get_space(rec);
@@ -1982,7 +1977,7 @@ ibuf_get_merge_page_nos(
 	volume_for_page = 0;
 	
 	while (*n_stored < limit) {
-		if (rec == page_get_supremum_rec(page)) {
+		if (page_rec_is_supremum(rec)) {
 			/* When no more records available, mark this with
 			another 'impossible' pair of space id, page no */
 			rec_page_no = 1;
@@ -2311,12 +2306,12 @@ ibuf_get_volume_buffered(
 
 	page = buf_frame_align(rec);
 
-	if (rec == page_get_supremum_rec(page)) {
+	if (page_rec_is_supremum(rec)) {
 		rec = page_rec_get_prev(rec);
 	}
 
 	for (;;) {
-		if (rec == page_get_infimum_rec(page)) {
+		if (page_rec_is_infimum(rec)) {
 
 			break;
 		}
@@ -2351,7 +2346,7 @@ ibuf_get_volume_buffered(
 	rec = page_rec_get_prev(rec);
 	
 	for (;;) {
-		if (rec == page_get_infimum_rec(prev_page)) {
+		if (page_rec_is_infimum(rec)) {
 
 			/* We cannot go to yet a previous page, because we
 			do not have the x-latch on it, and cannot acquire one
@@ -2374,12 +2369,12 @@ ibuf_get_volume_buffered(
 count_later:
 	rec = btr_pcur_get_rec(pcur);
 
-	if (rec != page_get_supremum_rec(page)) {
+	if (!page_rec_is_supremum(rec)) {
 		rec = page_rec_get_next(rec);
 	}
 
 	for (;;) {
-		if (rec == page_get_supremum_rec(page)) {
+		if (page_rec_is_supremum(rec)) {
 
 			break;
 		}
@@ -2414,7 +2409,7 @@ count_later:
 	rec = page_rec_get_next(rec);
 
 	for (;;) {
-		if (rec == page_get_supremum_rec(next_page)) {
+		if (page_rec_is_supremum(rec)) {
 
 			/* We give up */
 		
@@ -2815,7 +2810,7 @@ ibuf_insert_to_index_page(
 	ut_ad(ibuf_inside());
 	ut_ad(dtuple_check_typed(entry));
 
-	if (index->table->comp != page_is_comp(page)) {
+	if (UNIV_UNLIKELY(index->table->comp != !!page_is_comp(page))) {
 		fputs(
 "InnoDB: Trying to insert a record from the insert buffer to an index page\n"
 "InnoDB: but the 'compact' flag does not match!\n", stderr);
@@ -2824,7 +2819,8 @@ ibuf_insert_to_index_page(
 
 	rec = page_rec_get_next(page_get_infimum_rec(page));
 
-	if (rec_get_n_fields(rec, index) != dtuple_get_n_fields(entry)) {
+	if (UNIV_UNLIKELY(rec_get_n_fields(rec, index)
+			!= dtuple_get_n_fields(entry))) {
 		fputs(
 "InnoDB: Trying to insert a record from the insert buffer to an index page\n"
 "InnoDB: but the number of fields does not match!\n", stderr);
@@ -2848,7 +2844,7 @@ ibuf_insert_to_index_page(
 	if (low_match == dtuple_get_n_fields(entry)) {
 		rec = page_cur_get_rec(&page_cur);
 		
-		btr_cur_del_unmark_for_ibuf(rec, index, mtr);
+		btr_cur_del_unmark_for_ibuf(rec, mtr);
 	} else {
 		rec = page_cur_tuple_insert(&page_cur, entry, index, mtr);
 		
@@ -2861,8 +2857,8 @@ ibuf_insert_to_index_page(
 						PAGE_CUR_LE, &page_cur);
 
 			/* This time the record must fit */
-			if (!page_cur_tuple_insert(&page_cur, entry,
-								index, mtr)) {
+			if (UNIV_UNLIKELY(!page_cur_tuple_insert(
+					&page_cur, entry, index, mtr))) {
 
 				ut_print_timestamp(stderr);
 
@@ -2969,7 +2965,9 @@ ibuf_delete_rec(
 		btr_pcur_commit_specify_mtr(pcur, mtr);
 
 		fputs("InnoDB: Validating insert buffer tree:\n", stderr);
-		ut_a(btr_validate_tree(ibuf_data->index->tree));
+		if (!btr_validate_tree(ibuf_data->index->tree, NULL)) {
+			ut_error;
+		}
 
 		fprintf(stderr, "InnoDB: ibuf tree ok\n");
 		fflush(stderr);

innobase/include/btr0btr.h

@@ -168,7 +168,7 @@ btr_create(
 	ulint	type,	/* in: type of the index */
 	ulint	space,	/* in: space where created */
 	dulint	index_id,/* in: index id */
-	ibool	comp,	/* in: TRUE=compact page format */
+	ulint	comp,	/* in: nonzero=compact page format */
 	mtr_t*	mtr);	/* in: mini-transaction handle */
 /****************************************************************
 Frees a B-tree except the root page, which MUST be freed after this
@@ -276,7 +276,7 @@ void
 btr_set_min_rec_mark(
 /*=================*/
 	rec_t*	rec,	/* in: record */
-	ibool	comp,	/* in: TRUE=compact page format */
+	ulint	comp,	/* in: nonzero=compact page format */
 	mtr_t*	mtr);	/* in: mtr */
 /*****************************************************************
 Deletes on the upper level the node pointer to a page. */
@@ -336,7 +336,7 @@ btr_parse_set_min_rec_mark(
 			/* out: end of log record or NULL */
 	byte*	ptr,	/* in: buffer */
 	byte*	end_ptr,/* in: buffer end */
-	ibool	comp,	/* in: TRUE=compact page format */
+	ulint	comp,	/* in: nonzero=compact page format */
 	page_t*	page,	/* in: page or NULL */
 	mtr_t*	mtr);	/* in: mtr or NULL */
 /***************************************************************
@@ -398,6 +398,7 @@ btr_page_free_low(
 	page_t*		page,	/* in: page to be freed, x-latched */	
 	ulint		level,	/* in: page level */
 	mtr_t*		mtr);	/* in: mtr */
+#ifdef UNIV_BTR_PRINT
 /*****************************************************************
 Prints size info of a B-tree. */
 
@@ -414,6 +415,7 @@ btr_print_tree(
 	dict_tree_t*	tree,	/* in: tree */
 	ulint		width);	/* in: print this many entries from start
 				and end */
+#endif /* UNIV_BTR_PRINT */
 /****************************************************************
 Checks the size and number of fields in a record based on the definition of
 the index. */
@@ -434,7 +436,8 @@ ibool
 btr_validate_tree(
 /*==============*/
 				/* out: TRUE if ok */
-	dict_tree_t*	tree);	/* in: tree */
+	dict_tree_t*	tree,	/* in: tree */
+	trx_t*		trx);	/* in: transaction or NULL */
 
 #define BTR_N_LEAF_PAGES 	1
 #define BTR_TOTAL_SIZE		2

innobase/include/btr0btr.ic

@@ -200,10 +200,10 @@ btr_node_ptr_get_child_page_no(
 	
 	page_no = mach_read_from_4(field);
 
-	if (page_no == 0) {
+	if (UNIV_UNLIKELY(page_no == 0)) {
 		fprintf(stderr,
 "InnoDB: a nonsensical page number 0 in a node ptr record at offset %lu\n",
-		       (unsigned long)(rec - buf_frame_align(rec)));
+			(ulong) ut_align_offset(rec, UNIV_PAGE_SIZE));
 		buf_page_print(buf_frame_align(rec));
 	}
 

innobase/include/btr0cur.h

@@ -284,7 +284,6 @@ void
 btr_cur_del_unmark_for_ibuf(
 /*========================*/
 	rec_t*		rec,	/* in: record to delete unmark */
-	dict_index_t*	index,	/* in: record descriptor */
 	mtr_t*		mtr);	/* in: mtr */
 /*****************************************************************
 Tries to compress a page of the tree on the leaf level. It is assumed
@@ -389,7 +388,6 @@ btr_cur_parse_del_mark_set_sec_rec(
 				/* out: end of log record or NULL */
 	byte*		ptr,	/* in: buffer */
 	byte*		end_ptr,/* in: buffer end */
-	dict_index_t*	index,	/* in: index corresponding to page */
 	page_t*		page);	/* in: page or NULL */
 /***********************************************************************
 Estimates the number of rows in a given index range. */

innobase/include/btr0cur.ic

@@ -52,7 +52,9 @@ btr_cur_get_page(
 				/* out: pointer to page */
 	btr_cur_t*	cursor)	/* in: tree cursor */
 {
-	return(buf_frame_align(page_cur_get_rec(&(cursor->page_cur))));
+	page_t*	page = buf_frame_align(page_cur_get_rec(&(cursor->page_cur)));
+	ut_ad(!!page_is_comp(page) == cursor->index->table->comp);
+	return(page);
 }
 
 /*************************************************************

innobase/include/buf0buf.h

@@ -56,9 +56,11 @@ Created 11/5/1995 Heikki Tuuri
 #define BUF_NO_CHECKSUM_MAGIC 0xDEADBEEFUL
 
 extern buf_pool_t* 	buf_pool; 	/* The buffer pool of the database */
+#ifdef UNIV_DEBUG
 extern ibool		buf_debug_prints;/* If this is set TRUE, the program
 					prints info whenever read or flush
 					occurs */
+#endif /* UNIV_DEBUG */
 extern ulint srv_buf_pool_write_requests; /* variable to count write request
                                           issued */
 
@@ -382,10 +384,10 @@ Returns the value of the modify clock. The caller must have an s-lock
 or x-lock on the block. */
 UNIV_INLINE
 dulint
-buf_frame_get_modify_clock(
+buf_block_get_modify_clock(
 /*=======================*/
 				/* out: value */
-	buf_frame_t*	frame);	/* in: pointer to a frame */
+	buf_block_t*	block);	/* in: block */
 /************************************************************************
 Calculates a page checksum which is stored to the page when it is written
 to a file. Note that we must be careful to calculate the same value
@@ -480,12 +482,20 @@ buf_pool_is_block(
 /*==============*/
 			/* out: TRUE if pointer to block */
 	void*	ptr);	/* in: pointer to memory */
+#ifdef UNIV_DEBUG
 /*************************************************************************
 Validates the buffer pool data structure. */
 
 ibool
 buf_validate(void);
 /*==============*/
+/*************************************************************************
+Prints info of the buffer pool data structure. */
+
+void
+buf_print(void);
+/*============*/
+#endif /* UNIV_DEBUG */
 /************************************************************************
 Prints a page to stderr. */
 
@@ -494,12 +504,6 @@ buf_page_print(
 /*===========*/
 	byte*	read_buf);	/* in: a database page */
 /*************************************************************************
-Prints info of the buffer pool data structure. */
-
-void
-buf_print(void);
-/*============*/
-/*************************************************************************
 Returns the number of latched pages in the buffer pool. */
 
 ulint

innobase/include/buf0buf.ic

@@ -11,10 +11,11 @@ Created 11/5/1995 Heikki Tuuri
 #include "buf0rea.h"
 #include "mtr0mtr.h"
 
+#ifdef UNIV_DEBUG
 extern ulint		buf_dbg_counter; /* This is used to insert validation
 					operations in execution in the
 					debug version */
-					
+#endif /* UNIV_DEBUG */
 /************************************************************************
 Recommends a move of a block to the start of the LRU list if there is danger
 of dropping from the buffer pool. NOTE: does not reserve the buffer pool
@@ -26,12 +27,8 @@ buf_block_peek_if_too_old(
 				/* out: TRUE if should be made younger */
 	buf_block_t*	block)	/* in: block to make younger */
 {
-	if (buf_pool->freed_page_clock >= block->freed_page_clock 
-				+ 1 + (buf_pool->curr_size / 1024)) {
-		return(TRUE);
-	}
-
-	return(FALSE);
+	return(buf_pool->freed_page_clock >= block->freed_page_clock
+				+ 1 + (buf_pool->curr_size / 1024));
 }
 
 /*************************************************************************
@@ -210,8 +207,8 @@ buf_block_align(
 
 	frame_zero = buf_pool->frame_zero;
 
-	if ((ulint)ptr < (ulint)frame_zero
-	    || (ulint)ptr > (ulint)(buf_pool->high_end)) {
+	if (UNIV_UNLIKELY((ulint)ptr < (ulint)frame_zero)
+	    || UNIV_UNLIKELY((ulint)ptr > (ulint)(buf_pool->high_end))) {
 
 		ut_print_timestamp(stderr);	
 		fprintf(stderr,
@@ -246,8 +243,8 @@ buf_frame_align(
 
 	frame = ut_align_down(ptr, UNIV_PAGE_SIZE);
 
-	if (((ulint)frame < (ulint)(buf_pool->frame_zero))
-	    || (ulint)frame >= (ulint)(buf_pool->high_end)) {
+	if (UNIV_UNLIKELY((ulint)frame < (ulint)(buf_pool->frame_zero))
+	    || UNIV_UNLIKELY((ulint)frame >= (ulint)(buf_pool->high_end))) {
 
 		ut_print_timestamp(stderr);	
 		fprintf(stderr,
@@ -485,17 +482,11 @@ Returns the value of the modify clock. The caller must have an s-lock
 or x-lock on the block. */
 UNIV_INLINE
 dulint
-buf_frame_get_modify_clock(
+buf_block_get_modify_clock(
 /*=======================*/
 				/* out: value */
-	buf_frame_t*	frame)	/* in: pointer to a frame */
+	buf_block_t*	block)	/* in: block */
 {
-	buf_block_t*	block;
-
-	ut_ad(frame);
-
-	block = buf_block_align(frame);
-
 #ifdef UNIV_SYNC_DEBUG
 	ut_ad(rw_lock_own(&(block->lock), RW_LOCK_SHARED)
 	      || rw_lock_own(&(block->lock), RW_LOCK_EXCLUSIVE));

innobase/include/buf0lru.h

@@ -122,6 +122,7 @@ void
 buf_LRU_make_block_old(
 /*===================*/
 	buf_block_t*	block);	/* in: control block */
+#ifdef UNIV_DEBUG
 /**************************************************************************
 Validates the LRU list. */
 
@@ -134,6 +135,7 @@ Prints the LRU list. */
 void
 buf_LRU_print(void);
 /*===============*/
+#endif /* UNIV_DEBUG */
 
 #ifndef UNIV_NONINL
 #include "buf0lru.ic"

innobase/include/data0type.h

@@ -12,7 +12,7 @@ Created 1/16/1996 Heikki Tuuri
 #include "univ.i"
 
 extern ulint	data_mysql_default_charset_coll;
-extern ulint	data_mysql_latin1_swedish_charset_coll;
+#define DATA_MYSQL_LATIN1_SWEDISH_CHARSET_COLL 8
 
 /* SQL data type struct */
 typedef struct dtype_struct		dtype_t;

innobase/include/data0type.ic

@@ -388,8 +388,8 @@ dtype_get_fixed_size(
 					dtype_get_charset_coll(type->prtype),
 					&mbminlen, &mbmaxlen);
 
-				if (type->mbminlen != mbminlen
-					|| type->mbmaxlen != mbmaxlen) {
+				if (UNIV_UNLIKELY(type->mbminlen != mbminlen)
+				|| UNIV_UNLIKELY(type->mbmaxlen != mbmaxlen)) {
 
 					ut_print_timestamp(stderr);
 					fprintf(stderr, "  InnoDB: "

innobase/include/dyn0dyn.h

@@ -132,7 +132,7 @@ void
 dyn_push_string(
 /*============*/
 	dyn_array_t*	arr,	/* in: dyn array */
-	byte*		str,	/* in: string to write */
+	const byte*	str,	/* in: string to write */
 	ulint		len);	/* in: string length */
 
 /*#################################################################*/

innobase/include/dyn0dyn.ic

@@ -324,10 +324,9 @@ void
 dyn_push_string(
 /*============*/
 	dyn_array_t*	arr,	/* in: dyn array */
-	byte*		str,	/* in: string to write */
+	const byte*	str,	/* in: string to write */
 	ulint		len)	/* in: string length */
 {
-	byte*	ptr;
 	ulint	n_copied;
 
 	while (len > 0) {
@@ -337,9 +336,7 @@ dyn_push_string(
 			n_copied = len;
 		}			
 
-		ptr = (byte*) dyn_array_push(arr, n_copied);
-
-		ut_memcpy(ptr, str, n_copied);
+		memcpy(dyn_array_push(arr, n_copied), str, n_copied);
 		
 		str += n_copied;
 		len -= n_copied;

innobase/include/lock0lock.h

@@ -19,7 +19,9 @@ Created 5/7/1996 Heikki Tuuri
 #include "read0types.h"
 #include "hash0hash.h"
 
+#ifdef UNIV_DEBUG
 extern ibool	lock_print_waits;
+#endif /* UNIV_DEBUG */
 /* Buffer for storing information about the most recent deadlock error */
 extern FILE*	lock_latest_err_file;
 
@@ -216,6 +218,7 @@ actual record is being moved. */
 void
 lock_rec_store_on_page_infimum(
 /*===========================*/
+	page_t*	page,	/* in: page containing the record */
 	rec_t*	rec);	/* in: record whose lock state is stored
 			on the infimum record of the same page; lock
 			bits are reset on the record */
@@ -412,9 +415,7 @@ lock_table(
 				/* out: DB_SUCCESS, DB_LOCK_WAIT,
 				DB_DEADLOCK, or DB_QUE_THR_SUSPENDED */
 	ulint		flags,	/* in: if BTR_NO_LOCKING_FLAG bit is set,
-				does nothing;
-				if LOCK_TABLE_EXP bits are set,
-				creates an explicit table lock */
+				does nothing */
 	dict_table_t*	table,	/* in: database table in dictionary cache */
 	ulint		mode,	/* in: lock mode */
 	que_thr_t*	thr);	/* in: query thread */
@@ -451,15 +452,6 @@ lock_release_off_kernel(
 /*====================*/
 	trx_t*	trx);	/* in: transaction */
 /*************************************************************************
-Releases table locks explicitly requested with LOCK TABLES (indicated by
-lock type LOCK_TABLE_EXP), and releases possible other transactions waiting
-because of these locks. */
-
-void
-lock_release_tables_off_kernel(
-/*===========================*/
-	trx_t*	trx);	/* in: transaction */
-/*************************************************************************
 Cancels a waiting lock request and releases possible other transactions
 waiting behind it. */
 
@@ -618,9 +610,6 @@ extern lock_sys_t*	lock_sys;
 /* Lock types */
 #define LOCK_TABLE	16	/* these type values should be so high that */
 #define	LOCK_REC	32	/* they can be ORed to the lock mode */
-#define LOCK_TABLE_EXP	80	/* explicit table lock (80 = 16 + 64) */
-#define	LOCK_TABLE_TRANSACTIONAL	144
-				/* transactional table lock (144 = 16 + 128)*/
 #define LOCK_TYPE_MASK	0xF0UL	/* mask used to extract lock type from the
 				type_mode field in a lock */
 /* Waiting lock flag */

innobase/include/log0log.h

@@ -17,8 +17,12 @@ Created 12/9/1995 Heikki Tuuri
 typedef struct log_struct	log_t;
 typedef struct log_group_struct	log_group_t;
 
+#ifdef UNIV_DEBUG
 extern	ibool	log_do_write;
 extern 	ibool	log_debug_writes;
+#else /* UNIV_DEBUG */
+# define log_do_write TRUE
+#endif /* UNIV_DEBUG */
 
 /* Wait modes for log_write_up_to */
 #define LOG_NO_WAIT		91

innobase/include/mach0data.h

@@ -52,6 +52,27 @@ mach_read_from_2(
 /*=============*/
 			/* out: ulint integer, >= 0, < 64k */
 	byte*   b);      /* in: pointer to two bytes */
+
+/************************************************************
+The following function is used to convert a 16-bit data item
+to the canonical format, for fast bytewise equality test
+against memory. */
+UNIV_INLINE
+uint16
+mach_encode_2(
+/*==========*/
+			/* out: 16-bit integer in canonical format */
+	ulint	n);	/* in: integer in machine-dependent format */
+/************************************************************
+The following function is used to convert a 16-bit data item
+from the canonical format, for fast bytewise equality test
+against memory. */
+UNIV_INLINE
+ulint
+mach_decode_2(
+/*==========*/
+			/* out: integer in machine-dependent format */
+	uint16	n);	/* in: 16-bit integer in canonical format */
 /***********************************************************
 The following function is used to store data in 3 consecutive
 bytes. We store the most significant byte to the lowest address. */

innobase/include/mach0data.ic

@@ -68,6 +68,37 @@ mach_read_from_2(
 	      );
 }
 
+/************************************************************
+The following function is used to convert a 16-bit data item
+to the canonical format, for fast bytewise equality test
+against memory. */
+UNIV_INLINE
+uint16
+mach_encode_2(
+/*==========*/
+			/* out: 16-bit integer in canonical format */
+	ulint	n)	/* in: integer in machine-dependent format */
+{
+	uint16	ret;
+	ut_ad(2 == sizeof ret);
+	mach_write_to_2((byte*) &ret, n);
+	return(ret);
+}
+/************************************************************
+The following function is used to convert a 16-bit data item
+from the canonical format, for fast bytewise equality test
+against memory. */
+UNIV_INLINE
+ulint
+mach_decode_2(
+/*==========*/
+			/* out: integer in machine-dependent format */
+	uint16	n)	/* in: 16-bit integer in canonical format */
+{
+	ut_ad(2 == sizeof n);
+	return(mach_read_from_2((byte*) &n));
+}
+
 /***********************************************************
 The following function is used to store data in 3 consecutive
 bytes. We store the most significant byte to the lowest address. */

innobase/include/mem0mem.ic

@@ -623,7 +623,7 @@ mem_strdupq(
 	}
 	*d++ = q;
 	*d++ = '\0';
-	ut_ad(len == d - dst);
+	ut_ad((ssize_t) len == d - dst);
 	return(dst);
 }
 

innobase/include/mtr0log.h

@@ -41,10 +41,10 @@ corresponding log record to the mini-transaction log. */
 void
 mlog_write_string(
 /*==============*/
-	byte*	ptr,	/* in: pointer where to write */
-	byte*	str,	/* in: string to write */
-	ulint	len,	/* in: string length */
-	mtr_t*	mtr);	/* in: mini-transaction handle */
+	byte*		ptr,	/* in: pointer where to write */
+	const byte*	str,	/* in: string to write */
+	ulint		len,	/* in: string length */
+	mtr_t*		mtr);	/* in: mini-transaction handle */
 /************************************************************
 Writes initial part of a log record consisting of one-byte item
 type and four-byte space and page numbers. */
@@ -85,9 +85,9 @@ Catenates n bytes to the mtr log. */
 void
 mlog_catenate_string(
 /*=================*/
-	mtr_t*	mtr,	/* in: mtr */
-	byte*	str,	/* in: string to write */
-	ulint	len);	/* in: string length */
+	mtr_t*		mtr,	/* in: mtr */
+	const byte*	str,	/* in: string to write */
+	ulint		len);	/* in: string length */
 /************************************************************
 Catenates a compressed ulint to mlog. */
 UNIV_INLINE

innobase/include/mtr0mtr.h

@@ -112,7 +112,11 @@ flag value must give the length also! */
 						/* mark compact clustered index
 						record deleted */
 #define MLOG_COMP_REC_SEC_DELETE_MARK ((byte)40)/* mark compact secondary index
-						record deleted */
+						record deleted; this log
+						record type is redundant, as
+						MLOG_REC_SEC_DELETE_MARK is
+						independent of the record
+						format. */
 #define MLOG_COMP_REC_UPDATE_IN_PLACE ((byte)41)/* update of a compact record,
 						preserves record field sizes */
 #define MLOG_COMP_REC_DELETE	((byte)42)	/* delete a compact record

innobase/include/os0file.h

@@ -17,6 +17,8 @@ Created 10/21/1995 Heikki Tuuri
 #include <time.h>
 #endif
 
+typedef	struct fil_node_struct	fil_node_t;
+
 extern ibool	os_do_not_call_flush_at_each_write;
 extern ibool	os_has_said_disk_full;
 extern ibool	os_aio_print_debug;
@@ -563,7 +565,7 @@ os_aio(
 	ulint		offset_high, /* in: most significant 32 bits of
 				offset */
 	ulint		n,	/* in: number of bytes to read or write */	
-	void*		message1,/* in: messages for the aio handler (these
+	fil_node_t*	message1,/* in: messages for the aio handler (these
 				can be used to identify a completed aio
 				operation); if mode is OS_AIO_SYNC, these
 				are ignored */
@@ -621,7 +623,7 @@ os_aio_windows_handle(
 				ignored */
 	ulint	pos,		/* this parameter is used only in sync aio:
 				wait for the aio slot at this position */  
-	void**	message1,	/* out: the messages passed with the aio
+	fil_node_t**message1,	/* out: the messages passed with the aio
 				request; note that also in the case where
 				the aio operation failed, these output
 				parameters are valid and can be used to
@@ -641,7 +643,7 @@ os_aio_posix_handle(
 /*================*/
 				/* out: TRUE if the aio operation succeeded */
 	ulint	array_no,	/* in: array number 0 - 3 */
-	void**	message1,	/* out: the messages passed with the aio
+	fil_node_t**message1,	/* out: the messages passed with the aio
 				request; note that also in the case where
 				the aio operation failed, these output
 				parameters are valid and can be used to
@@ -661,7 +663,7 @@ os_aio_simulated_handle(
 				i/o thread, segment 1 the log i/o thread,
 				then follow the non-ibuf read threads, and as
 				the last are the non-ibuf write threads */
-	void**	message1,	/* out: the messages passed with the aio
+	fil_node_t**message1,	/* out: the messages passed with the aio
 				request; note that also in the case where
 				the aio operation failed, these output
 				parameters are valid and can be used to
@@ -688,6 +690,8 @@ Refreshes the statistics used to print per-second averages. */
 void
 os_aio_refresh_stats(void);
 /*======================*/
+
+#ifdef UNIV_DEBUG
 /**************************************************************************
 Checks that all slots in the system have been freed, that is, there are
 no pending io operations. */
@@ -695,6 +699,7 @@ no pending io operations. */
 ibool
 os_aio_all_slots_free(void);
 /*=======================*/
+#endif /* UNIV_DEBUG */
 
 /***********************************************************************
 This function returns information about the specified file */

innobase/include/page0cur.h

@@ -78,16 +78,16 @@ UNIV_INLINE
 ibool
 page_cur_is_before_first(
 /*=====================*/
-				/* out: TRUE if at start */
-	page_cur_t*	cur);	/* in: cursor */
+					/* out: TRUE if at start */
+	const page_cur_t*	cur);	/* in: cursor */
 /*************************************************************
 Returns TRUE if the cursor is after last user record. */
 UNIV_INLINE
 ibool
 page_cur_is_after_last(
 /*===================*/
-				/* out: TRUE if at end */
-	page_cur_t*	cur);	/* in: cursor */
+					/* out: TRUE if at end */
+	const page_cur_t*	cur);	/* in: cursor */
 /**************************************************************
 Positions the cursor on the given record. */
 UNIV_INLINE

innobase/include/page0cur.ic

@@ -69,15 +69,10 @@ UNIV_INLINE
 ibool
 page_cur_is_before_first(
 /*=====================*/
-				/* out: TRUE if at start */
-	page_cur_t*	cur)	/* in: cursor */
+					/* out: TRUE if at start */
+	const page_cur_t*	cur)	/* in: cursor */
 {
-	if (page_get_infimum_rec(page_cur_get_page(cur)) == cur->rec) {
-
-		return(TRUE);
-	}
-
-	return(FALSE);
+	return(page_rec_is_infimum(cur->rec));
 }
 
 /*************************************************************
@@ -86,15 +81,10 @@ UNIV_INLINE
 ibool
 page_cur_is_after_last(
 /*===================*/
-				/* out: TRUE if at end */
-	page_cur_t*	cur)	/* in: cursor */
+					/* out: TRUE if at end */
+	const page_cur_t*	cur)	/* in: cursor */
 {
-	if (page_get_supremum_rec(page_cur_get_page(cur)) == cur->rec) {
-
-		return(TRUE);
-	}
-
-	return(FALSE);
+	return(page_rec_is_supremum(cur->rec));
 }
 
 /**************************************************************

innobase/include/page0page.h

@@ -373,13 +373,21 @@ page_dir_find_owner_slot(
 /****************************************************************
 Determine whether the page is in new-style compact format. */
 UNIV_INLINE
-ibool
+ulint
 page_is_comp(
 /*=========*/
-			/* out: TRUE if the page is in compact format
-			FALSE if it is in old-style format */
+			/* out: nonzero if the page is in compact
+			format, zero if it is in old-style format */
 	page_t*	page);	/* in: index page */
 /****************************************************************
+TRUE if the record is on a page in compact format. */
+UNIV_INLINE
+ulint
+page_rec_is_comp(
+/*=============*/
+				/* out: nonzero if in compact format */
+	const rec_t*	rec);	/* in: record */
+/****************************************************************
 Gets the pointer to the next record on the page. */
 UNIV_INLINE
 rec_t*
@@ -407,47 +415,55 @@ page_rec_get_prev(
 				/* out: pointer to previous record */
 	rec_t*		rec);	/* in: pointer to record,
 				must not be page infimum */
-
 /****************************************************************
 TRUE if the record is a user record on the page. */
 UNIV_INLINE
 ibool
-page_rec_is_user_rec(
-/*=================*/
+page_rec_is_user_rec_low(
+/*=====================*/
 			/* out: TRUE if a user record */
-	rec_t*	rec);	/* in: record */
+	ulint	offset);/* in: record offset on page */
 /****************************************************************
 TRUE if the record is the supremum record on a page. */
 UNIV_INLINE
 ibool
-page_rec_is_supremum(
-/*=================*/
+page_rec_is_supremum_low(
+/*=====================*/
 			/* out: TRUE if the supremum record */
-	rec_t*	rec);	/* in: record */
+	ulint	offset);/* in: record offset on page */
 /****************************************************************
 TRUE if the record is the infimum record on a page. */
 UNIV_INLINE
 ibool
-page_rec_is_infimum(
-/*================*/
+page_rec_is_infimum_low(
+/*=====================*/
 			/* out: TRUE if the infimum record */
-	rec_t*	rec);	/* in: record */
+	ulint	offset);/* in: record offset on page */
+
 /****************************************************************
-TRUE if the record is the first user record on the page. */
+TRUE if the record is a user record on the page. */
 UNIV_INLINE
 ibool
-page_rec_is_first_user_rec(
-/*=======================*/
-			/* out: TRUE if first user record */
-	rec_t*	rec);	/* in: record */
+page_rec_is_user_rec(
+/*=================*/
+				/* out: TRUE if a user record */
+	const rec_t*	rec);	/* in: record */
 /****************************************************************
-TRUE if the record is the last user record on the page. */
+TRUE if the record is the supremum record on a page. */
 UNIV_INLINE
 ibool
-page_rec_is_last_user_rec(
-/*======================*/
-			/* out: TRUE if last user record */
-	rec_t*	rec);	/* in: record */
+page_rec_is_supremum(
+/*=================*/
+				/* out: TRUE if the supremum record */
+	const rec_t*	rec);	/* in: record */
+/****************************************************************
+TRUE if the record is the infimum record on a page. */
+UNIV_INLINE
+ibool
+page_rec_is_infimum(
+/*================*/
+				/* out: TRUE if the infimum record */
+	const rec_t*	rec);	/* in: record */
 /*******************************************************************
 Looks for the record which owns the given record. */
 UNIV_INLINE
@@ -495,7 +511,7 @@ ulint
 page_get_free_space_of_empty(
 /*=========================*/
 			/* out: free space */
-	ibool	comp)	/* in: TRUE=compact page format */
+	ulint	comp)	/* in: nonzero=compact page format */
 		__attribute__((const));
 /****************************************************************
 Returns the sum of the sizes of the records in the record list
@@ -539,7 +555,7 @@ page_create(
 	buf_frame_t*	frame,		/* in: a buffer frame where the page is
 					created */
 	mtr_t*		mtr,		/* in: mini-transaction handle */
-	ibool		comp);		/* in: TRUE=compact page format */
+	ulint		comp);		/* in: nonzero=compact page format */
 /*****************************************************************
 Differs from page_copy_rec_list_end, because this function does not
 touch the lock table and max trx id on page. */
@@ -673,7 +689,7 @@ page_parse_create(
 			/* out: end of log record or NULL */
 	byte*	ptr,	/* in: buffer */
 	byte*	end_ptr,/* in: buffer end */
-	ibool	comp,	/* in: TRUE=compact page format */
+	ulint	comp,	/* in: nonzero=compact page format */
 	page_t*	page,	/* in: page or NULL */
 	mtr_t*	mtr);	/* in: mtr or NULL */
 /****************************************************************

innobase/include/read0read.ic

@@ -71,13 +71,8 @@ read_view_sees_trx_id(
 
 		cmp = ut_dulint_cmp(trx_id,
 				read_view_get_nth_trx_id(view, n_ids - i - 1));
-		if (0 == cmp) {
-
-			return(FALSE);
-
-		} else if (cmp < 0) {
-
-			return(TRUE);
+		if (cmp <= 0) {
+			return(cmp < 0);
 		}
 	}
 	

innobase/include/rem0rec.h

@@ -51,7 +51,7 @@ rec_get_next_offs(
 			/* out: the page offset of the next 
 			chained record */
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp);	/* in: TRUE=compact page format */
+	ulint	comp);	/* in: nonzero=compact page format */
 /**********************************************************
 The following function is used to set the next record offset field
 of the record. */
@@ -60,7 +60,7 @@ void
 rec_set_next_offs(
 /*==============*/
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp,	/* in: TRUE=compact page format */
+	ulint	comp,	/* in: nonzero=compact page format */
 	ulint	next);	/* in: offset of the next record */
 /**********************************************************
 The following function is used to get the number of fields
@@ -90,7 +90,7 @@ rec_get_n_owned(
 /*============*/
 			/* out: number of owned records */
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp);	/* in: TRUE=compact page format */
+	ulint	comp);	/* in: nonzero=compact page format */
 /**********************************************************
 The following function is used to set the number of owned
 records. */
@@ -99,7 +99,7 @@ void
 rec_set_n_owned(
 /*============*/
 	rec_t*	rec,		/* in: physical record */
-	ibool	comp,		/* in: TRUE=compact page format */
+	ulint	comp,		/* in: nonzero=compact page format */
 	ulint	n_owned);	/* in: the number of owned */
 /**********************************************************
 The following function is used to retrieve the info bits of
@@ -110,7 +110,7 @@ rec_get_info_bits(
 /*==============*/
 			/* out: info bits */
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp);	/* in: TRUE=compact page format */
+	ulint	comp);	/* in: nonzero=compact page format */
 /**********************************************************
 The following function is used to set the info bits of a record. */
 UNIV_INLINE
@@ -118,7 +118,7 @@ void
 rec_set_info_bits(
 /*==============*/
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp,	/* in: TRUE=compact page format */
+	ulint	comp,	/* in: nonzero=compact page format */
 	ulint	bits);	/* in: info bits */
 /**********************************************************
 The following function retrieves the status bits of a new-style record. */
@@ -147,7 +147,7 @@ rec_get_info_and_status_bits(
 /*=========================*/
 			/* out: info bits */
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp);	/* in: TRUE=compact page format */
+	ulint	comp);	/* in: nonzero=compact page format */
 /**********************************************************
 The following function is used to set the info and status
 bits of a record.  (Only compact records have status bits.) */
@@ -156,18 +156,18 @@ void
 rec_set_info_and_status_bits(
 /*=========================*/
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp,	/* in: TRUE=compact page format */
+	ulint	comp,	/* in: nonzero=compact page format */
 	ulint	bits);	/* in: info bits */
 
 /**********************************************************
 The following function tells if record is delete marked. */
 UNIV_INLINE
-ibool
+ulint
 rec_get_deleted_flag(
 /*=================*/
-			/* out: TRUE if delete marked */
+			/* out: nonzero if delete marked */
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp);	/* in: TRUE=compact page format */
+	ulint	comp);	/* in: nonzero=compact page format */
 /**********************************************************
 The following function is used to set the deleted bit. */
 UNIV_INLINE
@@ -175,8 +175,8 @@ void
 rec_set_deleted_flag(
 /*=================*/
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp,	/* in: TRUE=compact page format */
-	ibool	flag);	/* in: TRUE if delete marked */
+	ulint	comp,	/* in: nonzero=compact page format */
+	ulint	flag);	/* in: nonzero if delete marked */
 /**********************************************************
 The following function tells if a new-style record is a node pointer. */
 UNIV_INLINE
@@ -186,14 +186,6 @@ rec_get_node_ptr_flag(
 			/* out: TRUE if node pointer */
 	rec_t*	rec);	/* in: physical record */
 /**********************************************************
-The following function is used to flag a record as a node pointer. */
-UNIV_INLINE
-void
-rec_set_node_ptr_flag(
-/*=================*/
-	rec_t*	rec,	/* in: physical record */
-	ibool	flag);	/* in: TRUE if the record is a node pointer */
-/**********************************************************
 The following function is used to get the order number
 of the record in the heap of the index page. */
 UNIV_INLINE
@@ -202,7 +194,7 @@ rec_get_heap_no(
 /*=============*/
 			/* out: heap order number */
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp);	/* in: TRUE=compact page format */
+	ulint	comp);	/* in: nonzero=compact page format */
 /**********************************************************
 The following function is used to set the heap number
 field in the record. */
@@ -211,7 +203,7 @@ void
 rec_set_heap_no(
 /*=============*/
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp,	/* in: TRUE=compact page format */
+	ulint	comp,	/* in: nonzero=compact page format */
 	ulint	heap_no);/* in: the heap number */
 /**********************************************************
 The following function is used to test whether the data offsets
@@ -305,27 +297,18 @@ rec_get_nth_field(
 Determine if the offsets are for a record in the new
 compact format. */
 UNIV_INLINE
-ibool
+ulint
 rec_offs_comp(
 /*==========*/
-				/* out: TRUE if compact format */
+				/* out: nonzero if compact format */
 	const ulint*	offsets);/* in: array returned by rec_get_offsets() */
 /**********************************************************
-Returns TRUE if the nth field of rec is SQL NULL. */
+Returns nonzero if the extern bit is set in nth field of rec. */
 UNIV_INLINE
-ibool
-rec_offs_nth_null(
-/*==============*/
-				/* out: TRUE if SQL NULL */
-	const ulint*	offsets,/* in: array returned by rec_get_offsets() */
-	ulint		n);	/* in: nth field */
-/**********************************************************
-Returns TRUE if the extern bit is set in nth field of rec. */
-UNIV_INLINE
-ibool
+ulint
 rec_offs_nth_extern(
 /*================*/
-				/* out: TRUE if externally stored */
+				/* out: nonzero if externally stored */
 	const ulint*	offsets,/* in: array returned by rec_get_offsets() */
 	ulint		n);	/* in: nth field */
 /**********************************************************

innobase/include/rem0rec.ic

@@ -265,7 +265,7 @@ rec_get_next_offs(
 			/* 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	comp)	/* in: nonzero=compact page format */
 {	
 	ulint	field_value;
 		
@@ -312,7 +312,7 @@ void
 rec_set_next_offs(
 /*==============*/
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp,	/* in: TRUE=compact page format */
+	ulint	comp,	/* in: nonzero=compact page format */
 	ulint	next)	/* in: offset of the next record, or 0 if none */
 {
 	ut_ad(rec);
@@ -414,7 +414,7 @@ rec_get_n_fields(
 {
 	ut_ad(rec);
 	ut_ad(index);
-	if (!index->table->comp) {
+	if (UNIV_UNLIKELY(!index->table->comp)) {
 		return(rec_get_n_fields_old(rec));
 	}
 	switch (rec_get_status(rec)) {
@@ -440,7 +440,7 @@ rec_get_n_owned(
 /*============*/
 			/* out: number of owned records */
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp)	/* in: TRUE=compact page format */
+	ulint	comp)	/* in: nonzero=compact page format */
 {
 	ulint	ret;
 
@@ -461,7 +461,7 @@ void
 rec_set_n_owned(
 /*============*/
 	rec_t*	rec,		/* in: physical record */
-	ibool	comp,		/* in: TRUE=compact page format */
+	ulint	comp,		/* in: nonzero=compact page format */
 	ulint	n_owned)	/* in: the number of owned */
 {
 	ut_ad(rec);
@@ -480,7 +480,7 @@ rec_get_info_bits(
 /*==============*/
 			/* out: info bits */
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp)	/* in: TRUE=compact page format */
+	ulint	comp)	/* in: nonzero=compact page format */
 {
 	ulint	ret;
 
@@ -501,7 +501,7 @@ void
 rec_set_info_bits(
 /*==============*/
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp,	/* in: TRUE=compact page format */
+	ulint	comp,	/* in: nonzero=compact page format */
 	ulint	bits)	/* in: info bits */
 {
 	ut_ad(rec);
@@ -537,14 +537,14 @@ rec_get_info_and_status_bits(
 /*=========================*/
 			/* out: info bits */
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp)	/* in: TRUE=compact page format */
+	ulint	comp)	/* in: nonzero=compact page format */
 {
 	ulint	bits;
 #if (REC_NEW_STATUS_MASK >> REC_NEW_STATUS_SHIFT) \
 & (REC_INFO_BITS_MASK >> REC_INFO_BITS_SHIFT)
 # error "REC_NEW_STATUS_MASK and REC_INFO_BITS_MASK overlap"
 #endif
-	if (comp) {
+	if (UNIV_EXPECT(comp, REC_OFFS_COMPACT)) {
 		bits = rec_get_info_bits(rec, TRUE) | rec_get_status(rec);
 	} else {
 		bits = rec_get_info_bits(rec, FALSE);
@@ -560,7 +560,7 @@ void
 rec_set_info_and_status_bits(
 /*=========================*/
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp,	/* in: TRUE=compact page format */
+	ulint	comp,	/* in: nonzero=compact page format */
 	ulint	bits)	/* in: info bits */
 {
 #if (REC_NEW_STATUS_MASK >> REC_NEW_STATUS_SHIFT) \
@@ -578,19 +578,22 @@ rec_set_info_and_status_bits(
 /**********************************************************
 The following function tells if record is delete marked. */
 UNIV_INLINE
-ibool
+ulint
 rec_get_deleted_flag(
 /*=================*/
-			/* out: TRUE if delete marked */
+			/* out: nonzero if delete marked */
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp)	/* in: TRUE=compact page format */
+	ulint	comp)	/* in: nonzero=compact page format */
 {
-	if (REC_INFO_DELETED_FLAG & rec_get_info_bits(rec, comp)) {
-
-		return(TRUE);
+	if (UNIV_EXPECT(comp, REC_OFFS_COMPACT)) {
+		return(UNIV_UNLIKELY(rec_get_bit_field_1(rec,
+				REC_NEW_INFO_BITS, REC_INFO_DELETED_FLAG,
+				REC_INFO_BITS_SHIFT)));
+	} else {
+		return(UNIV_UNLIKELY(rec_get_bit_field_1(rec,
+				REC_OLD_INFO_BITS, REC_INFO_DELETED_FLAG,
+				REC_INFO_BITS_SHIFT)));
 	}
-
-	return(FALSE);
 }
 
 /**********************************************************
@@ -600,24 +603,20 @@ void
 rec_set_deleted_flag(
 /*=================*/
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp,	/* in: TRUE=compact page format */
-	ibool	flag)	/* in: TRUE if delete marked */
+	ulint	comp,	/* in: nonzero=compact page format */
+	ulint	flag)	/* in: nonzero if delete marked */
 {
-	ulint	old_val;
-	ulint	new_val;
-
-	ut_ad(TRUE == 1);
-	ut_ad(flag <= TRUE);
+	ulint	val;
 
-	old_val = rec_get_info_bits(rec, comp);
+	val = rec_get_info_bits(rec, comp);
 	
 	if (flag) {
-		new_val = REC_INFO_DELETED_FLAG | old_val;
+		val |= REC_INFO_DELETED_FLAG;
 	} else {
-		new_val = ~REC_INFO_DELETED_FLAG & old_val;
+		val &= ~REC_INFO_DELETED_FLAG;
 	}
 
-	rec_set_info_bits(rec, comp, new_val);
+	rec_set_info_bits(rec, comp, val);
 }
 
 /**********************************************************
@@ -632,26 +631,6 @@ rec_get_node_ptr_flag(
 	return(REC_STATUS_NODE_PTR == rec_get_status(rec));
 }
 
-/**********************************************************
-The following function is used to flag a record as a node pointer. */
-UNIV_INLINE
-void
-rec_set_node_ptr_flag(
-/*=================*/
-	rec_t*	rec,	/* in: physical record */
-	ibool	flag)	/* in: TRUE if the record is a node pointer */
-{
-	ulint	status;
-	ut_ad(flag <= TRUE);
-	ut_ad(REC_STATUS_NODE_PTR >= rec_get_status(rec));
-	if (flag) {
-		status = REC_STATUS_NODE_PTR;
-	} else {
-		status = REC_STATUS_ORDINARY;
-	}
-	rec_set_status(rec, status);
-}
-
 /**********************************************************
 The following function is used to get the order number of the record in the
 heap of the index page. */
@@ -661,7 +640,7 @@ rec_get_heap_no(
 /*=============*/
 			/* out: heap order number */
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp)	/* in: TRUE=compact page format */
+	ulint	comp)	/* in: nonzero=compact page format */
 {
 	ulint	ret;
 
@@ -682,7 +661,7 @@ void
 rec_set_heap_no(
 /*=============*/
 	rec_t*	rec,	/* in: physical record */
-	ibool	comp,	/* in: TRUE=compact page format */
+	ulint	comp,	/* in: nonzero=compact page format */
 	ulint	heap_no)/* in: the heap number */
 {
 	ut_ad(heap_no <= REC_MAX_HEAP_NO);
@@ -843,7 +822,7 @@ rec_offs_validate(
 {
 	ulint	i	= rec_offs_n_fields(offsets);
 	ulint	last	= ULINT_MAX;
-	ibool	comp	= (*rec_offs_base(offsets) & REC_OFFS_COMPACT) != 0;
+	ulint	comp	= *rec_offs_base(offsets) & REC_OFFS_COMPACT;
 
 	if (rec) {
 		ut_ad((ulint) rec == offsets[2]);
@@ -926,7 +905,7 @@ rec_get_nth_field(
 	ut_ad(n < rec_offs_n_fields(offsets));
 	ut_ad(len);
 
-	if (n == 0) {
+	if (UNIV_UNLIKELY(n == 0)) {
 		field = rec;
 	} else {
 		field = rec + (rec_offs_base(offsets)[n] & REC_OFFS_MASK);
@@ -949,43 +928,30 @@ rec_get_nth_field(
 Determine if the offsets are for a record in the new
 compact format. */
 UNIV_INLINE
-ibool
+ulint
 rec_offs_comp(
 /*==========*/
-				/* out: TRUE if compact format */
+				/* out: nonzero if compact format */
 	const ulint*	offsets)/* in: array returned by rec_get_offsets() */
 {
 	ut_ad(rec_offs_validate(NULL, NULL, offsets));
-	return((*rec_offs_base(offsets) & REC_OFFS_COMPACT) != 0);
+	return(*rec_offs_base(offsets) & REC_OFFS_COMPACT);
 }
 
 /**********************************************************
-Returns TRUE if the nth field of rec is SQL NULL. */
-UNIV_INLINE
-ibool
-rec_offs_nth_null(
-/*==============*/
-				/* out: TRUE if SQL NULL */
-	const ulint*	offsets,/* in: array returned by rec_get_offsets() */
-	ulint		n)	/* in: nth field */
-{
-	ut_ad(rec_offs_validate(NULL, NULL, offsets));
-	ut_ad(n < rec_offs_n_fields(offsets));
-	return((rec_offs_base(offsets)[1 + n] & REC_OFFS_SQL_NULL) != 0);
-}
-/**********************************************************
-Returns TRUE if the extern bit is set in nth field of rec. */
+Returns nonzero if the extern bit is set in nth field of rec. */
 UNIV_INLINE
-ibool
+ulint
 rec_offs_nth_extern(
 /*================*/
-				/* out: TRUE if externally stored */
+				/* out: nonzero if externally stored */
 	const ulint*	offsets,/* in: array returned by rec_get_offsets() */
 	ulint		n)	/* in: nth field */
 {
 	ut_ad(rec_offs_validate(NULL, NULL, offsets));
 	ut_ad(n < rec_offs_n_fields(offsets));
-	return((rec_offs_base(offsets)[1 + n] & REC_OFFS_EXTERNAL) != 0);
+	return(UNIV_UNLIKELY(rec_offs_base(offsets)[1 + n]
+				& REC_OFFS_EXTERNAL));
 }
 
 /**********************************************************
@@ -1037,7 +1003,7 @@ rec_set_nth_field_extern_bit(
 				where rec is, or NULL; in the NULL case
 				we do not write to log about the change */
 {
-	if (index->table->comp) {
+	if (UNIV_LIKELY(index->table->comp)) {
 		rec_set_nth_field_extern_bit_new(rec, index, i, val, mtr);
 	} else {
 		rec_set_nth_field_extern_bit_old(rec, i, val, mtr);
@@ -1048,7 +1014,7 @@ rec_set_nth_field_extern_bit(
 Returns the offset of n - 1th field end if the record is stored in the 1-byte
 offsets form. If the field is SQL null, the flag is ORed in the returned
 value. This function and the 2-byte counterpart are defined here because the
-C-compilerwas not able to sum negative and positive constant offsets, and
+C-compiler was not able to sum negative and positive constant offsets, and
 warned of constant arithmetic overflow within the compiler. */
 UNIV_INLINE
 ulint
@@ -1452,7 +1418,7 @@ rec_get_converted_size(
 				? dict_index_get_n_unique_in_tree(index) + 1
 				: dict_index_get_n_fields(index)));
 
-	if (index->table->comp) {
+	if (UNIV_LIKELY(index->table->comp)) {
 		return(rec_get_converted_size_new(index, dtuple));
 	}
 

innobase/include/row0mysql.h

@@ -110,7 +110,7 @@ row_mysql_store_col_in_innobase_format(
 					necessarily the length of the actual
 					payload data; if the column is a true
 					VARCHAR then this is irrelevant */
-	ibool		comp);		/* in: TRUE = compact format */
+	ulint		comp);		/* in: nonzero=compact format */
 /********************************************************************
 Handles user errors and lock waits detected by the database engine. */
 
@@ -172,14 +172,6 @@ row_lock_table_autoinc_for_mysql(
 	row_prebuilt_t*	prebuilt);	/* in: prebuilt struct in the MySQL
 					table handle */
 /*************************************************************************
-Unlocks all table locks explicitly requested by trx (with LOCK TABLES,
-lock type LOCK_TABLE_EXP). */
-
-void		  	
-row_unlock_tables_for_mysql(
-/*========================*/
-	trx_t*	trx);	/* in: transaction */
-/*************************************************************************
 Sets a table lock on the table mentioned in prebuilt. */
 
 int
@@ -190,9 +182,10 @@ row_lock_table_for_mysql(
 					table handle */
 	dict_table_t*	table,		/* in: table to lock, or NULL
 					if prebuilt->table should be
-					locked as LOCK_TABLE_EXP |
+					locked as
 					prebuilt->select_lock_type */
-	ulint		mode);		/* in: lock mode of table */
+	ulint		mode);		/* in: lock mode of table
+					(ignored if table==NULL) */
 					   
 /*************************************************************************
 Does an insert for MySQL. */
@@ -599,6 +592,8 @@ struct row_prebuilt_struct {
 					that was decided in ha_innodb.cc,
 					::store_lock(), ::external_lock(),
 					etc. */
+	ulint		mysql_prefix_len;/* byte offset of the end of
+					the last requested column */
 	ulint		mysql_row_len;	/* length in bytes of a row in the
 					MySQL format */
 	ulint		n_rows_fetched;	/* number of rows fetched after

innobase/include/row0sel.ic

@@ -75,7 +75,7 @@ open_step(
 		}
 	}
 			
-	if (err != DB_SUCCESS) {
+	if (UNIV_EXPECT(err, DB_SUCCESS) != DB_SUCCESS) {
 		/* SQL error detected */
 		fprintf(stderr, "SQL error %lu\n", (ulong) err);
 

innobase/include/row0upd.ic

@@ -83,7 +83,7 @@ upd_field_set_field_no(
 {	
 	upd_field->field_no = field_no;
 
-	if (field_no >= dict_index_get_n_fields(index)) {
+	if (UNIV_UNLIKELY(field_no >= dict_index_get_n_fields(index))) {
 		fprintf(stderr,
 			"InnoDB: Error: trying to access field %lu in ",
 			(ulong) field_no);

innobase/include/sync0rw.ic

@@ -138,7 +138,7 @@ rw_lock_s_lock_low(
 #endif /* UNIV_SYNC_DEBUG */
 	/* Check if the writer field is free */
 
-	if (lock->writer == RW_LOCK_NOT_LOCKED) {
+	if (UNIV_LIKELY(lock->writer == RW_LOCK_NOT_LOCKED)) {
 		/* Set the shared lock by incrementing the reader count */
 		lock->reader_count++;
 
@@ -243,7 +243,7 @@ rw_lock_s_lock_func(
 
 	mutex_enter(rw_lock_get_mutex(lock));
 
-	if (TRUE == rw_lock_s_lock_low(lock, pass, file_name, line)) {
+	if (UNIV_LIKELY(rw_lock_s_lock_low(lock, pass, file_name, line))) {
 		mutex_exit(rw_lock_get_mutex(lock));
 
 		return; /* Success */
@@ -307,21 +307,18 @@ rw_lock_x_lock_func_nowait(
 	const char*	file_name,/* in: file name where lock requested */
 	ulint		line)	/* in: line where requested */
 {
-	ibool	success	= FALSE;
-	
+	ibool		success		= FALSE;
+	os_thread_id_t	curr_thread	= os_thread_get_curr_id();
 	mutex_enter(rw_lock_get_mutex(lock));
 
-	if ((rw_lock_get_reader_count(lock) == 0)
-	     && ((rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED)
-	     	 || ((rw_lock_get_writer(lock) == RW_LOCK_EX)
-	     	     && (lock->pass == 0)
-	     	     && os_thread_eq(lock->writer_thread,
-					os_thread_get_curr_id())))) {
-
+	if (UNIV_UNLIKELY(rw_lock_get_reader_count(lock) != 0)) {
+	} else if (UNIV_LIKELY(rw_lock_get_writer(lock)
+			       == RW_LOCK_NOT_LOCKED)) {
 		rw_lock_set_writer(lock, RW_LOCK_EX);
-		lock->writer_thread = os_thread_get_curr_id();
-		lock->writer_count++;
+		lock->writer_thread = curr_thread;
 		lock->pass = 0;
+	relock:
+		lock->writer_count++;
 			
 #ifdef UNIV_SYNC_DEBUG
 		rw_lock_add_debug_info(lock, 0, RW_LOCK_EX, file_name, line);
@@ -331,6 +328,10 @@ rw_lock_x_lock_func_nowait(
 		lock->last_x_line = line;
 
 		success = TRUE;
+	} else if (rw_lock_get_writer(lock) == RW_LOCK_EX
+			&& lock->pass == 0
+			&& os_thread_eq(lock->writer_thread, curr_thread)) {
+		goto relock;
 	}
 
 	mutex_exit(rw_lock_get_mutex(lock));
@@ -361,7 +362,7 @@ rw_lock_s_unlock_func(
 
 	/* Reset the shared lock by decrementing the reader count */
 
-	ut_a(lock->reader_count > 0);
+	ut_ad(lock->reader_count > 0);
 	lock->reader_count--;
 
 #ifdef UNIV_SYNC_DEBUG
@@ -371,7 +372,8 @@ rw_lock_s_unlock_func(
 	/* If there may be waiters and this was the last s-lock,
 	signal the object */
 
-	if (lock->waiters && (lock->reader_count == 0)) {
+	if (UNIV_UNLIKELY(lock->waiters)
+			&& lock->reader_count == 0) {
 	       	sg = TRUE;
 
 		rw_lock_set_waiters(lock, 0);
@@ -379,7 +381,7 @@ rw_lock_s_unlock_func(
 	
 	mutex_exit(mutex);
 
-	if (sg == TRUE) {
+	if (UNIV_UNLIKELY(sg)) {
 		sync_array_signal_object(sync_primary_wait_array, lock);
 	}
 
@@ -450,7 +452,8 @@ rw_lock_x_unlock_func(
 #endif
 	
 	/* If there may be waiters, signal the lock */
-	if (lock->waiters && (lock->writer_count == 0)) {
+	if (UNIV_UNLIKELY(lock->waiters)
+			&& lock->writer_count == 0) {
 
 	       	sg = TRUE;
 		rw_lock_set_waiters(lock, 0);
@@ -458,7 +461,7 @@ rw_lock_x_unlock_func(
 	
 	mutex_exit(&(lock->mutex));
 
-	if (sg == TRUE) {
+	if (UNIV_UNLIKELY(sg)) {
 		sync_array_signal_object(sync_primary_wait_array, lock);
 	}
 

innobase/include/trx0rseg.ic

@@ -65,7 +65,7 @@ trx_rsegf_get_nth_undo(
 	ulint		n,	/* in: index of slot */
 	mtr_t*		mtr)	/* in: mtr */
 {
-	if (n >= TRX_RSEG_N_SLOTS) {
+	if (UNIV_UNLIKELY(n >= TRX_RSEG_N_SLOTS)) {
 		fprintf(stderr,
 		"InnoDB: Error: trying to get slot %lu of rseg\n", (unsigned long) n);
 		ut_error;
@@ -86,7 +86,7 @@ trx_rsegf_set_nth_undo(
 	ulint		page_no,/* in: page number of the undo log segment */
 	mtr_t*		mtr)	/* in: mtr */
 {
-	if (n >= TRX_RSEG_N_SLOTS) {
+	if (UNIV_UNLIKELY(n >= TRX_RSEG_N_SLOTS)) {
 		fprintf(stderr,
 		"InnoDB: Error: trying to set slot %lu of rseg\n", (unsigned long) n);
 		ut_error;

innobase/include/trx0trx.h

@@ -312,6 +312,19 @@ trx_print(
 	FILE*	f,	/* in: output stream */
 	trx_t*	trx);	/* in: transaction */
 
+#ifndef UNIV_HOTBACKUP
+/**************************************************************************
+Determines if the currently running transaction has been interrupted. */
+
+ibool
+trx_is_interrupted(
+/*===============*/
+			/* out: TRUE if interrupted */
+	trx_t*	trx);	/* in: transaction */
+#else /* !UNIV_HOTBACKUP */
+#define trx_is_interrupted(trx) FALSE
+#endif /* !UNIV_HOTBACKUP */
+
 
 /* Signal to a transaction */
 struct trx_sig_struct{
@@ -484,13 +497,6 @@ struct trx_struct{
 					in the lock list trx_locks */
 	ibool		trx_create_lock;/* this is TRUE if we have created a
 					new lock for a record accessed */
-	ulint		n_lock_table_exp;/* number of explicit table locks
-					(LOCK TABLES) reserved by the
-					transaction, stored in trx_locks */
-	ulint		n_lock_table_transactional;
-					/* number of transactional table locks
-					(LOCK TABLES..WHERE ENGINE) reserved by
-					the transaction, stored in trx_locks */
 	UT_LIST_NODE_T(trx_t)
 			trx_list;	/* list of transactions */
 	UT_LIST_NODE_T(trx_t)

innobase/include/univ.i

@@ -181,7 +181,7 @@ management to ensure correct alignment for doubles etc. */
 /* Another basic type we use is unsigned long integer which should be equal to
 the word size of the machine, that is on a 32-bit platform 32 bits, and on a
 64-bit platform 64 bits. We also give the printf format for the type as a
-macro PRULINT. */
+macro ULINTPF. */
 
 #ifdef _WIN64
 typedef unsigned __int64	ulint;
@@ -243,6 +243,30 @@ contains the sum of the following flag and the locally stored len. */
 
 #define UNIV_EXTERN_STORAGE_FIELD (UNIV_SQL_NULL - UNIV_PAGE_SIZE)
 
+/* Some macros to improve branch prediction and reduce cache misses */
+#if defined(__GNUC__) && (__GNUC__ > 2)
+/* Tell the compiler that 'expr' probably evaluates to 'constant'. */
+# define UNIV_EXPECT(expr,constant) __builtin_expect(expr, constant)
+/* Tell the compiler that a pointer is likely to be NULL */
+# define UNIV_LIKELY_NULL(ptr) __builtin_expect((ulint) ptr, 0)
+/* Minimize cache-miss latency by moving data at addr into a cache before
+it is read. */
+# define UNIV_PREFETCH_R(addr) __builtin_prefetch(addr, 0, 3)
+/* Minimize cache-miss latency by moving data at addr into a cache before
+it is read or written. */
+# define UNIV_PREFETCH_RW(addr) __builtin_prefetch(addr, 1, 3)
+#else
+/* Dummy versions of the macros */
+# define UNIV_EXPECT(expr,value) (expr)
+# define UNIV_LIKELY_NULL(expr) (expr)
+# define UNIV_PREFETCH_R(addr) ((void) 0)
+# define UNIV_PREFETCH_RW(addr) ((void) 0)
+#endif
+/* Tell the compiler that cond is likely to hold */
+#define UNIV_LIKELY(cond) UNIV_EXPECT(cond, TRUE)
+/* Tell the compiler that cond is unlikely to hold */
+#define UNIV_UNLIKELY(cond) UNIV_EXPECT(cond, FALSE)
+
 #include <stdio.h>
 #include "ut0dbg.h"
 #include "ut0ut.h"

innobase/include/ut0dbg.h

@@ -13,74 +13,75 @@ Created 1/30/1994 Heikki Tuuri
 #include <stdlib.h>
 #include "os0thread.h"
 
+#if defined(__GNUC__) && (__GNUC__ > 2)
+# define UT_DBG_FAIL(EXPR) UNIV_UNLIKELY(!((ulint)(EXPR)))
+#else
 extern ulint	ut_dbg_zero; /* This is used to eliminate
 				compiler warnings */
+# define UT_DBG_FAIL(EXPR) !((ulint)(EXPR) + ut_dbg_zero)
+#endif
+
+/*****************************************************************
+Report a failed assertion. */
+
+void
+ut_dbg_assertion_failed(
+/*====================*/
+	const char* expr,	/* in: the failed assertion */
+	const char* file,	/* in: source file containing the assertion */
+	ulint line);		/* in: line number of the assertion */
+
+#ifdef __NETWARE__
+/* Flag for ignoring further assertion failures.
+On NetWare, have a graceful exit rather than a segfault to avoid abends. */
+extern ibool	panic_shutdown;
+/* Abort the execution. */
+void ut_dbg_panic(void);
+# define UT_DBG_PANIC ut_dbg_panic()
+/* Stop threads in ut_a(). */
+# define UT_DBG_STOP	while (0)	/* We do not do this on NetWare */
+#else /* __NETWARE__ */
+/* Flag for indicating that all threads should stop.  This will be set
+by ut_dbg_assertion_failed(). */
 extern ibool	ut_dbg_stop_threads;
 
+/* A null pointer that will be dereferenced to trigger a memory trap */
 extern ulint*	ut_dbg_null_ptr;
 
-extern const char*	ut_dbg_msg_assert_fail;
-extern const char*	ut_dbg_msg_trap;
-extern const char*	ut_dbg_msg_stop;
-/* Have a graceful exit on NetWare rather than a segfault to avoid abends */
-#ifdef __NETWARE__
-extern ibool 	panic_shutdown;
-#define ut_a(EXPR) do {\
-	if (!((ulint)(EXPR) + ut_dbg_zero)) {\
-                ut_print_timestamp(stderr);\
-	   	fprintf(stderr, ut_dbg_msg_assert_fail,\
-		os_thread_pf(os_thread_get_curr_id()), __FILE__,\
-                (ulint)__LINE__);\
-		fputs("InnoDB: Failing assertion: " #EXPR "\n", stderr);\
-		fputs(ut_dbg_msg_trap, stderr);\
-		ut_dbg_stop_threads = TRUE;\
-		if (ut_dbg_stop_threads) {\
-        		fprintf(stderr, ut_dbg_msg_stop,\
-	    os_thread_pf(os_thread_get_curr_id()), __FILE__, (ulint)__LINE__);\
-	    	}\
-		if(!panic_shutdown){\
-		panic_shutdown = TRUE;\
-		innobase_shutdown_for_mysql();}\
-		exit(1);\
-		}\
-} while (0)
-#define ut_error do {\
-		ut_print_timestamp(stderr);\
-		fprintf(stderr, ut_dbg_msg_assert_fail,\
-		os_thread_pf(os_thread_get_curr_id()), __FILE__, (ulint)__LINE__);\
-		fprintf(stderr, ut_dbg_msg_trap);\
-		ut_dbg_stop_threads = TRUE;\
-		if(!panic_shutdown){panic_shutdown = TRUE;\
-		innobase_shutdown_for_mysql();}\
-} while (0)
-#else
-#define ut_a(EXPR) do {\
-	if (!((ulint)(EXPR) + ut_dbg_zero)) {\
-                ut_print_timestamp(stderr);\
-	   	fprintf(stderr, ut_dbg_msg_assert_fail,\
-		os_thread_pf(os_thread_get_curr_id()), __FILE__,\
-                (ulint)__LINE__);\
-		fputs("InnoDB: Failing assertion: " #EXPR "\n", stderr);\
-		fputs(ut_dbg_msg_trap, stderr);\
-		ut_dbg_stop_threads = TRUE;\
-		if (*(ut_dbg_null_ptr)) ut_dbg_null_ptr = NULL;\
-	}\
-	if (ut_dbg_stop_threads) {\
-	        fprintf(stderr, ut_dbg_msg_stop,\
-     os_thread_pf(os_thread_get_curr_id()), __FILE__, (ulint)__LINE__);\
-		os_thread_sleep(1000000000);\
-	}\
+/*****************************************************************
+Stop a thread after assertion failure. */
+
+void
+ut_dbg_stop_thread(
+/*===============*/
+	const char*	file,
+	ulint		line);
+
+/* Abort the execution. */
+# define UT_DBG_PANIC					\
+	if (*(ut_dbg_null_ptr)) ut_dbg_null_ptr = NULL
+/* Stop threads in ut_a(). */
+# define UT_DBG_STOP do						\
+	if (UNIV_UNLIKELY(ut_dbg_stop_threads)) {		\
+		ut_dbg_stop_thread(__FILE__, (ulint) __LINE__);	\
+	} while (0)
+#endif /* __NETWARE__ */
+
+/* Abort execution if EXPR does not evaluate to nonzero. */
+#define ut_a(EXPR) do {						\
+	if (UT_DBG_FAIL(EXPR)) {				\
+		ut_dbg_assertion_failed(#EXPR,			\
+				__FILE__, (ulint) __LINE__);	\
+		UT_DBG_PANIC;					\
+	}							\
+	UT_DBG_STOP; 						\
 } while (0)
 
-#define ut_error do {\
-        ut_print_timestamp(stderr);\
-	fprintf(stderr, ut_dbg_msg_assert_fail,\
-	os_thread_pf(os_thread_get_curr_id()), __FILE__, (ulint)__LINE__);\
-	fprintf(stderr, ut_dbg_msg_trap);\
-	ut_dbg_stop_threads = TRUE;\
-	if (*(ut_dbg_null_ptr)) ut_dbg_null_ptr = NULL;\
+/* Abort execution. */
+#define ut_error do {						\
+	ut_dbg_assertion_failed(0, __FILE__, (ulint) __LINE__);	\
+	UT_DBG_PANIC;						\
 } while (0)
-#endif
 
 #ifdef UNIV_DEBUG
 #define ut_ad(EXPR)  	ut_a(EXPR)

innobase/include/ut0rnd.ic

@@ -207,12 +207,12 @@ ut_fold_binary(
 	const byte*	str,	/* in: string of bytes */
 	ulint		len)	/* in: length */
 {
-	ulint	i;
-	ulint	fold = 0;
+	const byte*	str_end	= str + len;
+	ulint		fold = 0;
 
 	ut_ad(str);
 
-	for (i = 0; i < len; i++) {
+	while (str < str_end) {
 		fold = ut_fold_ulint_pair(fold, (ulint)(*str));
 
 		str++;

innobase/log/log0log.c

@@ -57,10 +57,11 @@ ulint	log_fsp_current_free_limit		= 0;
 /* Global log system variable */
 log_t*	log_sys	= NULL;
 
+#ifdef UNIV_DEBUG
 ibool	log_do_write = TRUE;
 
 ibool	log_debug_writes = FALSE;
-
+#endif /* UNIV_DEBUG */
 
 /* These control how often we print warnings if the last checkpoint is too
 old */
@@ -974,22 +975,24 @@ log_group_check_flush_completion(
 #endif /* UNIV_SYNC_DEBUG */
 
 	if (!log_sys->one_flushed && group->n_pending_writes == 0) {
+#ifdef UNIV_DEBUG
 		if (log_debug_writes) {
 			fprintf(stderr,
 				"Log flushed first to group %lu\n", (ulong) group->id);
 		}
-	
+#endif /* UNIV_DEBUG */
 		log_sys->written_to_some_lsn = log_sys->write_lsn;
 		log_sys->one_flushed = TRUE;
 
 		return(LOG_UNLOCK_NONE_FLUSHED_LOCK);
 	}
 
+#ifdef UNIV_DEBUG
 	if (log_debug_writes && (group->n_pending_writes == 0)) {
 
 		fprintf(stderr, "Log flushed to group %lu\n", (ulong) group->id);
 	}
-
+#endif /* UNIV_DEBUG */
 	return(0);
 }
 
@@ -1066,12 +1069,13 @@ log_io_complete(
 		        fil_flush(group->space_id);
 		}
 
+#ifdef UNIV_DEBUG
 		if (log_debug_writes) {
 			fprintf(stderr,
 				"Checkpoint info written to group %lu\n",
 				group->id);
 		}
-
+#endif /* UNIV_DEBUG */
 		log_io_complete_checkpoint();
 
 		return;
@@ -1133,12 +1137,13 @@ log_group_file_header_flush(
 
 	dest_offset = nth_file * group->file_size;
 
+#ifdef UNIV_DEBUG
 	if (log_debug_writes) {
 		fprintf(stderr,
 			"Writing log file header to group %lu file %lu\n",
 			(ulong) group->id, (ulong) nth_file);
 	}
-
+#endif /* UNIV_DEBUG */
 	if (log_do_write) {
 		log_sys->n_log_ios++;	
 		
@@ -1226,7 +1231,8 @@ loop:
 	} else {
 		write_len = len;
 	}
-	
+
+#ifdef UNIV_DEBUG
 	if (log_debug_writes) {
 
 		fprintf(stderr,
@@ -1250,7 +1256,7 @@ loop:
 					+ i * OS_FILE_LOG_BLOCK_SIZE));
 		}
 	}
-
+#endif /* UNIV_DEBUG */
 	/* Calculate the checksums for each log block and write them to
 	the trailer fields of the log blocks */
 
@@ -1384,6 +1390,7 @@ loop:
 		return;
 	}
 
+#ifdef UNIV_DEBUG
 	if (log_debug_writes) {
 		fprintf(stderr,
 			"Writing log from %lu %lu up to lsn %lu %lu\n",
@@ -1392,7 +1399,7 @@ loop:
 			(ulong) ut_dulint_get_high(log_sys->lsn),
 			(ulong)	ut_dulint_get_low(log_sys->lsn));
 	}
-
+#endif /* UNIV_DEBUG */
 	log_sys->n_pending_writes++;
 
 	group = UT_LIST_GET_FIRST(log_sys->log_groups);
@@ -1961,12 +1968,14 @@ log_checkpoint(
 
 	log_sys->next_checkpoint_lsn = oldest_lsn;
 
+#ifdef UNIV_DEBUG
 	if (log_debug_writes) {
 		fprintf(stderr, "Making checkpoint no %lu at lsn %lu %lu\n",
 			(ulong) ut_dulint_get_low(log_sys->next_checkpoint_no),
 			(ulong) ut_dulint_get_high(oldest_lsn),
 			(ulong) ut_dulint_get_low(oldest_lsn));
 	}
+#endif /* UNIV_DEBUG */
 
 	log_groups_write_checkpoint_info();
 
@@ -2029,8 +2038,6 @@ log_checkpoint_margin(void)
 	ulint	checkpoint_age;
 	ulint	advance;
 	dulint	oldest_lsn;
-	dulint	new_oldest;
-	ibool	do_preflush;
 	ibool	sync;
 	ibool	checkpoint_sync;
 	ibool	do_checkpoint;
@@ -2038,7 +2045,6 @@ log_checkpoint_margin(void)
 loop:
 	sync = FALSE;
 	checkpoint_sync = FALSE;
-	do_preflush = FALSE;
 	do_checkpoint = FALSE;
 
 	mutex_enter(&(log->mutex));
@@ -2058,21 +2064,13 @@ loop:
 		/* A flush is urgent: we have to do a synchronous preflush */
 
 		sync = TRUE;
-	
-		advance = 2 * (age - log->max_modified_age_sync);
-
-		new_oldest = ut_dulint_add(oldest_lsn, advance);
-
-		do_preflush = TRUE;
-
+		advance = 2 * (age - log->max_modified_age_async);
 	} else if (age > log->max_modified_age_async) {
 
 		/* A flush is not urgent: we do an asynchronous preflush */
 		advance = age - log->max_modified_age_async;
-
-		new_oldest = ut_dulint_add(oldest_lsn, advance);
-
-		do_preflush = TRUE;
+	} else {
+		advance = 0;
 	}
 
 	checkpoint_age = ut_dulint_minus(log->lsn, log->last_checkpoint_lsn);
@@ -2096,7 +2094,9 @@ loop:
 	
 	mutex_exit(&(log->mutex));
 
-	if (do_preflush) {
+	if (advance) {
+		dulint	new_oldest = ut_dulint_add(oldest_lsn, advance);
+
 		success = log_preflush_pool_modified_pages(new_oldest, sync);
 
 		/* If the flush succeeded, this thread has done its part
@@ -2347,9 +2347,11 @@ loop:
 			exit(1);
 		}
 
+#ifdef UNIV_DEBUG
 		if (log_debug_writes) {
 			fprintf(stderr, "Created archive file %s\n", name);
 		}
+#endif /* UNIV_DEBUG */
 
 		ret = os_file_close(file_handle);
 	
@@ -2375,7 +2377,8 @@ loop:
 
 		len = group->file_size - (next_offset % group->file_size);
 	}
-	
+
+#ifdef UNIV_DEBUG
 	if (log_debug_writes) {
 		fprintf(stderr,
 		"Archiving starting at lsn %lu %lu, len %lu to group %lu\n",
@@ -2383,6 +2386,7 @@ loop:
 					(ulong) ut_dulint_get_low(start_lsn),
 					(ulong) len, (ulong) group->id);
 	}
+#endif /* UNIV_DEBUG */
 
 	log_sys->n_pending_archive_ios++;
 
@@ -2473,11 +2477,13 @@ log_archive_write_complete_groups(void)
 		trunc_files = n_files - 1;
 	}
 
+#ifdef UNIV_DEBUG
 	if (log_debug_writes && trunc_files) {
 		fprintf(stderr,
 			"Complete file(s) archived to group %lu\n",
 							  (ulong) group->id);
 	}
+#endif /* UNIV_DEBUG */
 
 	/* Calculate the archive file space start lsn */
 	start_lsn = ut_dulint_subtract(log_sys->next_archived_lsn,
@@ -2500,9 +2506,11 @@ log_archive_write_complete_groups(void)
 	fil_space_truncate_start(group->archive_space_id,
 					trunc_files * group->file_size);
 
+#ifdef UNIV_DEBUG
 	if (log_debug_writes) {
 		fputs("Archiving writes completed\n", stderr);
 	}
+#endif /* UNIV_DEBUG */
 }
 
 /**********************************************************
@@ -2519,9 +2527,11 @@ log_archive_check_completion_low(void)
 	if (log_sys->n_pending_archive_ios == 0
 			&& log_sys->archiving_phase == LOG_ARCHIVE_READ) {
 
+#ifdef UNIV_DEBUG
 		if (log_debug_writes) {
 			fputs("Archiving read completed\n", stderr);
 		}
+#endif /* UNIV_DEBUG */
 
 	    	/* Archive buffer has now been read in: start archive writes */
 
@@ -2665,6 +2675,7 @@ loop:
 
 	log_sys->next_archived_lsn = limit_lsn;
 
+#ifdef UNIV_DEBUG
 	if (log_debug_writes) {
 		fprintf(stderr,
 			"Archiving from lsn %lu %lu to lsn %lu %lu\n",
@@ -2673,6 +2684,7 @@ loop:
 			(ulong) ut_dulint_get_high(limit_lsn),
 			(ulong) ut_dulint_get_low(limit_lsn));
 	}
+#endif /* UNIV_DEBUG */
 
 	/* Read the log segment to the archive buffer */
 	
@@ -2775,12 +2787,14 @@ log_archive_close_groups(
 			group->archived_file_no += 2;
 		}
 
+#ifdef UNIV_DEBUG
 		if (log_debug_writes) {
 			fprintf(stderr,
 			"Incrementing arch file no to %lu in log group %lu\n",
 				(ulong) group->archived_file_no + 2,
 			        (ulong) group->id);
 		}
+#endif /* UNIV_DEBUG */
 	}
 }
 

innobase/log/log0recv.c

@@ -489,6 +489,7 @@ recv_find_max_checkpoint(
 			log_group_read_checkpoint_info(group, field);
 
 			if (!recv_check_cp_is_consistent(buf)) {
+#ifdef UNIV_DEBUG
 				if (log_debug_writes) {
 					fprintf(stderr, 
 	    "InnoDB: Checkpoint in group %lu at %lu invalid, %lu\n",
@@ -498,7 +499,7 @@ recv_find_max_checkpoint(
 					      + LOG_CHECKPOINT_CHECKSUM_1));
 
 				}
-
+#endif /* UNIV_DEBUG */
 				goto not_consistent;
 			}
 
@@ -511,13 +512,15 @@ recv_find_max_checkpoint(
 			checkpoint_no =
 				mach_read_from_8(buf + LOG_CHECKPOINT_NO);
 
+#ifdef UNIV_DEBUG
 			if (log_debug_writes) {
 				fprintf(stderr, 
 			"InnoDB: Checkpoint number %lu found in group %lu\n",
 				(ulong) ut_dulint_get_low(checkpoint_no),
 				(ulong) group->id);
 			}
-				
+#endif /* UNIV_DEBUG */
+
 			if (ut_dulint_cmp(checkpoint_no, max_no) >= 0) {
 				*max_group = group;
 				*max_field = field;
@@ -540,7 +543,7 @@ recv_find_max_checkpoint(
 "InnoDB: to create the InnoDB data files, but log file creation failed.\n"
 "InnoDB: If that is the case, please refer to\n"
 "InnoDB: http://dev.mysql.com/doc/mysql/en/Error_creating_InnoDB.html\n");
-
+		*max_field = 0;
 		return(DB_ERROR);
 	}
 
@@ -765,6 +768,7 @@ recv_parse_or_apply_log_rec_body(
 	case MLOG_REC_INSERT: case MLOG_COMP_REC_INSERT:
 		if (NULL != (ptr = mlog_parse_index(ptr, end_ptr,
 				type == MLOG_COMP_REC_INSERT, &index))) {
+			ut_a(!page||!!page_is_comp(page)==index->table->comp);
 			ptr = page_cur_parse_insert_rec(FALSE, ptr, end_ptr,
 							index, page, mtr);
 		}
@@ -772,20 +776,27 @@ recv_parse_or_apply_log_rec_body(
 	case MLOG_REC_CLUST_DELETE_MARK: case MLOG_COMP_REC_CLUST_DELETE_MARK:
 		if (NULL != (ptr = mlog_parse_index(ptr, end_ptr,
 			type == MLOG_COMP_REC_CLUST_DELETE_MARK, &index))) {
+			ut_a(!page||!!page_is_comp(page)==index->table->comp);
 			ptr = btr_cur_parse_del_mark_set_clust_rec(ptr,
 						end_ptr, index, page);
 		}
 		break;
-	case MLOG_REC_SEC_DELETE_MARK: case MLOG_COMP_REC_SEC_DELETE_MARK:
-		if (NULL != (ptr = mlog_parse_index(ptr, end_ptr,
-			type == MLOG_COMP_REC_SEC_DELETE_MARK, &index))) {
-			ptr = btr_cur_parse_del_mark_set_sec_rec(ptr, end_ptr,
-								index, page);
+	case MLOG_COMP_REC_SEC_DELETE_MARK:
+		/* This log record type is obsolete, but we process it for
+		backward compatibility with MySQL 5.0.3 and 5.0.4. */
+		ut_a(!page || page_is_comp(page));
+		ptr = mlog_parse_index(ptr, end_ptr, TRUE, &index);
+		if (!ptr) {
+			break;
 		}
+		/* Fall through */
+	case MLOG_REC_SEC_DELETE_MARK:
+		ptr = btr_cur_parse_del_mark_set_sec_rec(ptr, end_ptr, page);
 		break;
 	case MLOG_REC_UPDATE_IN_PLACE: case MLOG_COMP_REC_UPDATE_IN_PLACE:
 		if (NULL != (ptr = mlog_parse_index(ptr, end_ptr,
 			type == MLOG_COMP_REC_UPDATE_IN_PLACE, &index))) {
+			ut_a(!page||!!page_is_comp(page)==index->table->comp);
 			ptr = btr_cur_parse_update_in_place(ptr, end_ptr,
 							page, index);
 		}
@@ -795,6 +806,7 @@ recv_parse_or_apply_log_rec_body(
 		if (NULL != (ptr = mlog_parse_index(ptr, end_ptr,
 			type == MLOG_COMP_LIST_END_DELETE
 			|| type == MLOG_COMP_LIST_START_DELETE, &index))) {
+			ut_a(!page||!!page_is_comp(page)==index->table->comp);
 			ptr = page_parse_delete_rec_list(type, ptr, end_ptr,
 							index, page, mtr);
 		}
@@ -802,6 +814,7 @@ recv_parse_or_apply_log_rec_body(
 	case MLOG_LIST_END_COPY_CREATED: case MLOG_COMP_LIST_END_COPY_CREATED:
 		if (NULL != (ptr = mlog_parse_index(ptr, end_ptr,
 			type == MLOG_COMP_LIST_END_COPY_CREATED, &index))) {
+			ut_a(!page||!!page_is_comp(page)==index->table->comp);
 			ptr = page_parse_copy_rec_list_to_created_page(ptr,
 						end_ptr, index, page, mtr);
 		}
@@ -809,6 +822,7 @@ recv_parse_or_apply_log_rec_body(
 	case MLOG_PAGE_REORGANIZE: case MLOG_COMP_PAGE_REORGANIZE:
 		if (NULL != (ptr = mlog_parse_index(ptr, end_ptr,
 				type == MLOG_COMP_PAGE_REORGANIZE, &index))) {
+			ut_a(!page||!!page_is_comp(page)==index->table->comp);
 			ptr = btr_parse_page_reorganize(ptr, end_ptr, index,
 								page, mtr);
 		}
@@ -841,6 +855,7 @@ recv_parse_or_apply_log_rec_body(
 	case MLOG_REC_DELETE: case MLOG_COMP_REC_DELETE:
 		if (NULL != (ptr = mlog_parse_index(ptr, end_ptr,
 				type == MLOG_COMP_REC_DELETE, &index))) {
+			ut_a(!page||!!page_is_comp(page)==index->table->comp);
 			ptr = page_cur_parse_delete_rec(ptr, end_ptr,
 							index, page, mtr);
 		}
@@ -1186,6 +1201,7 @@ recv_recover_page(
 				start_lsn = recv->start_lsn;
 			}
 
+#ifdef UNIV_DEBUG
 			if (log_debug_writes) {
 				fprintf(stderr, 
      "InnoDB: Applying log rec type %lu len %lu to space %lu page no %lu\n",
@@ -1193,6 +1209,7 @@ recv_recover_page(
 					(ulong) recv_addr->space,
 					(ulong) recv_addr->page_no);
 			}
+#endif /* UNIV_DEBUG */
 
 			recv_parse_or_apply_log_rec_body(recv->type, buf,
 						buf + recv->len, page, &mtr);
@@ -1801,25 +1818,25 @@ recv_parse_log_rec(
 
 	new_ptr = mlog_parse_initial_log_record(ptr, end_ptr, type, space,
 								page_no);
-	if (!new_ptr) {
+	*body = new_ptr;
+
+	if (UNIV_UNLIKELY(!new_ptr)) {
 
 	        return(0);
 	}
 
 	/* Check that page_no is sensible */
 
-	if (*page_no > 0x8FFFFFFFUL) {
+	if (UNIV_UNLIKELY(*page_no > 0x8FFFFFFFUL)) {
 
 		recv_sys->found_corrupt_log = TRUE;
 
 		return(0);
 	}
 
-	*body = new_ptr;
-
 	new_ptr = recv_parse_or_apply_log_rec_body(*type, new_ptr, end_ptr,
 								NULL, NULL);
-	if (new_ptr == NULL) {
+	if (UNIV_UNLIKELY(new_ptr == NULL)) {
 
 		return(0);
 	}
@@ -2013,12 +2030,14 @@ loop:
 		recv_sys->recovered_offset += len;
 		recv_sys->recovered_lsn = new_recovered_lsn;
 
+#ifdef UNIV_DEBUG
 		if (log_debug_writes) {
 			fprintf(stderr, 
 "InnoDB: Parsed a single log rec type %lu len %lu space %lu page no %lu\n",
 				(ulong) type, (ulong) len, (ulong) space,
 				(ulong) page_no);
 		}
+#endif /* UNIV_DEBUG */
 
 		if (type == MLOG_DUMMY_RECORD) {
 			/* Do nothing */
@@ -2101,13 +2120,15 @@ loop:
 							body, ptr + len);
 #endif /* UNIV_LOG_REPLICATE */
 			}
-			
+
+#ifdef UNIV_DEBUG
 			if (log_debug_writes) {
 				fprintf(stderr, 
 "InnoDB: Parsed a multi log rec type %lu len %lu space %lu page no %lu\n",
 				(ulong) type, (ulong) len, (ulong) space,
 				(ulong) page_no);
 			}
+#endif /* UNIV_DEBUG */
 
 			total_len += len;
 			n_recs++;
@@ -2514,6 +2535,7 @@ recv_group_scan_log_recs(
 		start_lsn = end_lsn;
 	}
 
+#ifdef UNIV_DEBUG
 	if (log_debug_writes) {
 		fprintf(stderr,
 	"InnoDB: Scanned group %lu up to log sequence number %lu %lu\n",
@@ -2521,6 +2543,7 @@ recv_group_scan_log_recs(
 				(ulong) ut_dulint_get_high(*group_scanned_lsn),
 				(ulong) ut_dulint_get_low(*group_scanned_lsn));
 	}
+#endif /* UNIV_DEBUG */
 }
 
 /************************************************************
@@ -2906,10 +2929,12 @@ recv_recovery_from_checkpoint_finish(void)
 		recv_apply_hashed_log_recs(TRUE);
 	}
 
+#ifdef UNIV_DEBUG
 	if (log_debug_writes) {
 		fprintf(stderr,
 		"InnoDB: Log records applied to the database\n");
 	}
+#endif /* UNIV_DEBUG */
 
 	if (recv_needed_recovery) {
 		trx_sys_print_mysql_master_log_pos();
@@ -3246,6 +3271,7 @@ ask_again:
 			break;
 		}
 	
+#ifdef UNIV_DEBUG
 		if (log_debug_writes) {
 			fprintf(stderr, 
 "InnoDB: Archive read starting at lsn %lu %lu, len %lu from file %s\n",
@@ -3253,6 +3279,7 @@ ask_again:
 					(ulong) ut_dulint_get_low(start_lsn),
 					(ulong) len, name);
 		}
+#endif /* UNIV_DEBUG */
 
 		fil_io(OS_FILE_READ | OS_FILE_LOG, TRUE,
 			group->archive_space_id, read_offset / UNIV_PAGE_SIZE,

innobase/mtr/mtr0log.c

@@ -15,6 +15,7 @@ Created 12/7/1995 Heikki Tuuri
 #include "buf0buf.h"
 #include "dict0boot.h"
 #include "log0recv.h"
+#include "page0page.h"
 
 /************************************************************
 Catenates n bytes to the mtr log. */
@@ -22,9 +23,9 @@ Catenates n bytes to the mtr log. */
 void
 mlog_catenate_string(
 /*=================*/
-	mtr_t*	mtr,	/* in: mtr */
-	byte*	str,	/* in: string to write */
-	ulint	len)	/* in: string length */
+	mtr_t*		mtr,	/* in: mtr */
+	const byte*	str,	/* in: string to write */
+	ulint		len)	/* in: string length */
 {
 	dyn_array_t*	mlog;
 
@@ -301,14 +302,15 @@ corresponding log record to the mini-transaction log. */
 void
 mlog_write_string(
 /*==============*/
-	byte*	ptr,	/* in: pointer where to write */
-	byte*	str,	/* in: string to write */
-	ulint	len,	/* in: string length */
-	mtr_t*	mtr)	/* in: mini-transaction handle */
+	byte*		ptr,	/* in: pointer where to write */
+	const byte*	str,	/* in: string to write */
+	ulint		len,	/* in: string length */
+	mtr_t*		mtr)	/* in: mini-transaction handle */
 {
 	byte*	log_ptr;
 
-	if (ptr < buf_pool->frame_zero || ptr >= buf_pool->high_end) {
+	if (UNIV_UNLIKELY(ptr < buf_pool->frame_zero)
+	    || UNIV_UNLIKELY(ptr >= buf_pool->high_end)) {
 		fprintf(stderr,
 	"InnoDB: Error: trying to write to a stray memory location %p\n", ptr);
 		ut_error;
@@ -405,7 +407,9 @@ mlog_open_and_write_index(
 	const byte*	log_start;
 	const byte*	log_end;
 
-	if (!index->table->comp) {
+	ut_ad(!!page_rec_is_comp(rec) == index->table->comp);
+
+	if (!page_rec_is_comp(rec)) {
 		log_start = log_ptr = mlog_open(mtr, 11 + size);
 		if (!log_ptr) {
 			return(NULL); /* logging is disabled */
@@ -498,6 +502,8 @@ mlog_parse_index(
 	dict_table_t*	table;
 	dict_index_t*	ind;
 
+	ut_ad(comp == FALSE || comp == TRUE);
+
 	if (comp) {
 		if (end_ptr < ptr + 4) {
 			return(NULL);

innobase/mtr/mtr0mtr.c

@@ -48,16 +48,11 @@ mtr_memo_slot_release(
 	object = slot->object;
 	type = slot->type;
 
-	if (object != NULL) {
+	if (UNIV_LIKELY(object != NULL)) {
 		if (type <= MTR_MEMO_BUF_FIX) {
 			buf_page_release((buf_block_t*)object, type, mtr);
 		} else if (type == MTR_MEMO_S_LOCK) {
 			rw_lock_s_unlock((rw_lock_t*)object);
-#ifndef UNIV_DEBUG
-		} else {
-			rw_lock_x_unlock((rw_lock_t*)object);
-		}
-#endif
 #ifdef UNIV_DEBUG
 		} else if (type == MTR_MEMO_X_LOCK) {
 			rw_lock_x_unlock((rw_lock_t*)object);
@@ -65,8 +60,11 @@ mtr_memo_slot_release(
 			ut_ad(type == MTR_MEMO_MODIFY);
 			ut_ad(mtr_memo_contains(mtr, object,
 						MTR_MEMO_PAGE_X_FIX));
-		}
+#else
+		} else {
+			rw_lock_x_unlock((rw_lock_t*)object);
 #endif
+		}
 	}
 
 	slot->object = NULL;

innobase/os/os0file.c

@@ -83,7 +83,7 @@ struct os_aio_slot_struct{
 					made and only the slot message
 					needs to be passed to the caller
 					of os_aio_simulated_handle */
-	void*		message1;	/* message which is given by the */
+	fil_node_t*	message1;	/* message which is given by the */
 	void*		message2;	/* the requester of an aio operation
 					and which can be used to identify
 					which pending aio operation was
@@ -133,17 +133,17 @@ os_event_t*	os_aio_segment_wait_events	= NULL;
 
 /* The aio arrays for non-ibuf i/o and ibuf i/o, as well as sync aio. These
 are NULL when the module has not yet been initialized. */
-os_aio_array_t*	os_aio_read_array	= NULL;
-os_aio_array_t*	os_aio_write_array	= NULL;
-os_aio_array_t*	os_aio_ibuf_array	= NULL;
-os_aio_array_t*	os_aio_log_array	= NULL;
-os_aio_array_t*	os_aio_sync_array	= NULL;
+static os_aio_array_t*	os_aio_read_array	= NULL;
+static os_aio_array_t*	os_aio_write_array	= NULL;
+static os_aio_array_t*	os_aio_ibuf_array	= NULL;
+static os_aio_array_t*	os_aio_log_array	= NULL;
+static os_aio_array_t*	os_aio_sync_array	= NULL;
 
-ulint	os_aio_n_segments	= ULINT_UNDEFINED;
+static ulint	os_aio_n_segments	= ULINT_UNDEFINED;
 
 /* If the following is TRUE, read i/o handler threads try to
 wait until a batch of new read requests have been posted */
-ibool	os_aio_recommend_sleep_for_read_threads	= FALSE;
+static ibool	os_aio_recommend_sleep_for_read_threads	= FALSE;
 
 ulint	os_n_file_reads		= 0;
 ulint	os_bytes_read_since_printout = 0;
@@ -158,7 +158,7 @@ ibool	os_has_said_disk_full	= FALSE;
 
 /* The mutex protecting the following counts of pending pread and pwrite
 operations */
-os_mutex_t os_file_count_mutex;
+static os_mutex_t os_file_count_mutex;
 ulint	os_file_n_pending_preads  = 0;
 ulint	os_file_n_pending_pwrites = 0;
 
@@ -3025,7 +3025,7 @@ os_aio_array_reserve_slot(
 				/* out: pointer to slot */
 	ulint		type,	/* in: OS_FILE_READ or OS_FILE_WRITE */
 	os_aio_array_t*	array,	/* in: aio array */
-	void*		message1,/* in: message to be passed along with
+	fil_node_t*	message1,/* in: message to be passed along with
 				the aio operation */
 	void*		message2,/* in: message to be passed along with
 				the aio operation */
@@ -3287,7 +3287,7 @@ os_aio(
 	ulint		offset_high, /* in: most significant 32 bits of
 				offset */
 	ulint		n,	/* in: number of bytes to read or write */
-	void*		message1,/* in: messages for the aio handler (these
+	fil_node_t*	message1,/* in: messages for the aio handler (these
 				can be used to identify a completed aio
 				operation); if mode is OS_AIO_SYNC, these
 				are ignored */
@@ -3472,7 +3472,7 @@ os_aio_windows_handle(
 				ignored */
 	ulint	pos,		/* this parameter is used only in sync aio:
 				wait for the aio slot at this position */  
-	void**	message1,	/* out: the messages passed with the aio
+	fil_node_t**message1,	/* out: the messages passed with the aio
 				request; note that also in the case where
 				the aio operation failed, these output
 				parameters are valid and can be used to
@@ -3563,7 +3563,7 @@ os_aio_posix_handle(
 /*================*/
 				/* out: TRUE if the aio operation succeeded */
 	ulint	array_no,	/* in: array number 0 - 3 */
-	void**	message1,	/* out: the messages passed with the aio
+	fil_node_t**message1,	/* out: the messages passed with the aio
 				request; note that also in the case where
 				the aio operation failed, these output
 				parameters are valid and can be used to
@@ -3644,7 +3644,7 @@ os_aio_simulated_handle(
 				i/o thread, segment 1 the log i/o thread,
 				then follow the non-ibuf read threads, and as
 				the last are the non-ibuf write threads */
-	void**	message1,	/* out: the messages passed with the aio
+	fil_node_t**message1,	/* out: the messages passed with the aio
 				request; note that also in the case where
 				the aio operation failed, these output
 				parameters are valid and can be used to
@@ -4182,6 +4182,7 @@ os_aio_refresh_stats(void)
 	os_last_printout = time(NULL);
 }
 
+#ifdef UNIV_DEBUG
 /**************************************************************************
 Checks that all slots in the system have been freed, that is, there are
 no pending io operations. */
@@ -4241,3 +4242,4 @@ os_aio_all_slots_free(void)
 
 	return(FALSE);
 }
+#endif /* UNIV_DEBUG */

innobase/row/row0purge.c

@@ -126,7 +126,7 @@ row_purge_remove_clust_if_poss_low(
 	if (0 != ut_dulint_cmp(node->roll_ptr,
 		row_get_rec_roll_ptr(rec, index, rec_get_offsets(
 			rec, index, offsets_, ULINT_UNDEFINED, &heap)))) {
-		if (heap) {
+		if (UNIV_LIKELY_NULL(heap)) {
 			mem_heap_free(heap);
 		}
 		/* Someone else has modified the record later: do not remove */
@@ -135,7 +135,7 @@ row_purge_remove_clust_if_poss_low(
 		return(TRUE);
 	}
 
-	if (heap) {
+	if (UNIV_LIKELY_NULL(heap)) {
 		mem_heap_free(heap);
 	}
 

innobase/row/row0undo.c

@@ -190,7 +190,7 @@ row_undo_search_clust_to_pcur(
 
 	btr_pcur_commit_specify_mtr(&(node->pcur), &mtr);
 
-	if (heap) {
+	if (UNIV_LIKELY_NULL(heap)) {
 		mem_heap_free(heap);
 	}
 	return(ret);

innobase/srv/srv0start.c

@@ -1040,7 +1040,9 @@ innobase_start_or_create_for_mysql(void)
 
 	srv_start_has_been_called = TRUE;
 
+#ifdef UNIV_DEBUG
 	log_do_write = TRUE;
+#endif /* UNIV_DEBUG */
 /*	yydebug = TRUE; */
 
 	srv_is_being_started = TRUE;
@@ -1554,8 +1556,9 @@ NetWare. */
 
 	os_thread_create(&srv_master_thread, NULL, thread_ids + 1 +
 							SRV_MAX_N_IO_THREADS);
+#ifdef UNIV_DEBUG
 	/* buf_debug_prints = TRUE; */
-
+#endif /* UNIV_DEBUG */
 	sum_of_data_file_sizes = 0;
 	
 	for (i = 0; i < srv_n_data_files; i++) {