Merge lp:~vlad-lesin/percona-server/5.6-logical-readahead into lp:percona-server/5.6

[Vlad Lesin]

Porting logical readahead feature from Facebook branch. The original patches are here:

https://github.com/facebook/mysql-5.6/commit/f9d1a5332eb2c82c028638d3b93b5a3592a69ffa
https://github.com/facebook/mysql-5.6/commit/f8e361952612d00979f7cf744f487e48b15cb5a6
https://github.com/facebook/mysql-5.6/commit/f69a4ea522bce24e4cdcc7696d5fad29587cf87a

The main difference is multiple io's commit is enabled only for logical read-ahead in this branch in comparison with the original implementation where it is enabled by default for all operations. See explanation in commit comments.

Jenkins testing:
http://jenkins.percona.com/view/PS 5.6/job/percona-server-5.6-param/589

[Laurynas Biveinis (laurynas-biveinis)]

This is not a full review, but addressing this bit can happen in parallel with the rest of the review: the MP needs a blueprint, or even several blueprints, corresponding to each commit (the commits IMHO are well-split). The blueprints must be self-contained.

review: Needs Information

[Laurynas Biveinis (laurynas-biveinis)]

Review of commit 576. I think it will be easier if it will have its own MP (probably the other two commits too).

    Code

    - s/ibool/bool/g (in all three commits if applies)
    - I'd add a defensive asserts at os_aio_free that for all arrays,
      count[x] == 0. This would catch any unsubmitted buffered read
      request, and any request buffered on the non-read array.
    - s/ut_malloc+memset(0)/calloc in os_aio_array_create
    - Why does buf_read_recv_pages call
      os_aio_linux_dispatch_read_array_submit? It does not appear to
      submit any buffered requests.
    - fil_extend_space_to_desired_size calling os_aio with
      should_buffer == TRUE is a (benign) typo?
    - The abstraction level for buffered request submitting seems to
      be off. I'd rename os_aio_linux_dispatch_read_array_submit to
      os_aio_submit_buffered_requests and push #ifdef LINUX_NATIVE_AIO
      down to it.
    - buf_read_page_low header comment @return tag: edit to "1 if
      read request is issued or buffered" to clarify that the function
      returns the same for both buffered and immediatelly issued read
      requests.
    - s/read/ready in the buf_read_page_low should_buffer
      comment. (https://github.com/facebook/mysql-5.6/commit/b1b4c7977136d57170f8bf500aaedba740b1c333)
    - Make sure the patch does not break the build with performance
      schema configured out
    - os_aio_linux_dispatch_read_array_submit would need a /*===*/
      comment, os_aio_func should_buffer arg declaration is misaligned
      </pedantic>

    Testcase

    - --disable_warnings/DROP TABLE IF EXISTS/--enable_warnings idiom
      is obsolete and should be removed. (in all three commits if
      applies)
    - innodb_merge_read.test needs --source
      include/have_innodb_16k.inc, as the number of readahead requests
      is likely to differ for other page sizes.
    - innodb_merge_read-master.opt is redundant, as
      --innodb-use-native-aio=1 is the default. The source
      include/have_native_aio.inc check in the testcase itself is
      enough.
    - newline at the end of have_native_aio.inc
    - I'd extend the innodb_merge_read testcase to check that linear
      read ahead read buffering works for compressed tablespaces too
      (there is code if (zip_size) then read(... should_buffer) else
      read(... should_buffer)). That would cause move of the testcase
      to the innodb_zip suite as well.
    - (wishlist) Consider submitting
      https://github.com/webscalesql/webscalesql-5.6/commit/32e49b4d66eaa392d9f06198596db4b16e8b8d04
      for Percona Server so that we exercise AIO with MTR --mem.

review: Needs Fixing

[Laurynas Biveinis (laurynas-biveinis)]

Work on this MP must continue on github.

review: Needs Resubmitting

Unmerged revisions

578. By Vlad Lesin on 2014-04-22

Add mysqldump support for logical read ahead

Summary:
Adds options to mysqldump:
 --lra-size=X
 --lra-sleep=X
 --lra-n-node-recs-before-sleep=X

These just inject SET statements to set these session variables.

The original implementation is here:
https://github.com/facebook/mysql-5.6/commit/f69a4ea522bce24e4cdcc7696d5fad29587cf87a

577. By Vlad Lesin on 2014-04-22

When the session variable innodb_lra_size is set to N, we issue async
read requests for the next M logical pages where the total size of the M
pages on disk is N megabytes. The max allowed value of innodb_lra_size
is is 16384 which corresponds to prefetching 16GB of data. We may choose
to use smaller values in production.

The original implementation can be found here:
https://github.com/facebook/mysql-5.6/commit/f8e361952612d00979f7cf744f487e48b15cb5a6

This implementation does not contain code for flashcahe.

576. By Vlad Lesin on 2014-04-21

Merge aio page read requests

Summary:
Tries to submit multiple aio page read requests together to improve read
performance.

The original code and description can be found here:
https://github.com/facebook/mysql-5.6/commit/f9d1a5332eb2c82c028638d3b93b5a3592a69ffa

The difference between this and the original implementation is that fil_io()
macros invokes _fil_io() function with enabled io's buffering by default in
the original implementation, it can cause the errors connected with waiting
io finishing just after fil_io() invocation.

For example log_archive_do() waits io's finishing on log_sys->archive_lock
mutex, but the mutex is not being unlocked as io's were buffered and
uncommited and io_handler_thread() does not process io's completion in
fil_aio_wait(). Potentially there can be the same errors so io's buffering
is disabled by default and will be enabled only for logical readahead code.

=== modified file 'client/client_priv.h'
--- client/client_priv.h	2014-02-25 17:05:01 +0000
+++ client/client_priv.h	2014-04-23 10:58:56 +0000
@@ -106,7 +106,10 @@
   OPT_INNODB_OPTIMIZE_KEYS,
   OPT_REWRITE_DB,
   OPT_LOCK_FOR_BACKUP,
-  OPT_MAX_CLIENT_OPTION
+  OPT_MAX_CLIENT_OPTION,
+  OPT_LRA_SIZE,
+  OPT_LRA_SLEEP,
+  OPT_LRA_N_NODE_RECS_BEFORE_SLEEP
 };
 
 /**
 
=== modified file 'client/mysqldump.c'
--- client/mysqldump.c	2014-03-03 17:51:33 +0000
+++ client/mysqldump.c	2014-04-23 10:58:56 +0000
@@ -133,6 +133,9 @@
 /* Server supports character_set_results session variable? */
 static my_bool server_supports_switching_charsets= TRUE;
 static ulong opt_compatible_mode= 0;
+static ulong opt_lra_size = 0;
+static ulong opt_lra_sleep = 0;
+static ulong opt_lra_n_node_recs_before_sleep = 0;
 #define MYSQL_OPT_MASTER_DATA_EFFECTIVE_SQL 1
 #define MYSQL_OPT_MASTER_DATA_COMMENTED_SQL 2
 #define MYSQL_OPT_SLAVE_DATA_EFFECTIVE_SQL 1
@@ -567,6 +570,18 @@
    "Default authentication client-side plugin to use.",
    &opt_default_auth, &opt_default_auth, 0,
    GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  {"lra_size", OPT_LRA_SIZE,
+   "Set innodb_lra_size for the session of this dump.",
+   &opt_lra_size, &opt_lra_size, 0,
+   GET_ULONG, REQUIRED_ARG, 0, 0, 16384, 0, 0, 0},
+  {"lra_sleep", OPT_LRA_SLEEP,
+   "Set innodb_lra_sleep for the session of this dump.",
+   &opt_lra_sleep, &opt_lra_sleep, 0,
+   GET_ULONG, REQUIRED_ARG, 0, 0, 1000, 0, 0, 0},
+  {"lra_n_node_recs_before_sleep", OPT_LRA_N_NODE_RECS_BEFORE_SLEEP,
+   "Set innodb_lra_n_node_recs_before_sleep for the session of this dump.",
+   &opt_lra_n_node_recs_before_sleep, &opt_lra_n_node_recs_before_sleep, 0,
+   GET_ULONG, REQUIRED_ARG, 1024, 128, ULONG_MAX, 0, 0, 0},
   {0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
 };
 
@@ -1611,6 +1626,29 @@
     if (mysql_query_with_error_report(mysql, 0, buff))
       DBUG_RETURN(1);
   }
+
+  if (opt_lra_size)
+  {
+    my_snprintf(buff, sizeof(buff), "SET innodb_lra_size=%lu", opt_lra_size);
+    if (mysql_query_with_error_report(mysql, 0, buff))
+      DBUG_RETURN(1); 
+    if (opt_lra_sleep)
+    {
+      my_snprintf(buff, sizeof(buff), "SET innodb_lra_sleep=%lu",
+                  opt_lra_sleep);
+      if (mysql_query_with_error_report(mysql, 0, buff))
+        DBUG_RETURN(1);
+    }
+    if (opt_lra_n_node_recs_before_sleep)
+    {
+      my_snprintf(buff, sizeof(buff),
+                  "SET innodb_lra_n_node_recs_before_sleep=%lu",
+                  opt_lra_n_node_recs_before_sleep);
+      if (mysql_query_with_error_report(mysql, 0, buff))
+        DBUG_RETURN(1);
+    }
+  }
+
   DBUG_RETURN(0);
 } /* connect_to_db */
 
 
=== added file 'mysql-test/include/have_native_aio.inc'
--- mysql-test/include/have_native_aio.inc	1970-01-01 00:00:00 +0000
+++ mysql-test/include/have_native_aio.inc	2014-04-23 10:58:56 +0000
@@ -0,0 +1,6 @@
+--disable_query_log
+if (`select @@global.innodb_use_native_aio != 1`)
+{
+  --skip native AIO is not in use
+}
+--enable_query_log
 \ No newline at end of file
 
=== added file 'mysql-test/suite/innodb/r/innodb_logical_read_ahead.result'
--- mysql-test/suite/innodb/r/innodb_logical_read_ahead.result	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/innodb/r/innodb_logical_read_ahead.result	2014-04-23 10:58:56 +0000
@@ -0,0 +1,47 @@
+DROP TABLE if exists t1;
+CREATE TABLE t1 (a INT NOT NULL PRIMARY KEY AUTO_INCREMENT, b VARCHAR(256)) ENGINE=INNODB;
+INSERT INTO t1 VALUES (0, REPEAT('a',256));
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+show global status like "innodb_buffered_aio_submitted";
+Variable_name	Value
+Innodb_buffered_aio_submitted	0
+show global status like "innodb_logical_read_ahead_misses";
+Variable_name	Value
+Innodb_logical_read_ahead_misses	0
+show global status like "innodb_logical_read_ahead_prefetched";
+Variable_name	Value
+Innodb_logical_read_ahead_prefetched	0
+show global status like "innodb_logical_read_ahead_in_buf_pool";
+Variable_name	Value
+Innodb_logical_read_ahead_in_buf_pool	0
+SET SESSION innodb_lra_size=1024;
+SET SESSION innodb_lra_n_node_recs_before_sleep=128;
+SET SESSION innodb_lra_sleep=100;
+checksum table t1;
+Table	Checksum
+test.t1	2920207201
+show global status like "innodb_logical_read_ahead_misses";
+Variable_name	Value
+Innodb_logical_read_ahead_misses	0
+select variable_value > 1000 from information_schema.global_status where variable_name="innodb_logical_read_ahead_prefetched";
+variable_value > 1000
+1
+select variable_value < 100 from information_schema.global_status where variable_name="innodb_logical_read_ahead_in_buf_pool";
+variable_value < 100
+1
+DROP TABLE t1;
 
