Merge lp:~akopytov/percona-server/bug1131189 into lp:percona-server/5.5

[Alexey Kopytov]

Bug #1131189: Remove trx_list scan from read_view_open_now()

The patch introduces a concept if "trx descriptors" which is a global
ordered array containing IDs of transactions in either TRX_ACTIVE or
TRX_PREPARED state. It allows to replace the trx_list scan in
read_view_open_now() and read_cursor_view_create_for_mysql() with a
binary search on the descriptors array and two memcpy()s.

Purposes of using the ID array of transactions is certain states:

- we remove dependencies on trx_struct size and cache locality of those
  structures in memory
- per-node copying is replaced with memcpy()
- we don't have to check trx_struct fields for each trx_list node, such
  as ID, state and no.

Since there is no transaction serialization numbers (i.e. trx->no) in the
descriptors array, this check was replaced by keeping a separate,
trx->no ordered list (trx_sys->trx_serial_list). Getting the current
minimum for the current read view is then simply a matter of getting
trx->no of the first element from trx_serial_list.

Costs for maintaining the descriptors array:

- whenever a transaction is started, we need to insert its ID into the
  descriptors array. This in most cases is very cheap, as transactions
  are started with increasing IDs, so we can just add it as the last
  element in the descriptors array. In the unlikely case when this
  invariant does not hold (which is impossible with the current code),
  we look for the right slot using a linear search. A binary search
  would work better for cases when the right slot is far away from the
  array end, but again, this is defensive against future code changes
  that could possibly lead to breaking the ascending order in which new
  IDs are added, and we hope that it will be "mostly ascending", so a
  linear search should be faster.

- whenever a transaction is committed, we need to remove its ID from the
  descriptors array. Which is performed by ut_memmove() on the array. We
  could theoretically allow unused array slots but that would: 1)
  increase the size of descriptors by the 'used/unused' flag; 2) make
  using memcpy() in read_view_open_now() impossible, as we would also
  have to filter unused slots and 3) make the operation of adding a new
  descriptor scan the array for an unused slot

- when removing a transaction ID from the descriptors array, we first
  have to find the corresponding slot with a binary search. We could
  avoid this by maintaining the "trx -> descriptors slot" association,
  but since the array may be resized or reorder on insertion, keeping
  this association is not practically feasible

All of the above is performed under the kernel_mutex. But benchmarks
prove this overhead is negligible as compared to the list scan in
read_view_open_now().

The initial size of the descriptors array is 1000 slots (i.e. 8000
bytes). It is resized whenever we need more descriptors.

The patch also renames 'conc_state' to 'state' in trx_struct. The patch
would be much smaller without this change, but the purpose is to make
sure we notice any code changes around transaction states, as it is
critical for correct descriptors array maintenance. I tried implementing
a getter/setter pair of functions for trx state, it the patch got even
more messy, because trx state may be changed with kernel_mutex either
locked or unlocked, whereas we can only manipulate the descriptors array
with the mutex locked.

[Alexey Kopytov (akopytov)]

http://jenkins.percona.com/view/PS%205.5/job/percona-server-5.5-param/685/

[Laurynas Biveinis (laurynas-biveinis)]

It's a good patch, just couple of relatively small questions and comments:

   - The only thing I'd look into doing differently would be not
     doing linear search at all in trx_reserve_descriptor(), and just
     adding a debug assertion that the array is sorted after the
     insert (which would be just the comparison with the n-1th
     element). Would save a dozen code bytes in a presumably very hot
     code path.

   - I must be missing something here, but why there is padding
     inserted between descr_n_max and descr_n_used in trx_sys? It
     seems that these fields are accessed at close times.

   - File read0read.h adds the include of trx0sys.h. But the diff of
     read0read.h does not show anything new external used there.
     Rather, it is read0read.ic which starts using
     trx_find_descriptor(), thus the trx0sys.h include should be
     moved to read0read.ic.

   - Spurious whitespace changes in diff lines 381, 382, 645,
     1155-1157, 1220.

   - Why does trx_reserve_decriptor() loop: n_used++; while (n_used >
     n_max) n_max *= 2 ? A second iteration of this loop can never
     happen, it looks maybe a bit too defensive for me,
     and this is next to a very hot code path, isn't it? Since there
     is if (n_used > n_max) just above, one unconditional n_max *= 2;
     should be enough.

   - Why does trx_free_prepared() free its view now?

review: Needs Information

[Alexey Kopytov (akopytov)]

Hi Laurynas,

Thanks for the review.

On Mon, 25 Mar 2013 08:25:24 -0000, Laurynas Biveinis wrote:
> Review: Needs Information
>
> It's a good patch, just couple of relatively small questions and comments:
>
> - The only thing I'd look into doing differently would be not
> doing linear search at all in trx_reserve_descriptor(), and just
> adding a debug assertion that the array is sorted after the
> insert (which would be just the comparison with the n-1th
> element). Would save a dozen code bytes in a presumably very hot
> code path.
>

I'd like to keep that code. Assuming that invariant will always hold
and enforcing it with a debug-only assertion looks a bit fragile to me.

> - I must be missing something here, but why there is padding
> inserted between descr_n_max and descr_n_used in trx_sys? It
> seems that these fields are accessed at close times.
>

They are accessed at close times, but not always modified at close
times. So by splitting them into separate cache lines we avoid false
sharing in some (actually most) cases.

> - File read0read.h adds the include of trx0sys.h. But the diff of
> read0read.h does not show anything new external used there.
> Rather, it is read0read.ic which starts using
> trx_find_descriptor(), thus the trx0sys.h include should be
> moved to read0read.ic.
>

It was originally in read0read.ic, but that was breaking debug builds
due to some tricky inter-dependency between read0read.h, read0read.ic
and something else. Details elude me now, but my conclusion was that
adding that include to .h was the only clean way to resolve them.

> - Spurious whitespace changes in diff lines 381, 382, 645,
> 1155-1157, 1220.
>

Fixed those and a few other ones.

> - Why does trx_reserve_decriptor() loop: n_used++; while (n_used >
> n_max) n_max *= 2 ? A second iteration of this loop can never
> happen, it looks maybe a bit too defensive for me,
> and this is next to a very hot code path, isn't it? Since there
> is if (n_used > n_max) just above, one unconditional n_max *= 2;
> should be enough.
>

Probably remnants from previous implementation iterations. Fixed.

> - Why does trx_free_prepared() free its view now?
>

Because we are going to free trx a few lines later. Technically it's a
follow-up to the fix for bug #1131187 to avoid a memory leak, but they
both were originally in the same tree (with multiple revisions per
each), and it was tricky to figure what belongs to what. There's
actually another change that logically would belong to that fix.

[Alexey Kopytov (akopytov)]

Will rebase on GCA branches and resubmit along with a 5.6 MP, as porting this to 5.6 will be rather non-trivial.

review: Needs Resubmitting

[Alexey Kopytov (akopytov)]

Actually, I will not, because this depends on the already merged fix for bug #1131187 which will be missing from the GCA 5.5 branch. Which means waiting for a proper 5.6 branch will be the only way to proceed with porting.

[Laurynas Biveinis (laurynas-biveinis)]

review: Approve

=== modified file 'Percona-Server/storage/innobase/handler/ha_innodb.cc'
--- Percona-Server/storage/innobase/handler/ha_innodb.cc	2013-03-23 01:08:22 +0000
+++ Percona-Server/storage/innobase/handler/ha_innodb.cc	2013-03-25 10:05:33 +0000
@@ -1910,7 +1910,7 @@
 /*===========*/
 	trx_t*	trx)	/* in: transaction */
 {
-	return(trx->conc_state != TRX_NOT_STARTED);
+	return(trx->state != TRX_NOT_STARTED);
 }
 
 /*********************************************************************//**
@@ -9046,7 +9046,7 @@
 
 				prebuilt->trx->op_info = "confirming rows of SYS_STATS to store statistics";
 
-				ut_a(prebuilt->trx->conc_state == TRX_NOT_STARTED);
+				ut_a(!trx_is_started(prebuilt->trx));
 
 				for (index = dict_table_get_first_index(ib_table);
 				     index != NULL;
@@ -9059,7 +9059,7 @@
 					innobase_commit_low(prebuilt->trx);
 				}
 
-				ut_a(prebuilt->trx->conc_state == TRX_NOT_STARTED);
+				ut_a(!trx_is_started(prebuilt->trx));
 			}
 
 			prebuilt->trx->op_info = "updating table statistics";

=== modified file 'Percona-Server/storage/innobase/include/read0read.h'
--- Percona-Server/storage/innobase/include/read0read.h	2013-03-15 09:55:17 +0000
+++ Percona-Server/storage/innobase/include/read0read.h	2013-03-25 10:05:33 +0000
@@ -32,6 +32,7 @@
 #include "ut0byte.h"
 #include "ut0lst.h"
 #include "trx0trx.h"
+#include "trx0sys.h"
 #include "read0types.h"
 
 /*********************************************************************//**
@@ -44,8 +45,11 @@
 /*===============*/
 	trx_id_t	cr_trx_id,	/*!< in: trx_id of creating
 					transaction, or 0 used in purge */
-	read_view_t*	view);		/*!< in: pre-allocated view array or
-					NULL if a new one needs to be created */
+	read_view_t*	view,		/*!< in: current read view or NULL if it
+					doesn't exist yet */
+	ibool		exclude_self);	/*!< in: TRUE, if cr_trx_id should be
+					excluded from the resulting view */
+
 /*********************************************************************//**
 Makes a copy of the oldest existing read view, or opens a new. The view
 must be closed with ..._close.
@@ -150,19 +154,20 @@
 				are strictly smaller (<) than this value.
 				In other words,
 				this is the "low water mark". */
-	ulint		n_trx_ids;
+	ulint		n_descr;
 				/*!< Number of cells in the trx_ids array */
-	ulint		max_trx_ids;
+	ulint		max_descr;
 				/*!< Maximum number of cells in the trx_ids
 				array */
-	trx_id_t*	trx_ids;/*!< Additional trx ids which the read should
-				not see: typically, these are the active
+	trx_id_t*	descriptors;
+				/*!< Array of trx descriptors which the read
+				should not see: typically, these are the active
 				transactions at the time when the read is
 				serialized, except the reading transaction
 				itself; the trx ids in this array are in a
 				descending order. These trx_ids should be
-				between the "low" and "high" water marks,
-				that is, up_limit_id and low_limit_id. */
+				between the "low" and "high" water marks, that
+				is, up_limit_id and low_limit_id. */
 	trx_id_t	creator_trx_id;
 				/*!< trx id of creating transaction, or
 				0 used in purge */

=== modified file 'Percona-Server/storage/innobase/include/read0read.ic'
--- Percona-Server/storage/innobase/include/read0read.ic	2010-07-21 14:22:29 +0000
+++ Percona-Server/storage/innobase/include/read0read.ic	2013-03-25 10:05:33 +0000
@@ -25,6 +25,11 @@
 
 /*********************************************************************//**
 Gets the nth trx id in a read view.
+
+Upstream code stores array of trx_ids in the descending order. Percona Server
+keeps it in the ascending order for performance reasons. Let us keep the
+semantics.
+
 @return	trx id */
 UNIV_INLINE
 trx_id_t
@@ -33,13 +38,17 @@
 	const read_view_t*	view,	/*!< in: read view */
 	ulint			n)	/*!< in: position */
 {
-	ut_ad(n < view->n_trx_ids);
+	ut_ad(n < view->n_descr);
 
-	return(*(view->trx_ids + n));
+	return(view->descriptors[view->n_descr - 1 - n]);
 }
 
 /*********************************************************************//**
-Sets the nth trx id in a read view. */
+Sets the nth trx id in a read view.
+
+Upstream code stores array of trx_ids in the descending order. Percona Server
+keeps it in the ascending order for performance reasons. Let us keep the
+semantics. */
 UNIV_INLINE
 void
 read_view_set_nth_trx_id(
@@ -48,9 +57,9 @@
 	ulint		n,	/*!< in: position */
 	trx_id_t	trx_id)	/*!< in: trx id to set */
 {
-	ut_ad(n < view->n_trx_ids);
+	ut_ad(n < view->n_descr);
 
-	*(view->trx_ids + n) = trx_id;
+	view->descriptors[view->n_descr - 1 - n] = trx_id;
 }
 
 /*********************************************************************//**
@@ -63,9 +72,6 @@
 	const read_view_t*	view,	/*!< in: read view */
 	trx_id_t		trx_id)	/*!< in: trx id */
 {
-	ulint	n_ids;
-	ulint	i;
-
 	if (trx_id < view->up_limit_id) {
 
 		return(TRUE);
@@ -76,21 +82,8 @@
 		return(FALSE);
 	}
 
-	/* We go through the trx ids in the array smallest first: this order
-	may save CPU time, because if there was a very long running
-	transaction in the trx id array, its trx id is looked at first, and
-	the first two comparisons may well decide the visibility of trx_id. */
-
-	n_ids = view->n_trx_ids;
-
-	for (i = 0; i < n_ids; i++) {
-		trx_id_t	view_trx_id
-			= read_view_get_nth_trx_id(view, n_ids - i - 1);
-
-		if (trx_id <= view_trx_id) {
-			return(trx_id != view_trx_id);
-		}
-	}
-
-	return(TRUE);
+	/* Do a binary search over this view's descriptors array */
+
+	return(trx_find_descriptor(view->descriptors, view->n_descr,
+				   trx_id) == NULL);
 }

=== modified file 'Percona-Server/storage/innobase/include/trx0sys.h'
--- Percona-Server/storage/innobase/include/trx0sys.h	2012-10-22 00:07:03 +0000
+++ Percona-Server/storage/innobase/include/trx0sys.h	2013-03-25 10:05:33 +0000
@@ -249,6 +249,17 @@
 trx_sys_get_new_trx_id(void);
 /*========================*/
 
+/*************************************************************//**
+Find a slot for a given trx ID in a descriptors array.
+@return: slot pointer */
+UNIV_INLINE
+trx_id_t*
+trx_find_descriptor(
+/*================*/
+	const trx_id_t*	descriptors,	/*!< in: descriptors array */
+	ulint		n_descr,	/*!< in: array size */
+	trx_id_t	trx_id);	/*!< in: trx pointer */
+
 #ifdef UNIV_DEBUG
 /* Flag to control TRX_RSEG_N_SLOTS behavior debugging. */
 extern uint			trx_rseg_n_slots_debug;
@@ -633,6 +644,8 @@
 	 | TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_LOW)
 /* @} */
 