=== added file 'mysql-test/suite/innodb/r/innodb_logical_read_ahead_correctness.result'
--- mysql-test/suite/innodb/r/innodb_logical_read_ahead_correctness.result	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/innodb/r/innodb_logical_read_ahead_correctness.result	2014-04-23 10:58:56 +0000
@@ -0,0 +1,88 @@
+DROP TABLE IF EXISTS t1_small;
+DROP TABLE IF EXISTS t1;
+DROP TABLE IF EXISTS t1_lra;
+DROP TABLE IF EXISTS t2_small;
+DROP TABLE IF EXISTS t3_small;
+CREATE TABLE t1_small(a INT NOT NULL PRIMARY KEY AUTO_INCREMENT, b VARCHAR(256)) ENGINE=INNODB;
+SET SESSION innodb_lra_size=1;
+SELECT * FROM t1_small;
+a	b
+SET SESSION innodb_lra_size=0;
+INSERT INTO t1_small(b) VALUES(REPEAT('a',256));
+SET SESSION innodb_lra_size=1;
+SELECT a, LENGTH(b) FROM t1_small;
+a	LENGTH(b)
+1	256
+SET SESSION innodb_lra_size=0;
+DROP TABLE t1_small;
+CREATE TABLE `t2_small` (
+`id1` bigint(20) unsigned NOT NULL DEFAULT '0',
+`time` bigint(20) unsigned NOT NULL DEFAULT '0',
+`id2` bigint(20) unsigned NOT NULL DEFAULT '0',
+`id2_type` int(10) unsigned DEFAULT NULL,
+`data` text,
+`status` tinyint(3) unsigned DEFAULT NULL,
+PRIMARY KEY (`id1`,`time`,`id2`)
+) ENGINE=InnoDB DEFAULT CHARSET=latin1;
+SET SESSION innodb_lra_size=1;
+SELECT * FROM t2_small;
+id1	time	id2	id2_type	data	status
+DROP TABLE t2_small;
+CREATE TABLE `t3_small` (
+`id` bigint(20) NOT NULL,
+`a` text,
+`b` text,
+`c` text,
+`d` text,
+`e` text,
+`f` text,
+`g` text,
+PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=latin1;
+SET SESSION innodb_lra_size=1;
+SELECT * FROM t3_small;
+id	a	b	c	d	e	f	g
+DROP TABLE t3_small;
+CREATE TABLE t1(a INT NOT NULL PRIMARY KEY AUTO_INCREMENT, b VARCHAR(256)) ENGINE=INNODB;
+CREATE TABLE t1_lra(a INT NOT NULL PRIMARY KEY AUTO_INCREMENT, b VARCHAR(256)) ENGINE=INNODB;
+INSERT INTO t1 VALUES (0, REPEAT('a',256));
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1_lra SELECT * FROM t1;
+CHECKSUM TABLE t1;
+Table	Checksum
+test.t1	2793042655
+SET SESSION innodb_lra_size=1;
+SET SESSION innodb_lra_n_node_recs_before_sleep=128;
+SET SESSION innodb_lra_sleep=100;
+CHECKSUM TABLE t1_lra;
+Table	Checksum
+test.t1_lra	2793042655
+DELETE FROM t1 WHERE a >= 5480 AND a < 5520;
+DELETE FROM t1 WHERE a >= 5520 AND a < 5550;
+CHECKSUM TABLE t1;
+Table	Checksum
+test.t1	1005864202
+SET GLOBAL innodb_lra_test=1;
+DELETE FROM t1_lra WHERE a >= 5480 AND a < 5520;
+DELETE FROM t1_lra WHERE a >= 5520 AND a < 5550;
+SET SESSION innodb_lra_size=1;
+SET SESSION innodb_lra_n_node_recs_before_sleep=128;
+SET SESSION innodb_lra_sleep=100;
+CHECKSUM TABLE t1_lra;
+Table	Checksum
+test.t1_lra	1005864202
+DROP TABLE t1;
+DROP TABLE t1_lra;
 
=== added file 'mysql-test/suite/innodb/r/innodb_merge_read.result'
--- mysql-test/suite/innodb/r/innodb_merge_read.result	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/innodb/r/innodb_merge_read.result	2014-04-23 10:58:56 +0000
@@ -0,0 +1,30 @@
+DROP TABLE if exists t1;
+CREATE TABLE t1 (a INT NOT NULL PRIMARY KEY AUTO_INCREMENT, b VARCHAR(256)) ENGINE=INNODB;
+INSERT INTO t1 VALUES (0, REPEAT('a',256));
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+show global status like "innodb_buffered_aio_submitted";
+Variable_name	Value
+Innodb_buffered_aio_submitted	0
+select * from t1;
+select count(*) from t1;
+count(*)
+65536
+show global status like "innodb_buffered_aio_submitted";
+Variable_name	Value
+Innodb_buffered_aio_submitted	2397
+DROP TABLE t1;
 
=== added file 'mysql-test/suite/innodb/t/innodb_logical_read_ahead-master.opt'
--- mysql-test/suite/innodb/t/innodb_logical_read_ahead-master.opt	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/innodb/t/innodb_logical_read_ahead-master.opt	2014-04-23 10:58:56 +0000
@@ -0,0 +1,2 @@
+--innodb_use_native_aio=1
+--force-restart
 
=== added file 'mysql-test/suite/innodb/t/innodb_logical_read_ahead.test'
--- mysql-test/suite/innodb/t/innodb_logical_read_ahead.test	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/innodb/t/innodb_logical_read_ahead.test	2014-04-23 10:58:56 +0000
@@ -0,0 +1,55 @@
+--source include/have_innodb.inc
+--source include/have_native_aio.inc
+
+--disable_warnings
+DROP TABLE if exists t1;
+--enable_warnings
+
+# Create table.
+CREATE TABLE t1 (a INT NOT NULL PRIMARY KEY AUTO_INCREMENT, b VARCHAR(256)) ENGINE=INNODB;
+
+# Populate table.
+INSERT INTO t1 VALUES (0, REPEAT('a',256));
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+
+--source include/restart_mysqld.inc
+
+show global status like "innodb_buffered_aio_submitted";
+show global status like "innodb_logical_read_ahead_misses";
+show global status like "innodb_logical_read_ahead_prefetched";
+show global status like "innodb_logical_read_ahead_in_buf_pool";
+
+# set the logical read ahead large enough to prefetch
+# the entire table.
+SET SESSION innodb_lra_size=1024;
+SET SESSION innodb_lra_n_node_recs_before_sleep=128;
+SET SESSION innodb_lra_sleep=100;
+checksum table t1;
+
+# there should be no misses, all pages must have been
+# prefetched by the logical read ahead.
+show global status like "innodb_logical_read_ahead_misses";
+# the total number of pages prefetched must be close to the number
+# of leaf pages of the table.
+select variable_value > 1000 from information_schema.global_status where variable_name="innodb_logical_read_ahead_prefetched";
+# innodb_logical_read_ahead_in_buf_pool is the number of pages
+# of the table that were already in the buffer pool while doing the scan.
+# This should be small.
+select variable_value < 100 from information_schema.global_status where variable_name="innodb_logical_read_ahead_in_buf_pool";
+
+DROP TABLE t1;
 
=== added file 'mysql-test/suite/innodb/t/innodb_logical_read_ahead_correctness-master.opt'
--- mysql-test/suite/innodb/t/innodb_logical_read_ahead_correctness-master.opt	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/innodb/t/innodb_logical_read_ahead_correctness-master.opt	2014-04-23 10:58:56 +0000
@@ -0,0 +1,2 @@
+--innodb_use_native_aio=1
+--force-restart
 
=== added file 'mysql-test/suite/innodb/t/innodb_logical_read_ahead_correctness.test'
--- mysql-test/suite/innodb/t/innodb_logical_read_ahead_correctness.test	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/innodb/t/innodb_logical_read_ahead_correctness.test	2014-04-23 10:58:56 +0000
@@ -0,0 +1,107 @@
+--source include/have_debug.inc
+--source include/have_innodb.inc
+--source include/have_native_aio.inc
+
+--disable_warnings
+DROP TABLE IF EXISTS t1_small;
+DROP TABLE IF EXISTS t1;
+DROP TABLE IF EXISTS t1_lra;
+DROP TABLE IF EXISTS t2_small;
+DROP TABLE IF EXISTS t3_small;
+--enable_warnings
+
+# The small table is for checking against a bug where the table's only page is the
+# root page. In such a case the function called for getting the parent page caused
+# the server to crash.
+CREATE TABLE t1_small(a INT NOT NULL PRIMARY KEY AUTO_INCREMENT, b VARCHAR(256)) ENGINE=INNODB;
+
+SET SESSION innodb_lra_size=1;
+SELECT * FROM t1_small;
+
+SET SESSION innodb_lra_size=0;
+INSERT INTO t1_small(b) VALUES(REPEAT('a',256));
+SET SESSION innodb_lra_size=1;
+SELECT a, LENGTH(b) FROM t1_small;
+SET SESSION innodb_lra_size=0;
+
+DROP TABLE t1_small;
+
+CREATE TABLE `t2_small` (
+  `id1` bigint(20) unsigned NOT NULL DEFAULT '0',
+  `time` bigint(20) unsigned NOT NULL DEFAULT '0',
+  `id2` bigint(20) unsigned NOT NULL DEFAULT '0',
+  `id2_type` int(10) unsigned DEFAULT NULL,
+  `data` text,
+  `status` tinyint(3) unsigned DEFAULT NULL,
+  PRIMARY KEY (`id1`,`time`,`id2`)
+) ENGINE=InnoDB DEFAULT CHARSET=latin1;
+
+SET SESSION innodb_lra_size=1;
+SELECT * FROM t2_small;
+DROP TABLE t2_small;
+
+CREATE TABLE `t3_small` (
+  `id` bigint(20) NOT NULL,
+  `a` text,
+  `b` text,
+  `c` text,
+  `d` text,
+  `e` text,
+  `f` text,
+  `g` text,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=latin1;
+
+SET SESSION innodb_lra_size=1;
+SELECT * FROM t3_small;
+DROP TABLE t3_small;
+
+CREATE TABLE t1(a INT NOT NULL PRIMARY KEY AUTO_INCREMENT, b VARCHAR(256)) ENGINE=INNODB;
+CREATE TABLE t1_lra(a INT NOT NULL PRIMARY KEY AUTO_INCREMENT, b VARCHAR(256)) ENGINE=INNODB;
+
+# Populate tables.
+INSERT INTO t1 VALUES (0, REPEAT('a',256));
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+INSERT INTO t1(b) SELECT b FROM t1;
+
+INSERT INTO t1_lra SELECT * FROM t1;
+
+--source include/restart_mysqld.inc
+
+CHECKSUM TABLE t1;
+
+SET SESSION innodb_lra_size=1;
+SET SESSION innodb_lra_n_node_recs_before_sleep=128;
+SET SESSION innodb_lra_sleep=100;
+CHECKSUM TABLE t1_lra;
+
+--source include/restart_mysqld.inc
+
+DELETE FROM t1 WHERE a >= 5480 AND a < 5520;
+DELETE FROM t1 WHERE a >= 5520 AND a < 5550;
+
+CHECKSUM TABLE t1;
+
+SET GLOBAL innodb_lra_test=1;
+DELETE FROM t1_lra WHERE a >= 5480 AND a < 5520;
+DELETE FROM t1_lra WHERE a >= 5520 AND a < 5550;
+
+SET SESSION innodb_lra_size=1;
+SET SESSION innodb_lra_n_node_recs_before_sleep=128;
+SET SESSION innodb_lra_sleep=100;
+CHECKSUM TABLE t1_lra;
+
+DROP TABLE t1;
+DROP TABLE t1_lra;
 
=== added file 'mysql-test/suite/innodb/t/innodb_merge_read-master.opt'
--- mysql-test/suite/innodb/t/innodb_merge_read-master.opt	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/innodb/t/innodb_merge_read-master.opt	2014-04-23 10:58:56 +0000
@@ -0,0 +1,1 @@
+--innodb-use-native-aio=1
 
=== added file 'mysql-test/suite/innodb/t/innodb_merge_read.test'
--- mysql-test/suite/innodb/t/innodb_merge_read.test	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/innodb/t/innodb_merge_read.test	2014-04-23 10:58:56 +0000
@@ -0,0 +1,42 @@
+--source include/have_innodb.inc
+--source include/have_native_aio.inc
+
+--disable_warnings
+DROP TABLE if exists t1;
+--enable_warnings
+
+# Create table.
+CREATE TABLE t1 (a INT NOT NULL PRIMARY KEY AUTO_INCREMENT, b VARCHAR(256)) ENGINE=INNODB;
+
+# Populate table.
+INSERT INTO t1 VALUES (0, REPEAT('a',256));
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+INSERT INTO t1 SELECT 0, b FROM t1;
+
+--source include/restart_mysqld.inc
+
+show global status like "innodb_buffered_aio_submitted";
+
+--disable_result_log
+select * from t1;
+--enable_result_log
+
+select count(*) from t1;
+
+show global status like "innodb_buffered_aio_submitted";
+
+DROP TABLE t1;
 
=== added file 'mysql-test/suite/sys_vars/r/innodb_lra_n_node_recs_before_sleep_basic.result'
--- mysql-test/suite/sys_vars/r/innodb_lra_n_node_recs_before_sleep_basic.result	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/sys_vars/r/innodb_lra_n_node_recs_before_sleep_basic.result	2014-04-23 10:58:56 +0000
@@ -0,0 +1,28 @@
+SET GLOBAL innodb_lra_n_node_recs_before_sleep = 128;
+SELECT @@GLOBAL.innodb_lra_n_node_recs_before_sleep;
+@@GLOBAL.innodb_lra_n_node_recs_before_sleep
+128
+SET SESSION innodb_lra_n_node_recs_before_sleep=1000000;
+SELECT @@SESSION.innodb_lra_n_node_recs_before_sleep;
+@@SESSION.innodb_lra_n_node_recs_before_sleep
+1000000
+SET SESSION innodb_lra_n_node_recs_before_sleep=0;
+Warnings:
+Warning	1292	Truncated incorrect innodb_lra_n_node_recs_before_sl value: '0'
+SELECT @@SESSION.innodb_lra_n_node_recs_before_sleep;
+@@SESSION.innodb_lra_n_node_recs_before_sleep
+128
+SET SESSION innodb_lra_n_node_recs_before_sleep=16384;
+SELECT @@SESSION.innodb_lra_n_node_recs_before_sleep;
+@@SESSION.innodb_lra_n_node_recs_before_sleep
+16384
+SET GLOBAL innodb_lra_n_node_recs_before_sleep=-1;
+Warnings:
+Warning	1292	Truncated incorrect innodb_lra_n_node_recs_before_sl value: '-1'
+SELECT @@GLOBAL.innodb_lra_n_node_recs_before_sleep;
+@@GLOBAL.innodb_lra_n_node_recs_before_sleep
+128
+SET GLOBAL innodb_lra_n_node_recs_before_sleep = default;
+SELECT @@GLOBAL.innodb_lra_n_node_recs_before_sleep;
+@@GLOBAL.innodb_lra_n_node_recs_before_sleep
+1024
 
=== added file 'mysql-test/suite/sys_vars/r/innodb_lra_size_basic.result'
--- mysql-test/suite/sys_vars/r/innodb_lra_size_basic.result	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/sys_vars/r/innodb_lra_size_basic.result	2014-04-23 10:58:56 +0000
@@ -0,0 +1,28 @@
+SET GLOBAL innodb_lra_size = 128;
+SELECT @@GLOBAL.innodb_lra_size;
+@@GLOBAL.innodb_lra_size
+128
+SET SESSION innodb_lra_size=1000000;
+Warnings:
+Warning	1292	Truncated incorrect innodb_lra_size value: '1000000'
+SELECT @@SESSION.innodb_lra_size;
+@@SESSION.innodb_lra_size
+16384
+SET SESSION innodb_lra_size=0;
+SELECT @@SESSION.innodb_lra_size;
+@@SESSION.innodb_lra_size
+0
+SET SESSION innodb_lra_size=16384;
+SELECT @@SESSION.innodb_lra_size;
+@@SESSION.innodb_lra_size
+16384
+SET GLOBAL innodb_lra_size=-1;
+Warnings:
+Warning	1292	Truncated incorrect innodb_lra_size value: '-1'
+SELECT @@GLOBAL.innodb_lra_size;
+@@GLOBAL.innodb_lra_size
+0
+SET GLOBAL innodb_lra_size = default;
+SELECT @@GLOBAL.innodb_lra_size;
+@@GLOBAL.innodb_lra_size
+0
 
=== added file 'mysql-test/suite/sys_vars/r/innodb_lra_sleep_basic.result'
--- mysql-test/suite/sys_vars/r/innodb_lra_sleep_basic.result	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/sys_vars/r/innodb_lra_sleep_basic.result	2014-04-23 10:58:56 +0000
@@ -0,0 +1,30 @@
+SET GLOBAL innodb_lra_sleep = 128;
+SELECT @@GLOBAL.innodb_lra_sleep;
+@@GLOBAL.innodb_lra_sleep
+128
+SET SESSION innodb_lra_sleep=1000000;
+Warnings:
+Warning	1292	Truncated incorrect innodb_lra_sleep value: '1000000'
+SELECT @@SESSION.innodb_lra_sleep;
+@@SESSION.innodb_lra_sleep
+1000
+SET SESSION innodb_lra_sleep=0;
+SELECT @@SESSION.innodb_lra_sleep;
+@@SESSION.innodb_lra_sleep
+0
+SET SESSION innodb_lra_sleep=16384;
+Warnings:
+Warning	1292	Truncated incorrect innodb_lra_sleep value: '16384'
+SELECT @@SESSION.innodb_lra_sleep;
+@@SESSION.innodb_lra_sleep
+1000
+SET GLOBAL innodb_lra_sleep=-1;
+Warnings:
+Warning	1292	Truncated incorrect innodb_lra_sleep value: '-1'
+SELECT @@GLOBAL.innodb_lra_sleep;
+@@GLOBAL.innodb_lra_sleep
+0
+SET GLOBAL innodb_lra_sleep = default;
+SELECT @@GLOBAL.innodb_lra_sleep;
+@@GLOBAL.innodb_lra_sleep
+50
 
=== added file 'mysql-test/suite/sys_vars/r/innodb_lra_test_basic.result'
--- mysql-test/suite/sys_vars/r/innodb_lra_test_basic.result	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/sys_vars/r/innodb_lra_test_basic.result	2014-04-23 10:58:56 +0000
@@ -0,0 +1,8 @@
+set global innodb_lra_test=1;
+select @@global.innodb_lra_test;
+@@global.innodb_lra_test
+1
+set global innodb_lra_test=default;
+select @@global.innodb_lra_test;
+@@global.innodb_lra_test
+0
 
=== added file 'mysql-test/suite/sys_vars/t/innodb_lra_n_node_recs_before_sleep_basic.test'
--- mysql-test/suite/sys_vars/t/innodb_lra_n_node_recs_before_sleep_basic.test	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/sys_vars/t/innodb_lra_n_node_recs_before_sleep_basic.test	2014-04-23 10:58:56 +0000
@@ -0,0 +1,14 @@
+--source include/have_innodb.inc
+
+SET GLOBAL innodb_lra_n_node_recs_before_sleep = 128;
+SELECT @@GLOBAL.innodb_lra_n_node_recs_before_sleep;
+SET SESSION innodb_lra_n_node_recs_before_sleep=1000000;
+SELECT @@SESSION.innodb_lra_n_node_recs_before_sleep;
+SET SESSION innodb_lra_n_node_recs_before_sleep=0;
+SELECT @@SESSION.innodb_lra_n_node_recs_before_sleep;
+SET SESSION innodb_lra_n_node_recs_before_sleep=16384;
+SELECT @@SESSION.innodb_lra_n_node_recs_before_sleep;
+SET GLOBAL innodb_lra_n_node_recs_before_sleep=-1;
+SELECT @@GLOBAL.innodb_lra_n_node_recs_before_sleep;
+SET GLOBAL innodb_lra_n_node_recs_before_sleep = default;
+SELECT @@GLOBAL.innodb_lra_n_node_recs_before_sleep;
 
=== added file 'mysql-test/suite/sys_vars/t/innodb_lra_size_basic-master.opt'
--- mysql-test/suite/sys_vars/t/innodb_lra_size_basic-master.opt	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/sys_vars/t/innodb_lra_size_basic-master.opt	2014-04-23 10:58:56 +0000
@@ -0,0 +1,1 @@
+--innodb-use-native-aio=1
 
=== added file 'mysql-test/suite/sys_vars/t/innodb_lra_size_basic.test'
--- mysql-test/suite/sys_vars/t/innodb_lra_size_basic.test	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/sys_vars/t/innodb_lra_size_basic.test	2014-04-23 10:58:56 +0000
@@ -0,0 +1,14 @@
+--source include/have_innodb.inc
+
+SET GLOBAL innodb_lra_size = 128;
+SELECT @@GLOBAL.innodb_lra_size;
+SET SESSION innodb_lra_size=1000000;
+SELECT @@SESSION.innodb_lra_size;
+SET SESSION innodb_lra_size=0;
+SELECT @@SESSION.innodb_lra_size;
+SET SESSION innodb_lra_size=16384;
+SELECT @@SESSION.innodb_lra_size;
+SET GLOBAL innodb_lra_size=-1;
+SELECT @@GLOBAL.innodb_lra_size;
+SET GLOBAL innodb_lra_size = default;
+SELECT @@GLOBAL.innodb_lra_size;
 
=== added file 'mysql-test/suite/sys_vars/t/innodb_lra_sleep_basic.test'
--- mysql-test/suite/sys_vars/t/innodb_lra_sleep_basic.test	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/sys_vars/t/innodb_lra_sleep_basic.test	2014-04-23 10:58:56 +0000
@@ -0,0 +1,14 @@
+--source include/have_innodb.inc
+
+SET GLOBAL innodb_lra_sleep = 128;
+SELECT @@GLOBAL.innodb_lra_sleep;
+SET SESSION innodb_lra_sleep=1000000;
+SELECT @@SESSION.innodb_lra_sleep;
+SET SESSION innodb_lra_sleep=0;
+SELECT @@SESSION.innodb_lra_sleep;
+SET SESSION innodb_lra_sleep=16384;
+SELECT @@SESSION.innodb_lra_sleep;
+SET GLOBAL innodb_lra_sleep=-1;
+SELECT @@GLOBAL.innodb_lra_sleep;
+SET GLOBAL innodb_lra_sleep = default;
+SELECT @@GLOBAL.innodb_lra_sleep;
 
=== added file 'mysql-test/suite/sys_vars/t/innodb_lra_test_basic-master.opt'
--- mysql-test/suite/sys_vars/t/innodb_lra_test_basic-master.opt	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/sys_vars/t/innodb_lra_test_basic-master.opt	2014-04-23 10:58:56 +0000
@@ -0,0 +1,1 @@
+--innodb-use-native-aio=1
 
=== added file 'mysql-test/suite/sys_vars/t/innodb_lra_test_basic.test'
--- mysql-test/suite/sys_vars/t/innodb_lra_test_basic.test	1970-01-01 00:00:00 +0000
+++ mysql-test/suite/sys_vars/t/innodb_lra_test_basic.test	2014-04-23 10:58:56 +0000
@@ -0,0 +1,8 @@
+--source include/have_debug.inc
+--source include/have_innodb.inc
+--source include/have_native_aio.inc
+
+set global innodb_lra_test=1;
+select @@global.innodb_lra_test;
+set global innodb_lra_test=default;
+select @@global.innodb_lra_test;
 \ No newline at end of file
 
=== modified file 'storage/innobase/btr/btr0cur.cc'
--- storage/innobase/btr/btr0cur.cc	2014-03-03 17:51:33 +0000
+++ storage/innobase/btr/btr0cur.cc	2014-04-23 10:58:56 +0000
@@ -548,6 +548,7 @@
 	    btr_search_enabled below, and btr_search_guess_on_hash()
 	    will have to check it again. */
 	    && UNIV_LIKELY(btr_search_enabled)
+	    && !level
 	    && btr_search_guess_on_hash(index, info, tuple, mode,
 					latch_mode, cursor,
 					has_search_latch, mtr)) {
 
=== modified file 'storage/innobase/btr/btr0pcur.cc'
--- storage/innobase/btr/btr0pcur.cc	2014-03-03 17:51:33 +0000
+++ storage/innobase/btr/btr0pcur.cc	2014-04-23 10:58:56 +0000
@@ -227,6 +227,7 @@
 /*===========================*/
 	ulint		latch_mode,	/*!< in: BTR_SEARCH_LEAF, ... */
 	btr_pcur_t*	cursor,		/*!< in: detached persistent cursor */
+	ulint		level,
 	const char*	file,		/*!< in: file name */
 	ulint		line,		/*!< in: line where called */
 	mtr_t*		mtr)		/*!< in: mtr */
@@ -255,7 +256,7 @@
 		btr_cur_open_at_index_side(
 			cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE,
 			index, latch_mode,
-			btr_pcur_get_btr_cur(cursor), 0, mtr);
+			btr_pcur_get_btr_cur(cursor), level, mtr);
 
 		cursor->latch_mode = latch_mode;
 		cursor->pos_state = BTR_PCUR_IS_POSITIONED;
@@ -267,8 +268,12 @@
 	ut_a(cursor->old_rec);
 	ut_a(cursor->old_n_fields);
 
-	if (UNIV_LIKELY(latch_mode == BTR_SEARCH_LEAF)
-	    || UNIV_LIKELY(latch_mode == BTR_MODIFY_LEAF)) {
+	if (true
+#ifdef UNIV_DEBUG
+	    && !level
+#endif
+	    && (UNIV_LIKELY(latch_mode == BTR_SEARCH_LEAF)
+	    || UNIV_LIKELY(latch_mode == BTR_MODIFY_LEAF))) {
 		/* Try optimistic restoration. */
 
 		if (buf_page_optimistic_get(latch_mode,
@@ -325,24 +330,27 @@
 
 	/* Save the old search mode of the cursor */
 	old_mode = cursor->search_mode;
-
-	switch (cursor->rel_pos) {
-	case BTR_PCUR_ON:
+	if (level > 0) {
 		mode = PAGE_CUR_LE;
-		break;
-	case BTR_PCUR_AFTER:
-		mode = PAGE_CUR_G;
-		break;
-	case BTR_PCUR_BEFORE:
-		mode = PAGE_CUR_L;
-		break;
-	default:
-		ut_error;
-		mode = 0;
+	} else {
+		switch (cursor->rel_pos) {
+		case BTR_PCUR_ON:
+			mode = PAGE_CUR_LE;
+			break;
+		case BTR_PCUR_AFTER:
+			mode = PAGE_CUR_G;
+			break;
+		case BTR_PCUR_BEFORE:
+			mode = PAGE_CUR_L;
+			break;
+		default:
+			ut_error;
+			mode = 0;
+		}
 	}
 
-	btr_pcur_open_with_no_init_func(index, tuple, mode, latch_mode,
-					cursor, 0, file, line, mtr);
+	btr_pcur_open_with_no_init_func_low(index, tuple, mode, latch_mode,
+					    cursor, level, 0, file, line, mtr);
 
 	/* Restore the old search mode */
 	cursor->search_mode = old_mode;
 
=== modified file 'storage/innobase/buf/buf0rea.cc'
--- storage/innobase/buf/buf0rea.cc	2013-10-23 08:48:28 +0000
+++ storage/innobase/buf/buf0rea.cc	2014-04-23 10:58:56 +0000
@@ -123,7 +123,12 @@
 			use to stop dangling page reads from a tablespace
 			which we have DISCARDed + IMPORTed back */
 	ulint	offset,	/*!< in: page number */
-	trx_t*	trx)
+	trx_t*	trx,	/*!< in: transaction object */
+	ibool	should_buffer)	/*!< in: whether to buffer an aio request.
+				AIO read ahead uses this. If you plan to
+				use this parameter, make sure you remember
+				to call os_aio_linux_dispatch_read_array_submit
+				when you are read to commit all your requests.*/
 {
 	buf_page_t*	bpage;
 	ulint		wake_later;
@@ -229,14 +234,16 @@
 		*err = _fil_io(OS_FILE_READ | wake_later
 			       | ignore_nonexistent_pages,
 			       sync, space, zip_size, offset, 0, zip_size,
-			       bpage->zip.data, bpage, trx);
+			       bpage->zip.data, bpage, trx,
+			       should_buffer);
 	} else {
 		ut_a(buf_page_get_state(bpage) == BUF_BLOCK_FILE_PAGE);
 
 		*err = _fil_io(OS_FILE_READ | wake_later
 			      | ignore_nonexistent_pages,
 			      sync, space, 0, offset, 0, UNIV_PAGE_SIZE,
-			      ((buf_block_t*) bpage)->frame, bpage, trx);
+			      ((buf_block_t*) bpage)->frame, bpage, trx,
+			      should_buffer);
 	}
 
 	if (sync) {
@@ -395,7 +402,7 @@
 				&err, false,
 				ibuf_mode | OS_AIO_SIMULATED_WAKE_LATER,
 				space, zip_size, FALSE,
-				tablespace_version, i, trx);
+				tablespace_version, i, trx, FALSE);
 			if (err == DB_TABLESPACE_DELETED) {
 				ut_print_timestamp(stderr);
 				fprintf(stderr,
@@ -459,7 +466,7 @@
 
 	count = buf_read_page_low(&err, true, BUF_READ_ANY_PAGE, space,
 				  zip_size, FALSE,
-				  tablespace_version, offset, trx);
+				  tablespace_version, offset, trx, FALSE);
 	srv_stats.buf_pool_reads.add(count);
 	if (err == DB_TABLESPACE_DELETED) {
 		ut_print_timestamp(stderr);
@@ -507,7 +514,7 @@
 				  | OS_AIO_SIMULATED_WAKE_LATER
 				  | BUF_READ_IGNORE_NONEXISTENT_PAGES,
 				  space, zip_size, FALSE,
-				  tablespace_version, offset, NULL);
+				  tablespace_version, offset, NULL, FALSE);
 	srv_stats.buf_pool_reads.add(count);
 
 	/* We do not increment number of I/O operations used for LRU policy
@@ -584,6 +591,12 @@
 		return(0);
 	}
 
+	/* linear read ahead is disabled if user requested logical read ahead.
+	*/
+	if (trx && trx->lra_size) {
+		return(0);
+	}
+
 	low  = (offset / buf_read_ahead_linear_area)
 		* buf_read_ahead_linear_area;
 	high = (offset / buf_read_ahead_linear_area + 1)