+#define TRX_DESCR_ARRAY_INITIAL_SIZE 	1000
+
 #ifndef UNIV_HOTBACKUP
 /** Doublewrite control struct */
 struct trx_doublewrite_struct{
@@ -660,16 +673,41 @@
 	trx_id_t	max_trx_id;	/*!< The smallest number not yet
 					assigned as a transaction id or
 					transaction number */
+	char		pad1[64];	/*!< Ensure max_trx_id does not share
+					cache line with other fields. */
+	trx_id_t*	descriptors;	/*!< Array of trx descriptors */
+	ulint		descr_n_max;	/*!< The current size of the descriptors
+					array. */
+	char		pad2[64];	/*!< Ensure static descriptor fields
+					do not share cache lines with
+					descr_n_used */
+	ulint		descr_n_used;	/*!< Number of used elements in the
+					descriptors array. */
+	char		pad3[64];	/*!< Ensure descriptors do not share
+					cache line with other fields */
 	UT_LIST_BASE_NODE_T(trx_t) trx_list;
 					/*!< List of active and committed in
 					memory transactions, sorted on trx id,
 					biggest first */
+	char		pad4[64];	/*!< Ensure list base nodes do not
+					share cache line with other fields */
 	UT_LIST_BASE_NODE_T(trx_t) mysql_trx_list;
 					/*!< List of transactions created
 					for MySQL */
+	char		pad5[64];	/*!< Ensure list base nodes do not
+					share cache line with other fields */
+	UT_LIST_BASE_NODE_T(trx_t) trx_serial_list;
+					/*!< trx->no ordered List of
+					transactions in either TRX_PREPARED or
+					TRX_ACTIVE which have already been
+					assigned a serialization number */
+	char		pad6[64];	/*!< Ensure trx_serial_list does not
+					share cache line with other fields */
 	UT_LIST_BASE_NODE_T(trx_rseg_t) rseg_list;
 					/*!< List of rollback segment
 					objects */
+	char		pad7[64];	/*!< Ensure list base nodes do not
+					share cache line with other fields */
 	trx_rseg_t*	latest_rseg;	/*!< Latest rollback segment in the
 					round-robin assignment of rollback
 					segments to transactions */

=== modified file 'Percona-Server/storage/innobase/include/trx0sys.ic'
--- Percona-Server/storage/innobase/include/trx0sys.ic	2012-05-10 07:49:14 +0000
+++ Percona-Server/storage/innobase/include/trx0sys.ic	2013-03-25 10:05:33 +0000
@@ -367,28 +367,11 @@
 /*==========*/
 	trx_id_t	trx_id)	/*!< in: trx id of the transaction */
 {
-	trx_t*	trx;
-
 	ut_ad(mutex_own(&(kernel_mutex)));
 
-	if (trx_id < trx_list_get_min_trx_id()) {
-
-		return(FALSE);
-	}
-
-	if (UNIV_UNLIKELY(trx_id >= trx_sys->max_trx_id)) {
-
-		/* There must be corruption: we return TRUE because this
-		function is only called by lock_clust_rec_some_has_impl()
-		and row_vers_impl_x_locked_off_kernel() and they have
-		diagnostic prints in this case */
-
-		return(TRUE);
-	}
-
-	trx = trx_get_on_id(trx_id);
-	if (trx && (trx->conc_state == TRX_ACTIVE
-		    || trx->conc_state == TRX_PREPARED)) {
+	if (trx_find_descriptor(trx_sys->descriptors,
+				trx_sys->descr_n_used,
+				trx_id)) {
 
 		return(TRUE);
 	}
@@ -425,4 +408,27 @@
 	return(id);
 }
 
+
+/*************************************************************//**
+Find a slot for a given trx ID in a descriptors array.
+@return: slot pointer */
+UNIV_INLINE
+trx_id_t*
+trx_find_descriptor(
+/*================*/
+	const trx_id_t*	descriptors,	/*!< in: descriptors array */
+	ulint		n_descr,	/*!< in: array size */
+	trx_id_t	trx_id)		/*!< in: trx pointer */
+{
+	ut_ad(descriptors != trx_sys->descriptors ||
+	      mutex_own(&kernel_mutex));
+
+	if (UNIV_UNLIKELY(n_descr == 0)) {
+
+		return(NULL);
+	}
+
+	return((trx_id_t *) bsearch(&trx_id, descriptors, n_descr,
+				    sizeof(trx_id_t), trx_descr_cmp));
+}
 #endif /* !UNIV_HOTBACKUP */

=== modified file 'Percona-Server/storage/innobase/include/trx0trx.h'
--- Percona-Server/storage/innobase/include/trx0trx.h	2013-03-15 09:55:17 +0000
+++ Percona-Server/storage/innobase/include/trx0trx.h	2013-03-25 10:05:33 +0000
@@ -447,6 +447,23 @@
 /*==================*/
 	const trx_t*	trx);	/*!< in: transaction */
 