@@ -773,7 +786,8 @@
 			count += buf_read_page_low(
 				&err, false,
 				ibuf_mode,
-				space, zip_size, FALSE, tablespace_version, i, trx);
+				space, zip_size, FALSE, tablespace_version, i, trx,
+				TRUE);
 			if (err == DB_TABLESPACE_DELETED) {
 				ut_print_timestamp(stderr);
 				fprintf(stderr,
@@ -786,6 +800,10 @@
 			}
 		}
 	}
+#if defined(LINUX_NATIVE_AIO)
+	/* Tell aio to submit all buffered requests. */
+	ut_a(os_aio_linux_dispatch_read_array_submit());
+#endif
 
 	/* In simulated aio we wake the aio handler threads only after
 	queuing all aio requests, in native aio the following call does
@@ -863,7 +881,7 @@
 		buf_read_page_low(&err, sync && (i + 1 == n_stored),
 				  BUF_READ_ANY_PAGE, space_ids[i],
 				  zip_size, TRUE, space_versions[i],
-				  page_nos[i], NULL);
+				  page_nos[i], NULL, FALSE);
 
 		if (UNIV_UNLIKELY(err == DB_TABLESPACE_DELETED)) {
 tablespace_deleted:
@@ -1003,15 +1021,20 @@
 		if ((i + 1 == n_stored) && sync) {
 			buf_read_page_low(&err, true, BUF_READ_ANY_PAGE, space,
 					  zip_size, TRUE, tablespace_version,
-					  page_nos[i], NULL);
+					  page_nos[i], NULL, FALSE);
 		} else {
 			buf_read_page_low(&err, false, BUF_READ_ANY_PAGE
 					  | OS_AIO_SIMULATED_WAKE_LATER,
 					  space, zip_size, TRUE,
-					  tablespace_version, page_nos[i], NULL);
+					  tablespace_version, page_nos[i], NULL,
+					  FALSE);
 		}
 	}
 
+#ifdef LINUX_NATIVE_AIO
+	        ut_a(os_aio_linux_dispatch_read_array_submit());
+#endif
+
 	os_aio_simulated_wake_handler_threads();
 
 #ifdef UNIV_DEBUG
 
=== modified file 'storage/innobase/fil/fil0fil.cc'
--- storage/innobase/fil/fil0fil.cc	2014-03-05 11:54:14 +0000
+++ storage/innobase/fil/fil0fil.cc	2014-04-23 10:58:56 +0000
@@ -5168,7 +5168,7 @@
 		success = os_aio(OS_FILE_WRITE, OS_AIO_SYNC,
 				 node->name, node->handle, buf,
 				 offset, page_size * n_pages,
-				 NULL, NULL, space_id, NULL);
+				 NULL, NULL, space_id, NULL, TRUE);
 #endif /* UNIV_HOTBACKUP */
 		if (success) {
 			os_has_said_disk_full = FALSE;
@@ -5545,7 +5545,12 @@
 				appropriately aligned */
 	void*	message,	/*!< in: message for aio handler if non-sync
 				aio used, else ignored */
-	trx_t*	trx)
+	trx_t*	trx,
+	ibool	should_buffer)	/*!< in: whether to buffer an aio request.
+				AIO read ahead uses this. If you plan to
+				use this parameter, make sure you remember
+				to call os_aio_linux_dispatch_read_array_submit
+				when you are read to commit all your requests.*/
 {
 	ulint		mode;
 	fil_space_t*	space;
@@ -5762,7 +5767,7 @@
 
 	/* Queue the aio request */
 	ret = os_aio(type, mode | wake_later, node->name, node->handle, buf,
-		offset, len, node, message, space_id, trx);
+		offset, len, node, message, space_id, trx, should_buffer);
 
 #else
 	/* In ibbackup do normal i/o, not aio */
 
=== modified file 'storage/innobase/handler/ha_innodb.cc'
--- storage/innobase/handler/ha_innodb.cc	2014-03-03 17:51:33 +0000
+++ storage/innobase/handler/ha_innodb.cc	2014-04-23 10:58:56 +0000
@@ -106,6 +106,11 @@
 #include "i_s.h"
 #include "xtradb_i_s.h"
 
+#ifdef TARGET_OS_LINUX
+#include <sys/syscall.h>
+#include <sys/ioctl.h>
+#endif /* TARGET_OS_LINUX */
+
 # ifndef MYSQL_PLUGIN_IMPORT
 #  define MYSQL_PLUGIN_IMPORT /* nothing */
 # endif /* MYSQL_PLUGIN_IMPORT */
@@ -634,6 +639,30 @@
   "Timeout in seconds an InnoDB transaction may wait for a lock before being rolled back. Values above 100000000 disable the timeout.",
   NULL, NULL, 50, 1, 1024 * 1024 * 1024, 0);
 
+static MYSQL_THDVAR_ULONG(lra_size, PLUGIN_VAR_OPCMDARG,
+  "The size (in MBs) of the total size of the pages that innodb will prefetch "
+  "while scanning a table during this session. This is meant to be used only "
+  "for table scans. The upper limit of this variable is 16384 which "
+  "corresponds to prefetching 16GB of data. When set to max, this algorithm "
+  "may use 100M memory.", NULL, NULL, 0, 0, 16384, 0);
+
+static MYSQL_THDVAR_ULONG(lra_n_node_recs_before_sleep, PLUGIN_VAR_OPCMDARG,
+  "innodb_lra_n_node_recs_before_sleep is the number of node pointer records "
+  "traversed while holding the index lock before releasing the index lock "
+  "and sleeping for a short period of time so that the other threads get a "
+  "chance to x-latch the index lock. innodb_lra_sleep is the sleep time in "
+  "milliseconds.",
+  NULL, NULL, 1024, 128, ULINT_MAX, 0);
+
+static MYSQL_THDVAR_ULONG(lra_sleep, PLUGIN_VAR_OPCMDARG,
+  "innodb_lra_n_node_recs_before_sleep is the number of node pointer records "
+  "traversed while holding the index lock before releasing the index lock "
+  "and sleeping for a short period of time so that the other threads get a "
+  "chance to x-latch the index lock. innodb_lra_sleep is the sleep time in "
+  "milliseconds.",
+  NULL, NULL, 50, 0, 1000, 0);
+
+
 static MYSQL_THDVAR_STR(ft_user_stopword_table,
   PLUGIN_VAR_OPCMDARG|PLUGIN_VAR_MEMALLOC,
   "User supplied stopword table name, effective in the session level.",
@@ -851,6 +880,14 @@
   (char*) &export_vars.innodb_x_lock_spin_rounds,	  SHOW_LONGLONG},
   {"x_lock_spin_waits",
   (char*) &export_vars.innodb_x_lock_spin_waits,	  SHOW_LONGLONG},
+  {"buffered_aio_submitted",
+  (char*) &export_vars.innodb_buffered_aio_submitted,     SHOW_LONG},
+  {"logical_read_ahead_misses",
+  (char*) &export_vars.innodb_logical_read_ahead_misses,  SHOW_LONG},
+  {"logical_read_ahead_prefetched",
+  (char*) &export_vars.innodb_logical_read_ahead_prefetched, SHOW_LONG},
+  {"logical_read_ahead_in_buf_pool",
+  (char*) &export_vars.innodb_logical_read_ahead_in_buf_pool, SHOW_LONG},
   {NullS, NullS, SHOW_LONG}
 };
 
@@ -2294,6 +2331,10 @@
 		thd, OPTION_RELAXED_UNIQUE_CHECKS);
 
 	trx->fake_changes = THDVAR(thd, fake_changes);
+	trx_lra_reset(trx,
+		      THDVAR(thd, lra_size),
+		      THDVAR(thd, lra_n_node_recs_before_sleep),
+		      THDVAR(thd, lra_sleep));
 
 #ifdef EXTENDED_SLOWLOG
 	if (thd_log_slow_verbosity(thd) & (1ULL << SLOG_V_INNODB)) {
@@ -2326,6 +2367,10 @@
 	trx = trx_allocate_for_mysql();
 
 	trx->mysql_thd = thd;
+	trx_lra_reset(trx,
+		      THDVAR(thd, lra_size),
+		      THDVAR(thd, lra_n_node_recs_before_sleep),
+		      THDVAR(thd, lra_sleep));
 
 	innobase_trx_init(thd, trx);
 
@@ -3860,6 +3905,7 @@
 /*================*/
 	trx_t*	trx)	/*!< in: transaction handle */
 {
+	trx_lra_reset(trx, 0, 0, 0);
 	if (trx_is_started(trx)) {
 
 		trx_commit_for_mysql(trx);
@@ -17573,6 +17619,17 @@
   "It is to create artificially the situation the purge view have been updated "
   "but the each purges were not done yet.",
   NULL, NULL, FALSE);
+
+#ifdef UNIV_DEBUG
+extern my_bool row_lra_test;
+#endif
+
+static MYSQL_SYSVAR_BOOL(lra_test, row_lra_test,
+  PLUGIN_VAR_NOCMDARG,
+  "When set to true, the purge thread stops until the logical read ahead "
+  "sets this variable to TRUE. Used for testing edge cases regarding the "
+  "purge thread and logical read ahead.",
+  NULL, NULL, FALSE);
 #endif /* UNIV_DEBUG */
 
 const char *corrupt_table_action_names[]=
@@ -17789,10 +17846,14 @@
   MYSQL_SYSVAR(trx_rseg_n_slots_debug),
   MYSQL_SYSVAR(limit_optimistic_insert_debug),
   MYSQL_SYSVAR(trx_purge_view_update_only_debug),
+  MYSQL_SYSVAR(lra_test),
 #endif /* UNIV_DEBUG */
   MYSQL_SYSVAR(corrupt_table_action),
   MYSQL_SYSVAR(fake_changes),
   MYSQL_SYSVAR(locking_fake_changes),
+  MYSQL_SYSVAR(lra_size),
+  MYSQL_SYSVAR(lra_n_node_recs_before_sleep),
+  MYSQL_SYSVAR(lra_sleep),
   NULL
 };
 
 
=== modified file 'storage/innobase/include/btr0pcur.h'
--- storage/innobase/include/btr0pcur.h	2014-02-17 11:12:40 +0000
+++ storage/innobase/include/btr0pcur.h	2014-04-23 10:58:56 +0000
@@ -262,11 +262,12 @@
 /*===========================*/
 	ulint		latch_mode,	/*!< in: BTR_SEARCH_LEAF, ... */
 	btr_pcur_t*	cursor,		/*!< in: detached persistent cursor */
+	ulint		level,
 	const char*	file,		/*!< in: file name */
 	ulint		line,		/*!< in: line where called */
 	mtr_t*		mtr);		/*!< in: mtr */
-#define btr_pcur_restore_position(l,cur,mtr)				\
-	btr_pcur_restore_position_func(l,cur,__FILE__,__LINE__,mtr)
+#define btr_pcur_restore_position(l, cur, mtr)				\
+	btr_pcur_restore_position_func(l, cur, 0, __FILE__, __LINE__, mtr)
 /*********************************************************//**
 Gets the rel_pos field for a cursor whose position has been stored.
 @return	BTR_PCUR_ON, ... */
 
=== modified file 'storage/innobase/include/btr0pcur.ic'
--- storage/innobase/include/btr0pcur.ic	2014-02-17 11:12:40 +0000
+++ storage/innobase/include/btr0pcur.ic	2014-04-23 10:58:56 +0000
@@ -448,6 +448,54 @@
 cursor. */
 UNIV_INLINE
 void
+btr_pcur_open_with_no_init_func_low(
+/*============================*/
+	dict_index_t*	index,	/*!< in: index */
+	const dtuple_t*	tuple,	/*!< in: tuple on which search done */
+	ulint		mode,	/*!< in: PAGE_CUR_L, ...;
+				NOTE that if the search is made using a unique
+				prefix of a record, mode should be
+				PAGE_CUR_LE, not PAGE_CUR_GE, as the latter
+				may end up on the previous page of the
+				record! */
+	ulint		latch_mode,/*!< in: BTR_SEARCH_LEAF, ...;
+				NOTE that if has_search_latch != 0 then
+				we maybe do not acquire a latch on the cursor
+				page, but assume that the caller uses his
+				btr search latch to protect the record! */
+	btr_pcur_t*	cursor, /*!< in: memory buffer for persistent cursor */
+	ulint		level,
+	ulint		has_search_latch,/*!< in: latch mode the caller
+				         currently has on btr_search_latch:
+				         RW_S_LATCH, or 0 */
+	const char*	file,	/*!< in: file name */
+	ulint		line,	/*!< in: line where called */
+	mtr_t*		mtr)	/*!< in: mtr */
+{
+	btr_cur_t*	btr_cursor;
+
+	cursor->latch_mode = latch_mode;
+	cursor->search_mode = mode;
+
+	/* Search with the tree cursor */
+
+	btr_cursor = btr_pcur_get_btr_cur(cursor);
+
+	btr_cur_search_to_nth_level(index, level, tuple, mode, latch_mode,
+				    btr_cursor, has_search_latch,
+				    file, line, mtr);
+	cursor->pos_state = BTR_PCUR_IS_POSITIONED;
+
+	cursor->old_stored = BTR_PCUR_OLD_NOT_STORED;
+
+	cursor->trx_if_known = NULL;
+}
+
+/**************************************************************//**
+Opens an persistent cursor to an index tree without initializing the
+cursor. */
+UNIV_INLINE
+void
 btr_pcur_open_with_no_init_func(
 /*============================*/
 	dict_index_t*	index,	/*!< in: index */
@@ -471,23 +519,9 @@
 	ulint		line,	/*!< in: line where called */
 	mtr_t*		mtr)	/*!< in: mtr */
 {
-	btr_cur_t*	btr_cursor;
-
-	cursor->latch_mode = latch_mode;
-	cursor->search_mode = mode;
-
-	/* Search with the tree cursor */
-
-	btr_cursor = btr_pcur_get_btr_cur(cursor);
-
-	btr_cur_search_to_nth_level(index, 0, tuple, mode, latch_mode,
-				    btr_cursor, has_search_latch,
-				    file, line, mtr);
-	cursor->pos_state = BTR_PCUR_IS_POSITIONED;
-
-	cursor->old_stored = BTR_PCUR_OLD_NOT_STORED;
-
-	cursor->trx_if_known = NULL;
+	return btr_pcur_open_with_no_init_func_low(
+			index, tuple, mode, latch_mode, cursor,
+			0, has_search_latch, file, line, mtr);
 }
 
 /*****************************************************************//**
 
=== modified file 'storage/innobase/include/buf0rea.h'
--- storage/innobase/include/buf0rea.h	2013-10-23 08:48:28 +0000
+++ storage/innobase/include/buf0rea.h	2014-04-23 10:58:56 +0000
@@ -30,6 +30,43 @@
 #include "buf0types.h"
 
 /********************************************************************//**
+Low-level function which reads a page asynchronously from a file to the
+buffer buf_pool if it is not already there, in which case does nothing.
+Sets the io_fix flag and sets an exclusive lock on the buffer frame. The
+flag is cleared and the x-lock released by an i/o-handler thread.
+@return 1 if a read request was queued, 0 if the page already resided
+in buf_pool, or if the page is in the doublewrite buffer blocks in
+which case it is never read into the pool, or if the tablespace does
+not exist or is being dropped
+@return 1 if read request is issued. 0 if it is not */
+UNIV_INTERN
+ulint
+buf_read_page_low(
+/*==============*/
+	dberr_t*	err,	/*!< out: DB_SUCCESS or DB_TABLESPACE_DELETED
+			if we are trying to read from a non-existent
+			tablespace, or a tablespace which is just now being
+			dropped */
+	bool	sync,	/*!< in: TRUE if synchronous aio is desired */
+	ulint	mode,	/*!< in: BUF_READ_IBUF_PAGES_ONLY, ...,
+			ORed to OS_AIO_SIMULATED_WAKE_LATER (see below
+			at read-ahead functions) */
+	ulint	space,	/*!< in: space id */
+	ulint	zip_size,/*!< in: compressed page size, or 0 */
+	ibool	unzip,	/*!< in: TRUE=request uncompressed page */
+	ib_int64_t tablespace_version, /*!< in: if the space memory object has
+			this timestamp different from what we are giving here,
+			treat the tablespace as dropped; this is a timestamp
+			we use to stop dangling page reads from a tablespace
+			which we have DISCARDed + IMPORTed back */
+	ulint	offset,	/*!< in: page number */
+	trx_t*	trx,	/*!< in: transaction object */
+	ibool	should_buffer);	/*!< in: whether to buffer an aio request.
+				AIO read ahead uses this. If you plan to
+				use this parameter, make sure you remember
+				to call os_aio_linux_dispatch_read_array_submit
+				when you are read to commit all your requests.*/
+/********************************************************************//**
 High-level function which reads a page asynchronously from a file to the
 buffer buf_pool if it is not already there. Sets the io_fix flag and sets
 an exclusive lock on the buffer frame. The flag is cleared and the x-lock
 
=== modified file 'storage/innobase/include/fil0fil.h'
--- storage/innobase/include/fil0fil.h	2014-02-17 11:12:40 +0000
+++ storage/innobase/include/fil0fil.h	2014-04-23 10:58:56 +0000
@@ -724,7 +724,7 @@
 @return DB_SUCCESS, or DB_TABLESPACE_DELETED if we are trying to do
 i/o on a tablespace which does not exist */
 #define fil_io(type, sync, space_id, zip_size, block_offset, byte_offset, len, buf, message) \
-	_fil_io(type, sync, space_id, zip_size, block_offset, byte_offset, len, buf, message, NULL)
+	_fil_io(type, sync, space_id, zip_size, block_offset, byte_offset, len, buf, message, NULL, FALSE)
 
 UNIV_INTERN
 dberr_t
@@ -755,7 +755,10 @@
 				appropriately aligned */
 	void*	message,	/*!< in: message for aio handler if non-sync
 				aio used, else ignored */
-	trx_t*	trx)
+	trx_t*	trx,
+	ibool	should_buffer	/*!< in: whether to buffer an aio request.
+				Only used by aio read ahead*/
+)
 	__attribute__((nonnull(8)));
 /**********************************************************************//**
 Waits for an aio operation to complete. This function is used to write the
 
=== modified file 'storage/innobase/include/os0file.h'
--- storage/innobase/include/os0file.h	2014-02-17 11:12:40 +0000
+++ storage/innobase/include/os0file.h	2014-04-23 10:58:56 +0000
@@ -321,10 +321,11 @@
 	pfs_os_file_close_func(file, __FILE__, __LINE__)
 
 # define os_aio(type, mode, name, file, buf, offset,			\
-		n, message1, message2, space_id, trx)			\
+		n, message1, message2, space_id, trx,                   \
+		should_buffer)		                                \
 	pfs_os_aio_func(type, mode, name, file, buf, offset,		\
 		n, message1, message2, space_id, trx,			\
-		__FILE__, __LINE__)
+		__FILE__, __LINE__, should_buffer)
 
 # define os_file_read(file, buf, offset, n)				\
 	pfs_os_file_read_func(file, buf, offset, n, NULL,		\
@@ -371,9 +372,9 @@
 # define os_file_close(file)	os_file_close_func(file)
 
 # define os_aio(type, mode, name, file, buf, offset, n, message1,	\
-		message2, space_id, trx)				\
+		message2, space_id, trx, should_buffer)			\
 	os_aio_func(type, mode, name, file, buf, offset, n,		\
-		    message1, message2, space_id, trx)
+		    message1, message2, space_id, trx, should_buffer)
 
 # define os_file_read(file, buf, offset, n)				\
 	os_file_read_func(file, buf, offset, n, NULL)
@@ -777,7 +778,13 @@
 	ulint		space_id,
 	trx_t*		trx,
 	const char*	src_file,/*!< in: file name where func invoked */
-	ulint		src_line);/*!< in: line where the func invoked */
+	ulint		src_line,/*!< in: line where the func invoked */
+	ibool		should_buffer);
+				/*!< in: Whether to buffer an aio request.
+				AIO read ahead uses this. If you plan to
+				use this parameter, make sure you remember
+				to call os_aio_linux_dispatch_read_array_submit
+				when you are read to commit all your requests.*/
 /*******************************************************************//**
 NOTE! Please use the corresponding macro os_file_write(), not directly
 this function!
@@ -1148,7 +1155,12 @@
 				aio operation); ignored if mode is
 				OS_AIO_SYNC */
 	ulint		space_id,
-	trx_t*		trx);
+	trx_t*		trx,
+	ibool	should_buffer);	/*!< in: Whether to buffer an aio request.
+				AIO read ahead uses this. If you plan to
+				use this parameter, make sure you remember
+				to call os_aio_linux_dispatch_read_array_submit
+				when you are read to commit all your requests.*/
 /************************************************************************//**
 Wakes up all async i/o threads so that they know to exit themselves in
 shutdown. */