+/*************************************************************//**
+Callback function for trx_find_descriptor() to compare trx IDs. */
+UNIV_INTERN
+int
+trx_descr_cmp(
+/*==========*/
+	const void *a,	/*!< in: pointer to first comparison argument */
+	const void *b);	/*!< in: pointer to second comparison argument */
+
+/*************************************************************//**
+Release a slot for a given trx in the global descriptors array. */
+UNIV_INTERN
+void
+trx_release_descriptor(
+/*===================*/
+	trx_t* trx);	/*!< in: trx pointer */
+
 /* Signal to a transaction */
 struct trx_sig_struct{
 	unsigned	type:3;		/*!< signal type */
@@ -477,10 +494,18 @@
 	const char*	op_info;	/*!< English text describing the
 					current operation, or an empty
 					string */
-	ulint		conc_state;	/*!< state of the trx from the point
-					of view of concurrency control:
-					TRX_ACTIVE, TRX_COMMITTED_IN_MEMORY,
-					... */
+	ulint		state;		/*!< state of the trx from the point of
+					view of concurrency control: TRX_ACTIVE,
+					TRX_COMMITTED_IN_MEMORY, ...  This was
+					called 'conc_state' in the upstream and
+					has been renamed in Percona Server,
+					because changing it's value to/from
+					either TRX_ACTIVE or TRX_PREPARED
+					requires calling
+					trx_reserve_descriptor() /
+					trx_release_descriptor(). Different name
+					ensures we notice any new code changing
+					the state. */
 	/*------------------------------*/
 	/* MySQL has a transaction coordinator to coordinate two phase
        	commit between multiple storage engines and the binary log. When
@@ -495,6 +520,9 @@
 					also be set to 1. This is used in the
 					XA code */
 	unsigned	called_commit_ordered:1;/* 1 if innobase_commit_ordered has run. */
+	unsigned	is_in_trx_serial_list:1;
+					/* Set when transaction is in the
+					trx_serial_list */
 	/*------------------------------*/
 	ulint		isolation_level;/* TRX_ISO_REPEATABLE_READ, ... */
 	ulint		check_foreigns;	/* normally TRUE, but if the user
@@ -628,6 +656,9 @@
 	UT_LIST_NODE_T(trx_t)
 			mysql_trx_list;	/*!< list of transactions created for
 					MySQL */
+	UT_LIST_NODE_T(trx_t)
+			trx_serial_list;/*!< list node for
+					trx_sys->trx_serial_list */
 	/*------------------------------*/
 	ulint		error_state;	/*!< 0 if no error, otherwise error
 					number; NOTE That ONLY the thread

=== modified file 'Percona-Server/storage/innobase/include/trx0trx.ic'
--- Percona-Server/storage/innobase/include/trx0trx.ic	2010-07-21 14:22:29 +0000
+++ Percona-Server/storage/innobase/include/trx0trx.ic	2013-03-25 10:05:33 +0000
@@ -31,9 +31,9 @@
 /*=====================*/
 	trx_t*	trx)	/*!< in: transaction */
 {
-	ut_ad(trx->conc_state != TRX_COMMITTED_IN_MEMORY);
+	ut_ad(trx->state != TRX_COMMITTED_IN_MEMORY);
 
-	if (trx->conc_state == TRX_NOT_STARTED) {
+	if (trx->state == TRX_NOT_STARTED) {
 
 		trx_start(trx, ULINT_UNDEFINED);
 	}
@@ -48,9 +48,9 @@
 /*=========================*/
 	trx_t*	trx)	/*!< in: transaction */
 {
-	ut_ad(trx->conc_state != TRX_COMMITTED_IN_MEMORY);
+	ut_ad(trx->state != TRX_COMMITTED_IN_MEMORY);
 
-	if (trx->conc_state == TRX_NOT_STARTED) {
+	if (trx->state == TRX_NOT_STARTED) {
 
 		trx_start_low(trx, ULINT_UNDEFINED);
 	}

=== modified file 'Percona-Server/storage/innobase/lock/lock0lock.c'
--- Percona-Server/storage/innobase/lock/lock0lock.c	2013-03-05 12:16:18 +0000
+++ Percona-Server/storage/innobase/lock/lock0lock.c	2013-03-25 10:05:33 +0000
@@ -4652,7 +4652,7 @@
 	trx = UT_LIST_GET_FIRST(trx_sys->mysql_trx_list);
 
 	while (trx) {
-		if (trx->conc_state == TRX_NOT_STARTED) {
+		if (trx->state == TRX_NOT_STARTED) {
 			fputs("---", file);
 			trx_print(file, trx, 600);
 		}
@@ -4820,9 +4820,9 @@
 	lock = UT_LIST_GET_FIRST(table->locks);
 
 	while (lock) {
-		ut_a(((lock->trx)->conc_state == TRX_ACTIVE)
-		     || ((lock->trx)->conc_state == TRX_PREPARED)
-		     || ((lock->trx)->conc_state == TRX_COMMITTED_IN_MEMORY));
+		ut_a(((lock->trx)->state == TRX_ACTIVE)
+		     || ((lock->trx)->state == TRX_PREPARED)
+		     || ((lock->trx)->state == TRX_COMMITTED_IN_MEMORY));
 
 		if (!lock_get_wait(lock)) {
 
@@ -4870,7 +4870,7 @@
 		lock = lock_rec_get_first(block, heap_no);
 
 		while (lock) {
-			switch(lock->trx->conc_state) {
+			switch(lock->trx->state) {
 			case TRX_ACTIVE:
 			case TRX_PREPARED:
 			case TRX_COMMITTED_IN_MEMORY:
@@ -4957,9 +4957,9 @@
 	lock = lock_rec_get_first(block, heap_no);
 
 	while (lock) {
-		ut_a(lock->trx->conc_state == TRX_ACTIVE
-		     || lock->trx->conc_state == TRX_PREPARED
-		     || lock->trx->conc_state == TRX_COMMITTED_IN_MEMORY);
+		ut_a(lock->trx->state == TRX_ACTIVE
+		     || lock->trx->state == TRX_PREPARED
+		     || lock->trx->state == TRX_COMMITTED_IN_MEMORY);
 		ut_a(trx_in_trx_list(lock->trx));
 
 		if (index) {
@@ -5036,9 +5036,9 @@
 	}
 
 	ut_a(trx_in_trx_list(lock->trx));
-	ut_a(lock->trx->conc_state == TRX_ACTIVE
-	     || lock->trx->conc_state == TRX_PREPARED
-	     || lock->trx->conc_state == TRX_COMMITTED_IN_MEMORY);
+	ut_a(lock->trx->state == TRX_ACTIVE
+	     || lock->trx->state == TRX_PREPARED
+	     || lock->trx->state == TRX_COMMITTED_IN_MEMORY);
 
 # ifdef UNIV_SYNC_DEBUG
 	/* Only validate the record queues when this thread is not

=== modified file 'Percona-Server/storage/innobase/read/read0read.c'
--- Percona-Server/storage/innobase/read/read0read.c	2013-03-15 09:55:17 +0000
+++ Percona-Server/storage/innobase/read/read0read.c	2013-03-25 10:05:33 +0000
@@ -150,22 +150,22 @@
 {
 	if (view == NULL) {
 		view = ut_malloc(sizeof(read_view_t));
-		view->max_trx_ids = 0;
-		view->trx_ids = NULL;
+		view->max_descr = 0;
+		view->descriptors = NULL;
 	}
 
-	if (UNIV_UNLIKELY(view->max_trx_ids < n)) {
+	if (UNIV_UNLIKELY(view->max_descr < n)) {
 
-		/* avoid frequent reallocations by extending the array to the
+		/* avoid frequent re-allocations by extending the array to the
 		desired size + 10% */
 
-		view->max_trx_ids = n + n / 10;
-		view->trx_ids = ut_realloc(view->trx_ids,
-					   view->max_trx_ids *
-					   sizeof *view->trx_ids);
+		view->max_descr = n + n / 10;
+		view->descriptors = ut_realloc(view->descriptors,
+					       view->max_descr *
+					       sizeof(trx_id_t));
 	}
 
-	view->n_trx_ids = n;
+	view->n_descr = n;
 
 	return(view);
 }
@@ -198,10 +198,10 @@
 
 	if (old_view == NULL) {
 
-		return(read_view_open_now(cr_trx_id, view));
+		return(read_view_open_now(cr_trx_id, view, TRUE));
 	}
 
-	n = old_view->n_trx_ids;
+	n = old_view->n_descr;
 
 	if (old_view->creator_trx_id) {
 		n++;
@@ -217,7 +217,7 @@
 	i = 0;
 	while (i < n) {
 		if (needs_insert
-		    && (i >= old_view->n_trx_ids
+		    && (i >= old_view->n_descr
 			|| old_view->creator_trx_id
 			> read_view_get_nth_trx_id(old_view, i))) {
 
@@ -264,15 +264,17 @@
 /*===============*/
 	trx_id_t	cr_trx_id,	/*!< in: trx_id of creating
 					transaction, or 0 used in purge */
-	read_view_t*	view)		/*!< in: current read view or NULL if it
+	read_view_t*	view,		/*!< in: current read view or NULL if it
 					doesn't exist yet */
+	ibool		exclude_self)	/*!< in: TRUE, if cr_trx_id should be
+					excluded from the resulting view */
 {
-	trx_t*		trx;
-	ulint		n;
+	trx_id_t*	descr;
+	ulint		i;
 
 	ut_ad(mutex_own(&kernel_mutex));
 
-	view = read_view_create_low(UT_LIST_GET_LEN(trx_sys->trx_list), view);
+	view = read_view_create_low(trx_sys->descr_n_used, view);
 
 	view->creator_trx_id = cr_trx_id;
 	view->type = VIEW_NORMAL;
@@ -283,40 +285,58 @@
 	view->low_limit_no = trx_sys->max_trx_id;
 	view->low_limit_id = view->low_limit_no;
 
-	n = 0;
-	trx = UT_LIST_GET_FIRST(trx_sys->trx_list);
-
-	/* No active transaction should be visible, except cr_trx */
-
-	while (trx) {
-		if (trx->id != cr_trx_id
-		    && (trx->conc_state == TRX_ACTIVE
-			|| trx->conc_state == TRX_PREPARED)) {
-
-			read_view_set_nth_trx_id(view, n, trx->id);
-
-			n++;
-
-			/* NOTE that a transaction whose trx number is <
-			trx_sys->max_trx_id can still be active, if it is
-			in the middle of its commit! Note that when a
-			transaction starts, we initialize trx->no to
-			IB_ULONGLONG_MAX. */
-
-			if (view->low_limit_no > trx->no) {
-
-				view->low_limit_no = trx->no;
-			}
+	/* No active transaction should be visible */
+
+	descr = trx_find_descriptor(trx_sys->descriptors,
+				    trx_sys->descr_n_used,
+				    cr_trx_id);
+
+	if (UNIV_LIKELY(exclude_self && descr != NULL)) {
+
+		ut_ad(trx_sys->descr_n_used > 0);
+		ut_ad(view->n_descr > 0);
+
+		view->n_descr--;
+
+		i = descr - trx_sys->descriptors;
+	} else {
+		i = trx_sys->descr_n_used;
+	}
+
+	if (UNIV_LIKELY(i > 0)) {
+
+		/* Copy the [0; i-1] range */
+		memcpy(view->descriptors, trx_sys->descriptors,
+		       i * sizeof(trx_id_t));
+	}
+
+	if (UNIV_UNLIKELY(i + 1 < trx_sys->descr_n_used)) {
+
+		/* Copy the [i+1; descr_n_used-1] range */
+		memcpy(view->descriptors + i,
+		       trx_sys->descriptors + i + 1,
+		       (trx_sys->descr_n_used - i - 1) *
+		       sizeof(trx_id_t));
+	}
+
+	/* NOTE that a transaction whose trx number is < trx_sys->max_trx_id can
+	still be active, if it is in the middle of its commit! Note that when a
+	transaction starts, we initialize trx->no to IB_ULONGLONG_MAX. */
+
+	if (UT_LIST_GET_LEN(trx_sys->trx_serial_list) > 0) {
+
+		trx_id_t	trx_no;
+
+		trx_no = UT_LIST_GET_FIRST(trx_sys->trx_serial_list)->no;
+
+		if (trx_no < view->low_limit_no) {
+			view->low_limit_no = trx_no;
 		}
-
-		trx = UT_LIST_GET_NEXT(trx_list, trx);
 	}
 
-	view->n_trx_ids = n;
-
-	if (n > 0) {
+	if (UNIV_LIKELY(view->n_descr > 0)) {
 		/* The last active transaction has the smallest id: */
-		view->up_limit_id = read_view_get_nth_trx_id(view, n - 1);
+		view->up_limit_id = view->descriptors[0];
 	} else {
 		view->up_limit_id = view->low_limit_id;
 	}
@@ -350,8 +370,8 @@
 {
 	ut_ad(mutex_own(&kernel_mutex));
 
-	if (view->trx_ids != NULL) {
-		ut_free(view->trx_ids);
+	if (view->descriptors != NULL) {
+		ut_free(view->descriptors);
 	}
 
 	ut_free(view);
@@ -409,7 +429,7 @@
 
 	fprintf(file, "Read view individually stored trx ids:\n");
 
-	n_ids = view->n_trx_ids;
+	n_ids = view->n_descr;
 
 	for (i = 0; i < n_ids; i++) {
 		fprintf(file, "Read view trx id " TRX_ID_FMT "\n",
@@ -431,8 +451,6 @@
 	cursor_view_t*	curview;
 	read_view_t*	view;
 	mem_heap_t*	heap;
-	trx_t*		trx;
-	ulint		n;
 
 	ut_a(cr_trx);
 
@@ -451,61 +469,14 @@
 
 	mutex_enter(&kernel_mutex);
 
-	curview->read_view = read_view_create_low(
-		UT_LIST_GET_LEN(trx_sys->trx_list), NULL);
+	curview->read_view = read_view_open_now(cr_trx->id, NULL, FALSE);
+
+	mutex_exit(&kernel_mutex);
 
 	view = curview->read_view;
-	view->creator_trx_id = cr_trx->id;
 	view->type = VIEW_HIGH_GRANULARITY;
 	view->undo_no = cr_trx->undo_no;
 
-	/* No future transactions should be visible in the view */
-
-	view->low_limit_no = trx_sys->max_trx_id;
-	view->low_limit_id = view->low_limit_no;
-
-	n = 0;
-	trx = UT_LIST_GET_FIRST(trx_sys->trx_list);
-
-	/* No active transaction should be visible */
-
-	while (trx) {
-
-		if (trx->conc_state == TRX_ACTIVE
-		    || trx->conc_state == TRX_PREPARED) {
-
-			read_view_set_nth_trx_id(view, n, trx->id);
-
-			n++;
-
-			/* NOTE that a transaction whose trx number is <
-			trx_sys->max_trx_id can still be active, if it is
-			in the middle of its commit! Note that when a
-			transaction starts, we initialize trx->no to
-			IB_ULONGLONG_MAX. */
-
-			if (view->low_limit_no > trx->no) {
-
-				view->low_limit_no = trx->no;
-			}
-		}
-
-		trx = UT_LIST_GET_NEXT(trx_list, trx);
-	}
-
-	view->n_trx_ids = n;
-
-	if (n > 0) {
-		/* The last active transaction has the smallest id: */
-		view->up_limit_id = read_view_get_nth_trx_id(view, n - 1);
-	} else {
-		view->up_limit_id = view->low_limit_id;
-	}
-
-	UT_LIST_ADD_FIRST(view_list, trx_sys->view_list, view);
-
-	mutex_exit(&kernel_mutex);
-
 	return(curview);
 }
 

=== modified file 'Percona-Server/storage/innobase/row/row0sel.c'
--- Percona-Server/storage/innobase/row/row0sel.c	2013-03-23 04:47:09 +0000
+++ Percona-Server/storage/innobase/row/row0sel.c	2013-03-25 10:05:33 +0000
@@ -3813,9 +3813,9 @@
 		trx->has_search_latch = FALSE;
 	}
 
-	ut_ad(prebuilt->sql_stat_start || trx->conc_state == TRX_ACTIVE);
-	ut_ad(trx->conc_state == TRX_NOT_STARTED
-	      || trx->conc_state == TRX_ACTIVE);
+	ut_ad(prebuilt->sql_stat_start || trx->state == TRX_ACTIVE);
+	ut_ad(trx->state == TRX_NOT_STARTED
+	      || trx->state == TRX_ACTIVE);
 	ut_ad(prebuilt->sql_stat_start
 	      || prebuilt->select_lock_type != LOCK_NONE
 	      || trx->read_view);
@@ -4897,8 +4897,10 @@
 		if (trx->isolation_level >= TRX_ISO_REPEATABLE_READ
 		    && !trx->read_view) {
 
-			trx->read_view = read_view_open_now(
-				trx->id, NULL);
+			trx->read_view =
+				read_view_open_now(trx->id,
+						   NULL, TRUE);
+
 			trx->global_read_view = trx->read_view;
 		}
 	}

=== modified file 'Percona-Server/storage/innobase/row/row0vers.c'
--- Percona-Server/storage/innobase/row/row0vers.c	2012-09-17 13:08:32 +0000
+++ Percona-Server/storage/innobase/row/row0vers.c	2013-03-25 10:05:33 +0000
@@ -667,9 +667,9 @@
 
 		mutex_enter(&kernel_mutex);
 		version_trx = trx_get_on_id(version_trx_id);
-		if (version_trx
-		    && (version_trx->conc_state == TRX_COMMITTED_IN_MEMORY
-			|| version_trx->conc_state == TRX_NOT_STARTED)) {
+		if (version_trx &&
+		    (version_trx->state == TRX_COMMITTED_IN_MEMORY
+		     || version_trx->state == TRX_NOT_STARTED)) {
 
 			version_trx = NULL;
 		}

=== modified file 'Percona-Server/storage/innobase/srv/srv0srv.c'
--- Percona-Server/storage/innobase/srv/srv0srv.c	2013-03-05 12:16:18 +0000
+++ Percona-Server/storage/innobase/srv/srv0srv.c	2013-03-25 10:05:33 +0000
@@ -2925,7 +2925,7 @@
 		mutex_enter(&kernel_mutex);
 		trx = UT_LIST_GET_FIRST(trx_sys->mysql_trx_list);
 		while (trx) {
-			if (trx->conc_state == TRX_ACTIVE
+			if (trx->state == TRX_ACTIVE
 			    && trx->mysql_thd
 			    && innobase_thd_is_idle(trx->mysql_thd)) {
 				ib_int64_t	start_time = innobase_thd_get_start_time(trx->mysql_thd);

=== modified file 'Percona-Server/storage/innobase/trx/trx0purge.c'
--- Percona-Server/storage/innobase/trx/trx0purge.c	2013-03-23 04:47:09 +0000
+++ Percona-Server/storage/innobase/trx/trx0purge.c	2013-03-25 10:05:33 +0000
@@ -280,7 +280,12 @@
 	que_graph_free(purge_sys->query);
 
 	ut_a(purge_sys->sess->trx->is_purge);
-	purge_sys->sess->trx->conc_state = TRX_NOT_STARTED;
+	purge_sys->sess->trx->state = TRX_NOT_STARTED;
+
+	mutex_enter(&kernel_mutex);
+	trx_release_descriptor(purge_sys->sess->trx);
+	mutex_exit(&kernel_mutex);
+
 	sess_close(purge_sys->sess);
 	purge_sys->sess = NULL;
 

=== modified file 'Percona-Server/storage/innobase/trx/trx0roll.c'
--- Percona-Server/storage/innobase/trx/trx0roll.c	2011-04-05 07:18:43 +0000
+++ Percona-Server/storage/innobase/trx/trx0roll.c	2013-03-25 10:05:33 +0000
@@ -132,7 +132,7 @@
 {
 	int	err;
 
-	if (trx->conc_state == TRX_NOT_STARTED) {
+	if (trx->state == TRX_NOT_STARTED) {
 
 		return(DB_SUCCESS);
 	}
@@ -161,7 +161,7 @@
 {
 	int	err;
 
-	if (trx->conc_state == TRX_NOT_STARTED) {
+	if (trx->state == TRX_NOT_STARTED) {
 
 		return(DB_SUCCESS);
 	}
@@ -263,7 +263,7 @@
 		return(DB_NO_SAVEPOINT);
 	}
 
-	if (trx->conc_state == TRX_NOT_STARTED) {
+	if (trx->state == TRX_NOT_STARTED) {
 		ut_print_timestamp(stderr);
 		fputs("  InnoDB: Error: transaction has a savepoint ", stderr);
 		ut_print_name(stderr, trx, FALSE, savep->name);
@@ -560,7 +560,7 @@
 			continue;
 		}
 
-		switch (trx->conc_state) {
+		switch (trx->state) {
 		case TRX_NOT_STARTED:
 		case TRX_PREPARED:
 			continue;

=== modified file 'Percona-Server/storage/innobase/trx/trx0sys.c'
--- Percona-Server/storage/innobase/trx/trx0sys.c	2012-10-22 00:07:03 +0000
+++ Percona-Server/storage/innobase/trx/trx0sys.c	2013-03-25 10:05:33 +0000
@@ -1319,6 +1319,12 @@
 
 	trx_sys = mem_zalloc(sizeof(*trx_sys));
 
+	/* Allocate the trx descriptors array */
+	trx_sys->descriptors = ut_malloc(sizeof(trx_id_t) *
+					 TRX_DESCR_ARRAY_INITIAL_SIZE);
+	trx_sys->descr_n_max = TRX_DESCR_ARRAY_INITIAL_SIZE;
+	trx_sys->descr_n_used = 0;
+
 	sys_header = trx_sysf_get(&mtr);
 
 	trx_rseg_list_and_array_init(sys_header, ib_bh, &mtr);
@@ -1346,7 +1352,7 @@
 
 		for (;;) {
 
-			if (trx->conc_state != TRX_PREPARED) {
+			if (trx->state != TRX_PREPARED) {
 				rows_to_undo += trx->undo_no;
 			}
 
@@ -2028,6 +2034,9 @@
 	ut_a(UT_LIST_GET_LEN(trx_sys->view_list) == 0);
 	ut_a(UT_LIST_GET_LEN(trx_sys->mysql_trx_list) == 0);
 
+	ut_ad(trx_sys->descr_n_used == 0);
+	ut_free(trx_sys->descriptors);
+
 	mem_free(trx_sys);
 
 	trx_sys = NULL;

=== modified file 'Percona-Server/storage/innobase/trx/trx0trx.c'
--- Percona-Server/storage/innobase/trx/trx0trx.c	2013-03-23 04:47:09 +0000
+++ Percona-Server/storage/innobase/trx/trx0trx.c	2013-03-25 10:05:33 +0000
@@ -85,6 +85,126 @@
 			    sizeof(trx->detailed_error));
 }
 
+/*************************************************************//**
+Callback function for trx_find_descriptor() to compare trx IDs. */
+UNIV_INTERN
+int
+trx_descr_cmp(
+/*==========*/
+	const void *a,	/*!< in: pointer to first comparison argument */
+	const void *b)	/*!< in: pointer to second comparison argument */
+{
+	const trx_id_t*	da = (const trx_id_t*) a;
+	const trx_id_t*	db = (const trx_id_t*) b;
+
+	if (*da < *db) {
+		return -1;
+	} else if (*da > *db) {
+		return 1;
+	}
+
+	return 0;
+}
+
+/*************************************************************//**
+Reserve a slot for a given trx in the global descriptors array. */
+UNIV_INLINE
+void
+trx_reserve_descriptor(
+/*===================*/
+	const trx_t* trx)	/*!< in: trx pointer */
+{
+	ulint		n_used;
+	ulint		n_max;
+	trx_id_t*	descr;
+
+	ut_ad(mutex_own(&kernel_mutex));
+	ut_ad(!trx_find_descriptor(trx_sys->descriptors,
+				   trx_sys->descr_n_used,
+				   trx->id));
+
+	n_used = trx_sys->descr_n_used + 1;
+	n_max = trx_sys->descr_n_max;
+
+	if (UNIV_UNLIKELY(n_used > n_max)) {
+
+		n_max = n_max * 2;
+
+		trx_sys->descriptors =
+			ut_realloc(trx_sys->descriptors,
+				   n_max * sizeof(trx_id_t));
+
+		trx_sys->descr_n_max = n_max;
+	}
+
+	descr = trx_sys->descriptors + n_used - 1;
+
+	if (UNIV_UNLIKELY(n_used > 1 && trx->id < descr[-1])) {
+
+		/* Find the slot where it should be inserted. We could use a
+		binary search, but in reality linear search should be faster,
+		because the slot we are looking for is near the array end. */
+
+		trx_id_t*	tdescr;
+
+		for (tdescr = descr - 1;
+		     tdescr >= trx_sys->descriptors && *tdescr > trx->id;
+		     tdescr--) {
+		}
+
+		tdescr++;
+
+		ut_memmove(tdescr + 1, tdescr, (descr - tdescr) *
+			   sizeof(trx_id_t));
+
+		descr = tdescr;
+	}
+
+	*descr = trx->id;
+
+	trx_sys->descr_n_used = n_used;
+}
+
+/*************************************************************//**
+Release a slot for a given trx in the global descriptors array. */
+UNIV_INTERN
+void
+trx_release_descriptor(
+/*===================*/
+	trx_t* trx)	/*!< in: trx pointer */
+{
+	ulint		size;
+	trx_id_t*	descr;
+
+	ut_ad(mutex_own(&kernel_mutex));
+
+	if (UNIV_LIKELY(trx->is_in_trx_serial_list)) {
+
+		UT_LIST_REMOVE(trx_serial_list, trx_sys->trx_serial_list,
+			       trx);
+		trx->is_in_trx_serial_list = 0;
+	}
+
+	descr = trx_find_descriptor(trx_sys->descriptors,
+				    trx_sys->descr_n_used,
+				    trx->id);
+
+	if (UNIV_UNLIKELY(descr == NULL)) {
+
+		return;
+	}
+
+	size = (trx_sys->descriptors + trx_sys->descr_n_used - 1 - descr) *
+		sizeof(trx_id_t);
+
+	if (UNIV_LIKELY(size > 0)) {
+
+		ut_memmove(descr, descr + 1, size);
+	}
+
+	trx_sys->descr_n_used--;
+}
+
 /****************************************************************//**
 Creates and initializes a transaction object.
 @return	own: the transaction */
@@ -107,7 +227,7 @@
 
 	trx->is_purge = 0;
 	trx->is_recovered = 0;
-	trx->conc_state = TRX_NOT_STARTED;
+	trx->state = TRX_NOT_STARTED;
 
 	trx->is_registered = 0;
 	trx->owns_prepare_mutex = 0;
@@ -119,6 +239,7 @@
 
 	trx->id = 0;
 	trx->no = IB_ULONGLONG_MAX;
+	trx->is_in_trx_serial_list = 0;
 
 	trx->support_xa = TRUE;
 
@@ -328,7 +449,7 @@
 
 	trx->magic_n = 11112222;
 
-	ut_a(trx->conc_state == TRX_NOT_STARTED);
+	ut_a(trx->state == TRX_NOT_STARTED);
 
 	mutex_free(&(trx->undo_mutex));
 
@@ -359,15 +480,14 @@
 		read_view_free(trx->prebuilt_view);
 	}
 
-	trx->global_read_view = NULL;
-	trx->prebuilt_view = NULL;
-
 	ut_a(trx->read_view == NULL);
 
 	ut_a(ib_vector_is_empty(trx->autoinc_locks));
 	/* We allocated a dedicated heap for the vector. */
 	ib_vector_free(trx->autoinc_locks);
 
+	trx_release_descriptor(trx);
+
 	mem_free(trx);
 }
 
@@ -380,7 +500,7 @@
 	trx_t*	trx)	/*!< in, own: trx object */
 {
 	ut_ad(mutex_own(&kernel_mutex));
-	ut_a(trx->conc_state == TRX_PREPARED);
+	ut_a(trx->state == TRX_PREPARED);
 	ut_a(trx->magic_n == TRX_MAGIC_N);
 
 	/* Prepared transactions are sort of active; they allow
@@ -416,8 +536,16 @@
 	ut_a(ib_vector_is_empty(trx->autoinc_locks));
 	ib_vector_free(trx->autoinc_locks);
 
+	trx_release_descriptor(trx);
+
+	if (trx->prebuilt_view != NULL) {
+		read_view_free(trx->prebuilt_view);
+	}
+
 	UT_LIST_REMOVE(trx_list, trx_sys->trx_list, trx);
 
+	ut_ad(trx_sys->descr_n_used <= UT_LIST_GET_LEN(trx_sys->trx_list));
+
 	mem_free(trx);
 }
 
@@ -526,6 +654,7 @@
 
 	ut_ad(mutex_own(&kernel_mutex));
 	UT_LIST_INIT(trx_sys->trx_list);
+	UT_LIST_INIT(trx_sys->trx_serial_list);
 
 	/* Look from the rollback segments if there exist undo logs for
 	transactions */
@@ -562,7 +691,7 @@
 
 					if (srv_force_recovery == 0) {
 
-						trx->conc_state = TRX_PREPARED;
+						trx->state = TRX_PREPARED;
 						trx_n_prepared++;
 					} else {
 						fprintf(stderr,
@@ -572,11 +701,12 @@
 							" rollback it"
 							" anyway.\n");
 
-						trx->conc_state = TRX_ACTIVE;
+						trx->state = TRX_ACTIVE;
 					}
+
+					trx_reserve_descriptor(trx);
 				} else {
-					trx->conc_state
-						= TRX_COMMITTED_IN_MEMORY;
+					trx->state = TRX_COMMITTED_IN_MEMORY;
 				}
 
 				/* We give a dummy value for the trx no;
@@ -588,12 +718,15 @@
 
 				trx->no = trx->id;
 			} else {
-				trx->conc_state = TRX_ACTIVE;
+				trx->state = TRX_ACTIVE;
 
 				/* A running transaction always has the number
 				field inited to IB_ULONGLONG_MAX */
 
 				trx->no = IB_ULONGLONG_MAX;
+
+				trx_reserve_descriptor(trx);
+
 			}
 
 			if (undo->dict_operation) {
@@ -638,7 +771,7 @@
 
 						if (srv_force_recovery == 0) {
 
-							trx->conc_state
+							trx->state
 								= TRX_PREPARED;
 							trx_n_prepared++;
 						} else {
@@ -649,11 +782,12 @@
 								" rollback it"
 								" anyway.\n");
 
-							trx->conc_state
-								= TRX_ACTIVE;
+							trx->state = TRX_ACTIVE;
+							trx_reserve_descriptor(
+								trx);
 						}
 					} else {
-						trx->conc_state
+						trx->state
 							= TRX_COMMITTED_IN_MEMORY;
 					}
 
@@ -662,13 +796,14 @@
 
 					trx->no = trx->id;
 				} else {
-					trx->conc_state = TRX_ACTIVE;
-
+					trx->state = TRX_ACTIVE;
 					/* A running transaction always has
 					the number field inited to
 					IB_ULONGLONG_MAX */
 
 					trx->no = IB_ULONGLONG_MAX;
+
+					trx_reserve_descriptor(trx);
 				}
 
 				trx->rseg = rseg;
@@ -739,13 +874,15 @@
 
 	if (trx->is_purge) {
 		trx->id = 0;
-		trx->conc_state = TRX_ACTIVE;
+		/* Don't reserve a descriptor, since this trx is not added to
+		trx_list. */
+		trx->state = TRX_ACTIVE;
 		trx->start_time = time(NULL);
 
 		return(TRUE);
 	}
 
-	ut_ad(trx->conc_state != TRX_ACTIVE);
+	ut_ad(trx->state != TRX_ACTIVE);
 
 	ut_a(rseg_id == ULINT_UNDEFINED);
 
@@ -760,7 +897,10 @@
 
 	trx->rseg = rseg;
 
-	trx->conc_state = TRX_ACTIVE;
+	trx->state = TRX_ACTIVE;
+
+	trx_reserve_descriptor(trx);
+
 	trx->start_time = time(NULL);
 
 	UT_LIST_ADD_FIRST(trx_list, trx_sys->trx_list, trx);
@@ -817,6 +957,14 @@
 
 	trx->no = trx_sys_get_new_trx_id();
 
+	if (UNIV_LIKELY(trx->is_in_trx_serial_list == 0)) {
+
+		UT_LIST_ADD_LAST(trx_serial_list, trx_sys->trx_serial_list,
+				 trx);
+
+		trx->is_in_trx_serial_list = 1;
+	}
+
 	/* If the rollack segment is not empty then the
 	new trx_t::no can't be less than any trx_t::no
 	already in the rollback segment. User threads only
@@ -998,10 +1146,10 @@
 		lsn = 0;
 	}
 
-	ut_ad(trx->conc_state == TRX_ACTIVE || trx->conc_state == TRX_PREPARED);
+	ut_ad(trx->state == TRX_ACTIVE || trx->state == TRX_PREPARED);
 	ut_ad(mutex_own(&kernel_mutex));
 
-	if (UNIV_UNLIKELY(trx->conc_state == TRX_PREPARED)) {
+	if (UNIV_UNLIKELY(trx->state == TRX_PREPARED)) {
 		ut_a(trx_n_prepared > 0);
 		trx_n_prepared--;
 	}
@@ -1021,7 +1169,9 @@
 	committed. */
 
 	/*--------------------------------------*/
-	trx->conc_state = TRX_COMMITTED_IN_MEMORY;
+	trx->state = TRX_COMMITTED_IN_MEMORY;
+	/* The following also removes trx from trx_serial_list */
+	trx_release_descriptor(trx);
 	/*--------------------------------------*/
 
 	/* If we release kernel_mutex below and we are still doing
@@ -1127,7 +1277,7 @@
 	/* Free all savepoints */
 	trx_roll_free_all_savepoints(trx);
 
-	trx->conc_state = TRX_NOT_STARTED;
+	trx->state = TRX_NOT_STARTED;
 	trx->rseg = NULL;
 	trx->undo_no = 0;
 	trx->last_sql_stat_start.least_undo_no = 0;
@@ -1137,6 +1287,8 @@
 
 	UT_LIST_REMOVE(trx_list, trx_sys->trx_list, trx);
 
+	ut_ad(trx_sys->descr_n_used <= UT_LIST_GET_LEN(trx_sys->trx_list));
+
 	trx->error_state = DB_SUCCESS;
 }
 
@@ -1155,12 +1307,15 @@
 		trx_undo_insert_cleanup(trx);
 	}
 
-	trx->conc_state = TRX_NOT_STARTED;
+	trx->state = TRX_NOT_STARTED;
+	trx_release_descriptor(trx);
 	trx->rseg = NULL;
 	trx->undo_no = 0;
 	trx->last_sql_stat_start.least_undo_no = 0;
 
 	UT_LIST_REMOVE(trx_list, trx_sys->trx_list, trx);
+
+	ut_ad(trx_sys->descr_n_used <= UT_LIST_GET_LEN(trx_sys->trx_list));
 }
 
 /********************************************************************//**
@@ -1174,7 +1329,7 @@
 /*=================*/
 	trx_t*	trx)	/*!< in: active transaction */
 {
-	ut_ad(trx->conc_state == TRX_ACTIVE);
+	ut_ad(trx->state == TRX_ACTIVE);
 
 	if (trx->read_view) {
 		return(trx->read_view);
@@ -1182,12 +1337,9 @@
 
 	mutex_enter(&kernel_mutex);
 
-	if (!trx->read_view) {
-		trx->read_view = read_view_open_now(trx->id,
-						    trx->prebuilt_view);
-		trx->prebuilt_view = trx->read_view;
-		trx->global_read_view = trx->read_view;
-	}
+	trx->read_view = read_view_open_now(trx->id, trx->prebuilt_view, TRUE);
+	trx->prebuilt_view = trx->read_view;
+	trx->global_read_view = trx->read_view;
 
 	mutex_exit(&kernel_mutex);
 
@@ -1552,7 +1704,7 @@
 		return;
 	}
 
-	if (trx->conc_state == TRX_NOT_STARTED) {
+	if (trx->state == TRX_NOT_STARTED) {
 
 		trx_start_low(trx, ULINT_UNDEFINED);
 	}
@@ -1844,7 +1996,7 @@
 {
 	ut_a(trx);
 
-	if (trx->conc_state == TRX_NOT_STARTED) {
+	if (trx->state == TRX_NOT_STARTED) {
 		trx->undo_no = 0;
 	}
 
@@ -1867,7 +2019,7 @@
 
 	fprintf(f, "TRANSACTION " TRX_ID_FMT, (ullint) trx->id);
 
-	switch (trx->conc_state) {
+	switch (trx->state) {
 	case TRX_NOT_STARTED:
 		fputs(", not started", f);
 		break;
@@ -1883,7 +2035,7 @@
 		fputs(", COMMITTED IN MEMORY", f);
 		break;
 	default:
-		fprintf(f, " state %lu", (ulong) trx->conc_state);
+		fprintf(f, " state %lu", (ulong) trx->state);
 	}
 
 	if (*trx->op_info) {
@@ -2078,7 +2230,11 @@
 	ut_ad(mutex_own(&kernel_mutex));
 
 	/*--------------------------------------*/
-	trx->conc_state = TRX_PREPARED;
+	if (UNIV_UNLIKELY(trx->state != TRX_ACTIVE)) {
+
+		trx_reserve_descriptor(trx);
+	}
+	trx->state = TRX_PREPARED;
 	trx_n_prepared++;
 	/*--------------------------------------*/
 
@@ -2192,7 +2348,7 @@
 	trx = UT_LIST_GET_FIRST(trx_sys->trx_list);
 
 	while (trx) {
-		if (trx->conc_state == TRX_PREPARED) {
+		if (trx->state == TRX_PREPARED) {
 			xid_list[count] = trx->xid;
 
 			if (count == 0) {
@@ -2265,7 +2421,7 @@
 		the same */
 
 		if (trx->is_recovered
-		    && trx->conc_state == TRX_PREPARED
+		    && trx->state == TRX_PREPARED
 		    && xid->gtrid_length == trx->xid.gtrid_length
 		    && xid->bqual_length == trx->xid.bqual_length
 		    && memcmp(xid->data, trx->xid.data,