@@ -1315,6 +1327,12 @@
 				restart the operation. */
 	ulint*	type,		/*!< out: OS_FILE_WRITE or ..._READ */
 	ulint*	space_id);
+/*******************************************************************//**
+Submit buffered AIO requests on the given segment to the kernel.
+@return	TRUE on success. */
+UNIV_INTERN
+ibool
+os_aio_linux_dispatch_read_array_submit();
 #endif /* LINUX_NATIVE_AIO */
 
 #ifndef UNIV_NONINL
 
=== modified file 'storage/innobase/include/os0file.ic'
--- storage/innobase/include/os0file.ic	2013-10-23 08:48:28 +0000
+++ storage/innobase/include/os0file.ic	2014-04-23 10:58:56 +0000
@@ -213,7 +213,10 @@
 	ulint		space_id,
 	trx_t*		trx,
 	const char*	src_file,/*!< in: file name where func invoked */
-	ulint		src_line)/*!< in: line where the func invoked */
+	ulint		src_line,/*!< in: line where the func invoked */
+	ibool		should_buffer)
+				/*!< in: whether to buffer an aio request.
+				Only used by aio read ahead*/
 {
 	ibool	result;
 	struct PSI_file_locker*	locker = NULL;
@@ -227,7 +230,8 @@
 				   src_file, src_line);
 
 	result = os_aio_func(type, mode, name, file, buf, offset,
-			     n, message1, message2, space_id, trx);
+			     n, message1, message2, space_id, trx,
+			     should_buffer);
 
 	register_pfs_file_io_end(locker, n);
 
 
=== modified file 'storage/innobase/include/srv0srv.h'
--- storage/innobase/include/srv0srv.h	2014-02-17 11:12:40 +0000
+++ storage/innobase/include/srv0srv.h	2014-04-23 10:58:56 +0000
@@ -129,6 +129,23 @@
 	ulint_ctr_1_t		lock_deadlock_count;
 
 	ulint_ctr_1_t		n_lock_max_wait_time;
+
+	/** Number of buffered aio requests submitted */
+	ulint_ctr_64_t		n_aio_submitted;
+
+	/** total number of pages that logical-read-ahead missed while doing
+	a table scan. The number is the total for all transactions that used a
+	non-zero innodb_lra_size. */
+	ulint_ctr_64_t n_logical_read_ahead_misses;
+	/** total number of pages that logical-read-ahead prefetched. The
+	number is the total for all transactions that used a non-zero
+	innodb_lra_size. */
+	ulint_ctr_64_t n_logical_read_ahead_prefetched;
+	/** total number of pages that logical-read-ahead did not need to
+	prefetch because these pages were already in the buffer pool. The
+	number is the total for all transactions that used a non-zero
+	innodb_lra_size. */
+	ulint_ctr_64_t n_logical_read_ahead_in_buf_pool;
 };
 
 extern const char*	srv_main_thread_op_info;
@@ -1060,6 +1077,31 @@
 	ulint innodb_purge_view_trx_id_age;	/*!< rw_max_trx_id
 						- purged view's min trx_id */
 #endif /* UNIV_DEBUG */
+	ulint innodb_buffered_aio_submitted;
+	ulint innodb_logical_read_ahead_misses; /*!< total number of pages that
+						logical-read-ahead missed
+						during a table scan.
+						The number is the total for all
+						the transactions that used a
+						non-zero
+						innodb_lra_size.
+						*/
+	ulint innodb_logical_read_ahead_prefetched; /*!< total number of pages
+						that logical-read-ahead
+						prefetched. The number is the
+						total for all the transactions
+						that used a non-zero
+						innodb_lra_size.
+						*/
+	ulint innodb_logical_read_ahead_in_buf_pool; /*!< total number of pages
+						that logical-read-ahead did not
+						need to prefetch because these
+						pages were already in the
+						buffer pool. The number is the
+						total for all transactions that
+						used a non-zero
+						innodb_lra_size.
+						*/
 };
 
 /** Thread slot in the thread table.  */
 
=== modified file 'storage/innobase/include/trx0trx.h'
--- storage/innobase/include/trx0trx.h	2014-02-17 11:12:40 +0000
+++ storage/innobase/include/trx0trx.h	2014-04-23 10:58:56 +0000
@@ -39,6 +39,13 @@
 #include "trx0xa.h"
 #include "ut0vec.h"
 #include "fts0fts.h"
+#include "btr0types.h"
+
+#ifdef TARGET_OS_LINUX
+#include <sys/syscall.h>
+#include <sys/ioctl.h>
+#endif /* TARGET_OS_LINUX */
+
 
 /** Dummy session used currently in MySQL interface */
 extern sess_t*	trx_dummy_sess;
@@ -135,7 +142,27 @@
 #define trx_start_if_not_started_xa(t)				\
 	trx_start_if_not_started_xa_low((t))
 #endif /* UNIV_DEBUG */
-
+/*************************************************************//**
+Creates or frees data structures related to logical-read-ahead.
+based on the value of lra_size. */
+UNIV_INTERN
+void
+trx_lra_reset(
+	trx_t* trx, /*!< in: transaction */
+	ulint lra_size, /*!< in: lra_size in MB.
+				       If 0, the fields that are releated
+				       to logical-read-ahead will be free'd
+				       if they were initialized. */
+	ulint lra_n_node_recs_before_sleep,
+					/*!< in: lra_n_node_recs_before_sleep
+					is the number of node pointer records
+					traversed while holding the index lock
+					before releasing the index lock and
+					sleeping for a short period of time so
+					that the other threads get a chance to
+					x-latch the index lock. */
+	ulint lra_sleep);		/* lra_sleep is the sleep time in
+					milliseconds. */
 /*************************************************************//**
 Starts the transaction if it is not yet started. */
 UNIV_INTERN
@@ -650,6 +677,15 @@
 
 #define TRX_MAGIC_N	91118598
 
+/*******************************************************************//**
+Helper data structure to store page numbers in an internally-linked hash
+table. */
+typedef struct page_no_holder_struct page_no_holder_t;
+struct page_no_holder_struct {
+        ulint	page_no;
+        page_no_holder_t* hash;
+};
+
 /** The transaction handle
 
 Normally, there is a 1:1 relationship between a transaction handle
@@ -804,6 +840,65 @@
 					150 bytes in the undo log size as then
 					we skip XA steps */
 	ulint		fake_changes;
+	ulint		lra_size;	/* Total size (in MBs) of the
+					pages that will be prefetched by
+					logical read ahead. */
+	ulint		lra_n_pages;	/* Number of pages that lra prefetches
+					every time. This is computed using
+					lra_size and the currently scanned
+					table's block size */
+	ulint		lra_space_id;	/* The last space id that the scanning
+					transaction accessed. If the scanning
+					trx accesses multiple tables, we need
+					to reset the data structures that lra
+					uses. */
+	ulint		lra_page_no;	/* The last page that was visited
+					by the trx. Used by the
+					logical-read-ahead algorithm to
+					determine if a new prefetch should be
+					performed. */
+	hash_table_t*	lra_ht1;
+	hash_table_t*	lra_ht2;	/* Hash tables store the leaf page
+					numbers for the already prefetched
+					pages. Each hash table will typically
+					have lra_n_pages pages and when the
+					scanning trx visits all lra_n_pages
+					pages in one of them, we will empty
+					that one and prefetch another batch of
+					lra_n_pages pages. */
+	hash_table_t*	lra_ht;		/* lra_ht points to lra_ht1 and lra_ht2
+					alternatingly. */
+	ulint		lra_n_pages_since;/* number of leaf pages visited since
+					the last prefetch operation. We require
+					that no prefetch be done until the
+					scanning trx scans lra_n_pages pages.
+					*/
+	ulint*		lra_sort_arr;	/* Array used for sorting the page
+					numbers before issuing the read
+					requests */
+	page_no_holder_t* lra_arr1;	/* Pre-allocated array of
+					page_no_holder objects which are used
+					by the logical-read-ahead algorithm for
+					lra_ht1. */
+	page_no_holder_t* lra_arr2;	/* Pre-allocated array of
+					page_no_holder objects which are used
+					by the logical-read-ahead algorithm for
+					lra_ht2. */
+	btr_pcur_t*	lra_cur;	/* The persistent cursor that points
+					to the first node pointer record for
+					which the associated leaf page is not
+					prefetched by LRA. */
+	ulint		lra_n_node_recs_before_sleep;
+					/* lra_n_node_recs_before_sleep
+					is the number of node pointer records
+					traversed while holding the index lock
+					before releasing the index lock and
+					sleeping for a short period of time so
+					that the other threads get a chance to
+					x-latch the index lock. */
+	ulint		lra_sleep;	/* lra_sleep is the sleep time in
+					milliseconds. */
+	ulint		lra_tree_height;
 	ulint		flush_log_later;/* In 2PC, we hold the
 					prepare_commit mutex across
 					both phases. In that case, we
 
=== modified file 'storage/innobase/os/os0file.cc'
--- storage/innobase/os/os0file.cc	2014-03-03 17:51:33 +0000
+++ storage/innobase/os/os0file.cc	2014-04-23 10:58:56 +0000
@@ -245,6 +245,16 @@
 				There is one such event for each
 				possible pending IO. The size of the
 				array is equal to n_slots. */
+	struct iocb**		pending;
+				/* Array to buffer the not-submitted aio
+				requests. The array length is n_slots.
+				It is divided into n_segments segments.
+				pending requests on each segment are buffered
+				separately.*/
+	ulint*			count;
+				/* Array of length n_segments. Each element
+				counts the number of not-submitted aio request
+				on that segment.*/
 #endif /* LINUX_NATIV_AIO */
 };
 
@@ -3926,6 +3936,13 @@
 	memset(io_event, 0x0, sizeof(*io_event) * n);
 	array->aio_events = io_event;
 
+	array->pending = static_cast<struct iocb**>(
+		ut_malloc(n * sizeof(struct iocb*)));
+	memset(array->pending, 0x0, sizeof(struct iocb*) * n);
+	array->count = static_cast<ulint*>(
+		ut_malloc(n_segments * sizeof(ulint)));
+	memset(array->count, 0x0, sizeof(ulint) * n_segments);
+
 skip_native_aio:
 #endif /* LINUX_NATIVE_AIO */
 	for (ulint i = 0; i < n; i++) {
@@ -3982,6 +3999,8 @@
 	if (srv_use_native_aio) {
 		ut_free(array->aio_events);
 		ut_free(array->aio_ctx);
+		ut_free(array->pending);
+		ut_free(array->count);
 	}
 #endif /* LINUX_NATIVE_AIO */
 
@@ -4605,6 +4624,49 @@
 
 #if defined(LINUX_NATIVE_AIO)
 /*******************************************************************//**
+Submit buffered AIO requests on the given segment to the kernel.
+@return	TRUE on success. */
+UNIV_INTERN
+ibool
+os_aio_linux_dispatch_read_array_submit()
+{
+	os_aio_array_t* array = os_aio_read_array;
+	ulint total_submitted = 0;
+	ulint total_count = 0;
+	if (!srv_use_native_aio) {
+		return TRUE;
+	}
+	os_mutex_enter(array->mutex);
+	/* Submit aio requests buffered on all segments. */
+	for (ulint i = 0; i < array->n_segments; i++) {
+		ulint count = array->count[i];
+		if (count > 0) {
+			ulint iocb_index = i * array->n_slots
+					   / array->n_segments;
+			total_count += count;
+			total_submitted += io_submit(array->aio_ctx[i], count,
+					       &(array->pending[iocb_index]));
+		}
+	}
+	/* Reset the aio request buffer. */
+	memset(array->pending, 0x0,
+	       sizeof(struct iocb*) * array->n_slots);
+	memset(array->count, 0x0, sizeof(ulint) * array->n_segments);
+	os_mutex_exit(array->mutex);
+
+	srv_stats.n_aio_submitted.add(total_count);
+
+	/* io_submit returns number of successfully
+	queued requests or -errno. */
+	if (UNIV_UNLIKELY(total_count != total_submitted)) {
+		errno = -total_submitted;
+		return(FALSE);
+	}
+
+	return(TRUE);
+}
+
+/*******************************************************************//**
 Dispatch an AIO request to the kernel.
 @return	TRUE on success. */
 static
@@ -4612,24 +4674,46 @@
 os_aio_linux_dispatch(
 /*==================*/
 	os_aio_array_t*	array,	/*!< in: io request array. */
-	os_aio_slot_t*	slot)	/*!< in: an already reserved slot. */
+	os_aio_slot_t*	slot,	/*!< in: an already reserved slot. */
+	ibool		should_buffer)	/*!< in: should buffer the request
+					rather than submit. */
 {
 	int		ret;
-	ulint		io_ctx_index;
+	ulint		io_ctx_index = 0;
 	struct iocb*	iocb;
+	ulint slots_per_segment;
 
-	ut_ad(slot != NULL);
+	ut_ad(slot);
 	ut_ad(array);
-
 	ut_a(slot->reserved);
 
 	/* Find out what we are going to work with.
 	The iocb struct is directly in the slot.
 	The io_context is one per segment. */
 
+	slots_per_segment = array->n_slots / array->n_segments;
 	iocb = &slot->control;
-	io_ctx_index = (slot->pos * array->n_segments) / array->n_slots;
-
+	io_ctx_index = slot->pos / slots_per_segment;
+	if (should_buffer) {
+		ulint n;
+		os_mutex_enter(array->mutex);
+		/* There are array->n_slots elements in array->pending,
+		which is divided into array->n_segments area of equal size.
+		The iocb of each segment are buffered in its corresponding area
+		in the pending array consecutively as they come.
+		array->count[i] records the number of buffered aio requests
+		in the ith segment.*/
+		n = io_ctx_index * slots_per_segment
+			  + array->count[io_ctx_index];
+		array->pending[n] = iocb;
+		array->count[io_ctx_index] ++;
+		os_mutex_exit(array->mutex);
+		if (array->count[io_ctx_index] == slots_per_segment) {
+			return os_aio_linux_dispatch_read_array_submit();
+		}
+		return(TRUE);
+	}
+	/* Submit the given request. */
 	ret = io_submit(array->aio_ctx[io_ctx_index], 1, &iocb);
 
 #if defined(UNIV_AIO_DEBUG)
@@ -4689,7 +4773,12 @@
 				aio operation); ignored if mode is
 				OS_AIO_SYNC */
 	ulint		space_id,
-	trx_t*		trx)
+	trx_t*		trx,
+	ibool	should_buffer)	/*!< in: Whether to buffer an aio request.
+				AIO read ahead uses this. If you plan to
+				use this parameter, make sure you remember
+				to call os_aio_linux_dispatch_read_array_submit
+				when you are read to commit all your requests.*/
 {
 	os_aio_array_t*	array;
 	os_aio_slot_t*	slot;
@@ -4802,7 +4891,8 @@
 				       &(slot->control));
 
 #elif defined(LINUX_NATIVE_AIO)
-			if (!os_aio_linux_dispatch(array, slot)) {
+			if (!os_aio_linux_dispatch(array, slot,
+						   should_buffer)) {
 				goto err_exit;
 			}
 #endif /* WIN_ASYNC_IO */
@@ -4822,7 +4912,7 @@
 					&(slot->control));
 
 #elif defined(LINUX_NATIVE_AIO)
-			if (!os_aio_linux_dispatch(array, slot)) {
+			if (!os_aio_linux_dispatch(array, slot, FALSE)) {
 				goto err_exit;
 			}
 #endif /* WIN_ASYNC_IO */
 
=== modified file 'storage/innobase/row/row0purge.cc'
--- storage/innobase/row/row0purge.cc	2013-06-20 15:16:00 +0000
+++ storage/innobase/row/row0purge.cc	2014-04-23 10:58:56 +0000
@@ -187,6 +187,10 @@
 	return(success);
 }
 
+#ifdef UNIV_DEBUG
+extern my_bool row_lra_test;
+#endif
+
 /***********************************************************//**
 Removes a clustered index record if it has not been modified after the delete
 marking.
@@ -203,6 +207,11 @@
 		return(true);
 	}
 
+#ifdef UNIV_DEBUG
+	while (row_lra_test) {
+		os_thread_sleep(300000);
+	}
+#endif
 	for (ulint n_tries = 0;
 	     n_tries < BTR_CUR_RETRY_DELETE_N_TIMES;
 	     n_tries++) {
 
=== modified file 'storage/innobase/row/row0sel.cc'
--- storage/innobase/row/row0sel.cc	2014-03-03 17:51:33 +0000
+++ storage/innobase/row/row0sel.cc	2014-04-23 10:58:56 +0000
@@ -60,6 +60,8 @@
 #include "srv0start.h"
 #include "m_string.h" /* for my_sys.h */
 #include "my_sys.h" /* DEBUG_SYNC_C */
+#include "ut0sort.h"
+#include <algorithm>
 
 #include "my_compare.h" /* enum icp_result */
 
@@ -3632,6 +3634,318 @@
 	return(result);
 }
 
+/**********************************************************************//**
+Determines the page numbers for the next batch of pages that will be
+prefetched for logical read ahead and stores them in the hash_table and
+page_no_array. Does not issue read requests. */
+static
+void
+row_read_ahead_logical_low(
+	hash_table_t*	hash_table, /* in/out: This hash table is emptied and
+				    then filled with the next batch of page
+				    numbers that should be prefetched. */
+	ulint* n_prefetched_ptr,    /* in/out: the number that's pointed by
+				    this pointer is incremented by the number
+				    of pages that are added to the hash_table */
+	ulint* page_no_array,       /* out: the page numbers that will be
+				    prefetched are stored in this array */
+	dict_index_t* index,        /* in: index object for the table */
+	mtr_t* mtr,                 /* in: mini transaction object used for
+				    acquiring and releasing the necessary locks */
+	ulint* offsets,             /* in/out: temporary storage for offsets */
+	mem_heap_t* heap,           /* in: temporary memory heap */
+	trx_t *trx)
+{
+	page_no_holder_t* page_no_holder;
+	page_no_holder_t* lra_arr;
+	ulint page_no;
+	ulint n_prefetched = 0;
+	rec_t* rec;
+	/* empty the hash table because we don't want it to grow to hold
+	all leaf page numbers of the table. The concern is not memory, but
+	the lookup time. */
+	hash_table_clear(hash_table);
+	if (hash_table == trx->lra_ht1) {
+		lra_arr = trx->lra_arr1;
+	} else {
+		lra_arr = trx->lra_arr2;
+	}
+	while (!btr_pcur_is_after_last_in_tree(trx->lra_cur, mtr)
+	       && n_prefetched < trx->lra_n_pages) {
+		if (UNIV_UNLIKELY(trx_is_interrupted(trx))) {
+			return;
+		}
+		rec = btr_pcur_get_rec(trx->lra_cur);
+		if (page_rec_is_supremum(rec) || page_rec_is_infimum(rec)) {
+			btr_pcur_move_to_next(trx->lra_cur, mtr);
+			continue;
+		}
+		offsets = rec_get_offsets(rec, index, offsets,
+					  ULINT_UNDEFINED, &heap);
+		page_no = btr_node_ptr_get_child_page_no(rec, offsets);
+		page_no_holder = &lra_arr[n_prefetched];
+		page_no_holder->page_no = page_no;
+		page_no_holder->hash = NULL;
+		HASH_INSERT(page_no_holder_t, hash, hash_table,
+			    page_no, page_no_holder);
+		btr_pcur_move_to_next(trx->lra_cur, mtr);
+		page_no_array[n_prefetched] = page_no;
+		++n_prefetched;
+		if (trx->lra_n_node_recs_before_sleep
+		    && trx->lra_sleep
+		    &&
+		    ((n_prefetched % trx->lra_n_node_recs_before_sleep) == 0))
+		{
+			btr_pcur_store_position(trx->lra_cur, mtr);
+			mtr_commit(mtr);
+			os_thread_sleep(trx->lra_sleep * 1000);
+			mtr_start(mtr);
+			btr_pcur_restore_position_func(
+					BTR_SEARCH_LEAF, trx->lra_cur, 1,
+					__FILE__, __LINE__, mtr);
+		}
+	}
+	*n_prefetched_ptr += n_prefetched;
+}
+
+/*********************************************************************//**
+Returns TRUE if the page specified by page_no was prefetched.
+@return: TRUE if the page was prefetched before. */
+UNIV_INLINE
+ibool
+row_lra_is_prefetched(
+	const trx_t* trx, /* in: trx->lra_ht1 and trx->lra_ht2 are
+			  probed to see if page page_no was prefetched */
+	ulint page_no)    /* in: page no for the page that is being checked */
+{
+	page_no_holder_t* page_no_holder = NULL;
+	hash_table_t*	other_table;
+	HASH_SEARCH(hash, trx->lra_ht, page_no, page_no_holder_t*,
+		    page_no_holder, ut_a(1),
+		    page_no_holder->page_no == page_no);
+	if (page_no_holder) {
+		return TRUE;
+	}
+	other_table = trx->lra_ht == trx->lra_ht1 ? trx->lra_ht2
+						  : trx->lra_ht1;
+	HASH_SEARCH(hash, other_table, page_no, page_no_holder_t*,
+		    page_no_holder, ut_a(1),
+		    page_no_holder->page_no == page_no);
+	if (page_no_holder) {
+		return TRUE;
+	}
+	return FALSE;
+}
+
+#ifdef UNIV_DEBUG
+my_bool row_lra_test = FALSE;
+#endif
+
+/*********************************************************************//**
+This function submits io requests for pages that are logical successors to
+the page that is pointed by pcur. It is meant to be called during sequential
+scan to prefetch pages and speed-up the scan. The number of pages that are
+prefetched is determined by the session variable innodb_logical_readahead_size
+divided by the block size of the table. It is ok to call this function
+successively even if pcur did not move to the next page because this function
+keeps track of the page numbers it prefetched and won't duplicate io requests.
+This function may temporarily release the block latches held by pcur and
+re-acquire them.
+@return: TRUE if the function released the block latch and re-acquired it and
+now the cursor pcur points to a new record that must be processed by the
+caller. */
+static
+ibool
+row_read_ahead_logical(
+	btr_pcur_t* pcur,      /* in/out: Cursor from which the current page
+                               number is obtained. Cursor's position may change
+			       and this is indicated in the return value. */
+	dict_index_t* index,   /* in: index object for the table */
+	mtr_t* mtr,            /* in: mini-transaction. May be committed and
+			       restarted */
+	ulint* offsets,        /* in: temporary storage for offsets */
+	mem_heap_t** heap_ptr, /* in/out: If *heap_ptr is not NULL then this
+			       heap is used for memory allocations, otherwise
+			       a new heap is created and stored in *heap_ptr.
+			       The caller is responsible for freeing the heap */
+	trx_t *trx)
+{
+	buf_block_t* block = btr_cur_get_block(&pcur->btr_cur);
+	ibool same_user_rec;
+	mem_heap_t* heap;
+	ib_int64_t tablespace_version;
+	ulint page_no = buf_block_get_page_no(block);
+	ulint space = buf_block_get_space(block);
+	ulint zip_size = buf_block_get_zip_size(block);
+	rec_t* rec;
+	dtuple_t* tuple;
+	dberr_t err;
+	ulint num_prefetched = 0;
+	ulint num_read_requests = 0;
+	ulint i;
+	ulint root_page_no;
+	buf_block_t* root_block;
+
+	if (!trx->lra_size) {
+		return FALSE;
+	}
+	if (trx->lra_space_id == space && trx->lra_tree_height <= 1) {
+		return FALSE;
+	}
+	if (trx->lra_space_id == space && trx->lra_page_no == page_no) {
+		/* the cursor is on the same page as the last time this
+		function was called. */
+		return FALSE;
+	}
+
+	/* Set the last page number to page_no only if we are scanning the
+	same table. */
+	if (trx->lra_space_id == space) {
+		trx->lra_page_no = page_no;
+	}
+
+	/* In order not to prefetch extraneously, we do not issue prefetches
+	until the scan processes lra_n_pages pages. This may cause misses if
+	there are too many splits/merges going on but in such a case it
+	would be hard to guess which pages to prefetch anyway
+	because it is equivalent to guessing which pages would split
+	(or merge). */
+	if (trx->lra_space_id == space
+	    && ++trx->lra_n_pages_since <= trx->lra_n_pages) {
+		if (!row_lra_is_prefetched(trx, page_no)) {
+			srv_stats.n_logical_read_ahead_misses.add(1);
+		}
+		return FALSE;
+	}
+	rec = page_rec_get_next(page_get_infimum_rec(
+				buf_block_get_frame(block)));
+	if (!rec || page_rec_is_supremum(rec)) {
+		/* Do not start prefetching because we can not get the
+		parent page of an empty page */
+		trx->lra_page_no = 0;
+		return FALSE;
+	}
+	tablespace_version = fil_space_get_version(space);
+
+	if (!*heap_ptr) {
+		*heap_ptr = mem_heap_create(100);
+	}
+	heap = *heap_ptr;
+	tuple = dict_index_build_node_ptr(index, rec, 0, heap, 1);
+	trx->lra_n_pages_since = 0;
+
+	btr_pcur_store_position(pcur, mtr);
+	mtr_commit(mtr);
+#ifdef UNIV_DEBUG
+	if (row_lra_test && trx->lra_space_id == space) {
+		row_lra_test = FALSE;
+		os_thread_sleep(1000000);
+	}
+#endif
+	mtr_start(mtr);
+
+	if (UNIV_LIKELY(trx->lra_space_id == space)) {
+#ifdef UNIV_DEBUG
+		memset(trx->lra_sort_arr, 0,
+		       2 * trx->lra_n_pages * sizeof(ulint));
+#endif
+		btr_pcur_restore_position_func(
+			BTR_SEARCH_LEAF, trx->lra_cur, 1,
+			__FILE__, __LINE__, mtr);
+		row_read_ahead_logical_low(
+			trx->lra_ht, &num_prefetched,
+			trx->lra_sort_arr, index, mtr,
+			offsets, heap, trx);
+		if (trx->lra_ht == trx->lra_ht1) {
+			trx->lra_ht = trx->lra_ht2;
+		} else {
+			trx->lra_ht = trx->lra_ht1;
+		}
+	} else {
+		/* The transaction started to scan a new table, set
+		the values for lra_space_id and lra_n_pages based on the
+		new table */
+		trx_lra_reset(trx,
+			      trx->lra_size,
+			      trx->lra_n_node_recs_before_sleep,
+			      trx->lra_sleep);
+		trx->lra_space_id = space;
+		trx->lra_n_pages = (trx->lra_size << 20L)
+				   / (zip_size ? zip_size : UNIV_PAGE_SIZE);
+		trx->lra_page_no = page_no;
+		mtr_s_lock(dict_index_get_lock(index), mtr);
+		/* Get root page to get the B-tree depth */
+		root_page_no = dict_index_get_page(index);
+		root_block = buf_page_get_gen(space, zip_size, root_page_no,
+				              RW_NO_LATCH, NULL, BUF_GET,
+					      __FILE__, __LINE__, mtr);
+		trx->lra_tree_height = btr_page_get_level(
+					buf_block_get_frame(root_block),
+					mtr) + 1;
+		if (trx->lra_tree_height > 1) {
+#ifdef UNIV_DEBUG
+			memset(trx->lra_sort_arr, 0,
+			       2 * trx->lra_n_pages * sizeof(ulint));
+#endif
+			mtr_commit(mtr);
+			mtr_start(mtr);
+			btr_pcur_open_low(index, 1, tuple, PAGE_CUR_LE,
+					  BTR_SEARCH_LEAF, trx->lra_cur,
+					  __FILE__, __LINE__, mtr);
+			row_read_ahead_logical_low(
+				trx->lra_ht1, &num_prefetched,
+				trx->lra_sort_arr, index, mtr,
+				offsets, heap, trx);
+			row_read_ahead_logical_low(
+				trx->lra_ht2, &num_prefetched,
+				&trx->lra_sort_arr[num_prefetched], index, mtr,
+				offsets, heap, trx);
+		}
+		trx->lra_ht = trx->lra_ht1;
+	}
+	if (trx->lra_tree_height > 1)
+		btr_pcur_store_position(trx->lra_cur, mtr);
+	mtr_commit(mtr);
+	if (num_prefetched) {
+		/* We sort the page numbers before issuing read requests for two
+		reasons:
+		1- The block layer in linux kernel currently sorts the read
+		requests and merges them but there is a possibility that
+		this algorithm does not detect the sequential read and
+		coalesce the iops.
+		2- Even if the block layer algorithm is perfect, the
+		asynchrounous read array size may be small in which case we
+		the read requests will have a lower chance of being
+		coalesced by the block layer.
+
+		Sorting is cheap in comparison to the iops that are about to
+		be done so we always sort. */
+		std::sort(trx->lra_sort_arr, trx->lra_sort_arr + num_prefetched);
+		/* TODO(nizamordulu): Here we call buf_read_page_low() which
+		acquires the related buffer pool shard lock and checks if the
+		page is in that shard for each page. This could be made more
+		efficient if we checked for all pages at once or batched the
+		check for multiple pages after acquiring the related latch. */
+		for (i = 0; i < num_prefetched; ++i) {
+			num_read_requests += buf_read_page_low(
+				&err, FALSE,
+				BUF_READ_ANY_PAGE | OS_AIO_SIMULATED_WAKE_LATER,
+				space, zip_size, FALSE, tablespace_version,
+				trx->lra_sort_arr[i], trx, TRUE);
+		}
+#ifdef LINUX_NATIVE_AIO
+		os_aio_linux_dispatch_read_array_submit();
+#endif
+		srv_stats.n_logical_read_ahead_prefetched.add(
+							num_read_requests);
+		srv_stats.n_logical_read_ahead_in_buf_pool.add(
+					num_prefetched - num_read_requests);
+	}
+	mtr_start(mtr);
+	return sel_restore_position_for_mysql(&same_user_rec, BTR_SEARCH_LEAF,
+					      pcur, TRUE, mtr);
+}
+
 /********************************************************************//**
 Searches for rows in the database. This is used in the interface to
 MySQL. This function opens a cursor, and also implements fetch next
@@ -5014,6 +5328,11 @@
 	}
 
 	if (moves_up) {
+		if (trx
+		    && row_read_ahead_logical(
+				pcur, index, &mtr, offsets, &heap, trx)) {
+			goto rec_loop;
+		}
 		if (UNIV_UNLIKELY(!btr_pcur_move_to_next(pcur, &mtr))) {
 not_moved:
 			btr_pcur_store_position(pcur, &mtr);
 
=== modified file 'storage/innobase/srv/srv0srv.cc'
--- storage/innobase/srv/srv0srv.cc	2014-03-03 17:51:33 +0000
+++ storage/innobase/srv/srv0srv.cc	2014-04-23 10:58:56 +0000
@@ -1863,6 +1863,15 @@
 	}
 #endif /* UNIV_DEBUG */
 
+	export_vars.innodb_buffered_aio_submitted =
+		srv_stats.n_aio_submitted;
+	export_vars.innodb_logical_read_ahead_misses =
+		srv_stats.n_logical_read_ahead_misses;
+	export_vars.innodb_logical_read_ahead_prefetched =
+		srv_stats.n_logical_read_ahead_prefetched;
+	export_vars.innodb_logical_read_ahead_in_buf_pool =
+		srv_stats.n_logical_read_ahead_in_buf_pool;
+
 	mutex_exit(&srv_innodb_monitor_mutex);
 }
 
 
=== modified file 'storage/innobase/trx/trx0trx.cc'
--- storage/innobase/trx/trx0trx.cc	2014-02-17 11:12:40 +0000
+++ storage/innobase/trx/trx0trx.cc	2014-04-23 10:58:56 +0000
@@ -48,6 +48,7 @@
 #include "ha_prototypes.h"
 #include "srv0mon.h"
 #include "ut0vec.h"
+#include "btr0pcur.h"
 
 #include<set>
 
@@ -212,6 +213,121 @@
 	trx_sys->descr_n_used--;
 }
 
+/*************************************************************//**
+Creates or frees data structures related to logical-read-ahead.
+based on the value of lra_size. */
+UNIV_INTERN
+void
+trx_lra_reset(
+	trx_t* trx, /*!< in: transaction */
+	ulint lra_size, /*!< in: lra_size in MB.
+				       If 0, the fields that are releated
+				       to logical-read-ahead will be free'd
+				       if they were initialized. */
+	ulint lra_n_node_recs_before_sleep,
+					/*!< in: lra_n_node_recs_before_sleep
+					is the number of node pointer records
+					traversed while holding the index lock
+					before releasing the index lock and
+					sleeping for a short period of time so
+					that the other threads get a chance to
+					x-latch the index lock. */
+	ulint lra_sleep)		/* lra_sleep is the sleep time in
+					milliseconds. */
+{
+#ifndef TARGET_OS_LINUX
+	if (lra_size) {
+		ib_logf(IB_LOG_LEVEL_WARN,
+			"Logical read ahead is supported only on linux.");
+		lra_size = 0;
+	}
+#else /* TARGET_OS_LINUX */
+	if (!srv_use_native_aio && lra_size) {
+		ib_logf(IB_LOG_LEVEL_WARN,
+			"In order to use logical read ahead please enable "
+			"native aio by setting innodb_use_native_aio=1 in "
+			"my.cnf and restarting the server.");
+		lra_size = 0;
+	}
+#endif /* TARGET_OS_LINUX */
+	trx->lra_size = lra_size;
+	trx->lra_space_id = 0;
+	trx->lra_n_pages = 0;
+	trx->lra_n_pages_since = 0;
+	trx->lra_page_no = 0;
+	trx->lra_n_node_recs_before_sleep = lra_n_node_recs_before_sleep;
+	trx->lra_sleep = lra_sleep;
+	trx->lra_tree_height = 0;
+	if (lra_size) {
+		ulint n_pages_max =
+			(lra_size << 20L) / UNIV_ZIP_SIZE_MIN;
+		ulint mem = n_pages_max * (2 * sizeof(ulint)
+			                   + 2 * sizeof(page_no_holder_t))
+			    + sizeof(btr_pcur_t);
+		if (trx->lra_ht) {
+			ut_a(trx->lra_ht1);
+			ut_a(trx->lra_ht2);
+			ut_a(trx->lra_sort_arr);
+			ut_a(trx->lra_cur);
+			hash_table_clear(trx->lra_ht1);
+			hash_table_clear(trx->lra_ht2);
+			trx->lra_ht = trx->lra_ht1;
+#ifdef UNIV_DEBUG
+			/* following resets lra_sort_arr,
+			 * lra_arr1, lra_arr2, and lra_cursor.
+			 */
+			memset(trx->lra_sort_arr, 0, mem);
+#endif
+			btr_pcur_init(trx->lra_cur);
+		} else {
+			byte* alloc;
+			ut_a(!trx->lra_ht1);
+			ut_a(!trx->lra_ht2);
+			ut_a(!trx->lra_sort_arr);
+			trx->lra_ht1 = hash_create(16384);
+			trx->lra_ht2 = hash_create(16384);
+			trx->lra_ht = trx->lra_ht1;
+			alloc = (byte*)ut_malloc(mem);
+#ifdef UNIV_DEBUG
+			memset(alloc, 0, mem);
+#endif
+			trx->lra_sort_arr = (ulint*)alloc;
+			alloc += 2 * sizeof(ulint) * n_pages_max;
+			trx->lra_arr1 = (page_no_holder_t*) alloc;
+			alloc +=  sizeof(page_no_holder_t) * n_pages_max;
+			trx->lra_arr2 = (page_no_holder_t*) alloc;
+			alloc +=  sizeof(page_no_holder_t) * n_pages_max;
+			trx->lra_cur = (btr_pcur_t*) alloc;
+			btr_pcur_init(trx->lra_cur);
+
+		}
+	} else {
+		if (trx->lra_ht) {
+			ut_a(trx->lra_ht1);
+			ut_a(trx->lra_ht2);
+			ut_a(trx->lra_sort_arr);
+			hash_table_free(trx->lra_ht1);
+			hash_table_free(trx->lra_ht2);
+			btr_pcur_close(trx->lra_cur);
+			ut_free(trx->lra_sort_arr);
+			trx->lra_sort_arr = NULL;
+			trx->lra_ht = NULL;
+			trx->lra_ht1 = NULL;
+			trx->lra_ht2 = NULL;
+			trx->lra_arr1 = NULL;
+			trx->lra_arr2 = NULL;
+			trx->lra_cur = NULL;
+		} else {
+			ut_a(!trx->lra_ht1);
+			ut_a(!trx->lra_ht2);
+			ut_a(!trx->lra_sort_arr);
+			ut_a(!trx->lra_cur);
+			ut_a(!trx->lra_arr1);
+			ut_a(!trx->lra_arr2);
+		}
+	}
+}
+
 /****************************************************************//**
 Creates and initializes a transaction object. It must be explicitly
 started with trx_start_if_not_started() before using it. The default
@@ -294,6 +410,12 @@
 	trx->lock.table_locks = ib_vector_create(
 		heap_alloc, sizeof(void**), 32);
 
+	trx->lra_ht = NULL;
+	trx->lra_cur = NULL;
+	trx->lra_ht1 = NULL;
+	trx->lra_ht2 = NULL;
+	trx_lra_reset(trx, 0, 0, 0);
+
 	return(trx);
 }
 
@@ -388,6 +510,7 @@
 	}
 
 	mutex_free(&trx->mutex);
+	trx_lra_reset(trx, 0, 0, 0);
 
 	read_view_free(trx->prebuilt_view);