Merge branch '10.2' into 10.3

1 files changed, 67 insertions, 103 deletions

diff --git a/storage/innobase/fts/fts0opt.cc b/storage/innobase/fts/fts0opt.cc
index 8b72bac6589..06cb70ed575 100644
--- a/storage/innobase/fts/fts0opt.cc
+++ b/storage/innobase/fts/fts0opt.cc
@@ -35,9 +35,10 @@ Completed 2011/7/10 Sunny and Jimmy Yang
 #include "srv0start.h"
 #include "ut0list.h"
 #include "zlib.h"
+#include "fts0opt.h"
 
 /** The FTS optimize thread's work queue. */
-static ib_wqueue_t* fts_optimize_wq;
+ib_wqueue_t* fts_optimize_wq;
 
 /** The FTS vector to store fts_slot_t */
 static ib_vector_t*  fts_slots;
@@ -168,8 +169,8 @@ struct fts_encode_t {
 /** We use this information to determine when to start the optimize
 cycle for a table. */
 struct fts_slot_t {
-	/** table identifier, or 0 if the slot is empty */
-	table_id_t	table_id;
+	/** table, or NULL if the slot is unused */
+	dict_table_t*	table;
 
 	/** whether this slot is being processed */
 	bool		running;
@@ -2391,14 +2392,7 @@ fts_optimize_table_bk(
 		return(DB_SUCCESS);
 	}
 
-	dict_table_t* table = dict_table_open_on_id(
-		slot->table_id, FALSE, DICT_TABLE_OP_NORMAL);
-
-	if (!table) {
-		slot->last_run = now;
-		return DB_SUCCESS;
-	}
-
+	dict_table_t*	table = slot->table;
 	dberr_t		error;
 
 	if (fil_table_accessible(table)
@@ -2418,8 +2412,6 @@ fts_optimize_table_bk(
 		error = DB_SUCCESS;
 	}
 
-	dict_table_close(table, FALSE, FALSE);
-
 	return(error);
 }
 /*********************************************************************//**
@@ -2564,11 +2556,13 @@ void fts_optimize_add_table(dict_table_t* table)
 
 	msg = fts_optimize_create_msg(FTS_MSG_ADD_TABLE, table);
 
-	ib_wqueue_add(fts_optimize_wq, msg, msg->heap);
+	mutex_enter(&fts_optimize_wq->mutex);
+
+	ib_wqueue_add(fts_optimize_wq, msg, msg->heap, true);
 
-	mutex_enter(&table->fts->bg_threads_mutex);
 	table->fts->in_queue = true;
-	mutex_exit(&table->fts->bg_threads_mutex);
+
+	mutex_exit(&fts_optimize_wq->mutex);
 }
 
 /**********************************************************************//**
@@ -2595,12 +2589,10 @@ fts_optimize_remove_table(
 		return;
 	}
 
-	fts_t*	fts = table->fts;
-	mutex_enter(&fts->bg_threads_mutex);
-	bool is_in_optimize_queue = fts->in_queue;
-	mutex_exit(&fts->bg_threads_mutex);
+	mutex_enter(&fts_optimize_wq->mutex);
 
-	if (!is_in_optimize_queue) {
+	if (!table->fts->in_queue) {
+		mutex_exit(&fts_optimize_wq->mutex);
 		return;
 	}
 
@@ -2616,15 +2608,17 @@ fts_optimize_remove_table(
 	remove->event = event;
 	msg->ptr = remove;
 
-	ib_wqueue_add(fts_optimize_wq, msg, msg->heap);
+	ib_wqueue_add(fts_optimize_wq, msg, msg->heap, true);
+
+	mutex_exit(&fts_optimize_wq->mutex);
 
 	os_event_wait(event);
 
 	os_event_destroy(event);
 
-	mutex_enter(&fts->bg_threads_mutex);
-	fts->in_queue = false;
-	mutex_exit(&fts->bg_threads_mutex);
+	ut_d(mutex_enter(&fts_optimize_wq->mutex));
+	ut_ad(!table->fts->in_queue);
+	ut_d(mutex_exit(&fts_optimize_wq->mutex));
 }
 
 /** Send sync fts cache for the table.
@@ -2633,9 +2627,6 @@ void
 fts_optimize_request_sync_table(
 	dict_table_t*	table)
 {
-	fts_msg_t*	msg;
-	table_id_t*	table_id;
-
 	/* if the optimize system not yet initialized, return */
 	if (!fts_optimize_wq) {
 		return;
@@ -2648,39 +2639,36 @@ fts_optimize_request_sync_table(
 		return;
 	}
 
-	msg = fts_optimize_create_msg(FTS_MSG_SYNC_TABLE, NULL);
+	fts_msg_t* msg = fts_optimize_create_msg(FTS_MSG_SYNC_TABLE, table);
 
-	table_id = static_cast<table_id_t*>(
-		mem_heap_alloc(msg->heap, sizeof(table_id_t)));
-	*table_id = table->id;
-	msg->ptr = table_id;
+	mutex_enter(&fts_optimize_wq->mutex);
 
-	ib_wqueue_add(fts_optimize_wq, msg, msg->heap);
+	ib_wqueue_add(fts_optimize_wq, msg, msg->heap, true);
 
-	mutex_enter(&table->fts->bg_threads_mutex);
 	table->fts->in_queue = true;
-	mutex_exit(&table->fts->bg_threads_mutex);
+
+	mutex_exit(&fts_optimize_wq->mutex);
 }
 
 /** Add a table to fts_slots if it doesn't already exist. */
 static bool fts_optimize_new_table(dict_table_t* table)
 {
+	ut_ad(table);
+
 	ulint		i;
 	fts_slot_t*	slot;
 	fts_slot_t*	empty = NULL;
-	const table_id_t table_id = table->id;
-	ut_ad(table_id);
 
 	/* Search for duplicates, also find a free slot if one exists. */
 	for (i = 0; i < ib_vector_size(fts_slots); ++i) {
 
 		slot = static_cast<fts_slot_t*>(ib_vector_get(fts_slots, i));
 
-		if (!slot->table_id) {
+		if (!slot->table) {
 			empty = slot;
-		} else if (slot->table_id == table_id) {
+		} else if (slot->table == table) {
 			/* Already exists in our optimize queue. */
-			return(FALSE);
+			return false;
 		}
 	}
 
@@ -2689,36 +2677,35 @@ static bool fts_optimize_new_table(dict_table_t* table)
 
 	memset(slot, 0x0, sizeof(*slot));
 
-	slot->table_id = table->id;
-	slot->running = false;
-
-	return(TRUE);
+	slot->table = table;
+	return true;
 }
 
 /** Remove a table from fts_slots if it exists.
 @param[in,out]	table	table to be removed from fts_slots */
 static bool fts_optimize_del_table(const dict_table_t* table)
 {
-	const table_id_t table_id = table->id;
-	ut_ad(table_id);
-
+	ut_ad(table);
 	for (ulint i = 0; i < ib_vector_size(fts_slots); ++i) {
 		fts_slot_t*	slot;
 
 		slot = static_cast<fts_slot_t*>(ib_vector_get(fts_slots, i));
 
-		if (slot->table_id == table_id) {
+		if (slot->table == table) {
 			if (fts_enable_diag_print) {
 				ib::info() << "FTS Optimize Removing table "
 					<< table->name;
 			}
 
-			slot->table_id = 0;
-			return(TRUE);
+			mutex_enter(&fts_optimize_wq->mutex);
+			slot->table->fts->in_queue = false;
+			mutex_exit(&fts_optimize_wq->mutex);
+			slot->table = NULL;
+			return true;
 		}
 	}
 
-	return(FALSE);
+	return false;
 }
 
 /**********************************************************************//**
@@ -2732,7 +2719,7 @@ static ulint fts_optimize_how_many()
 	for (ulint i = 0; i < ib_vector_size(fts_slots); ++i) {
 		const fts_slot_t* slot = static_cast<const fts_slot_t*>(
 			ib_vector_get_const(fts_slots, i));
-		if (slot->table_id == 0) {
+		if (!slot->table) {
 			continue;
 		}
 
@@ -2768,22 +2755,14 @@ static bool fts_is_sync_needed()
 		const fts_slot_t* slot = static_cast<const fts_slot_t*>(
 			ib_vector_get_const(fts_slots, i));
 
-		if (slot->table_id == 0) {
-			continue;
-		}
-
-		dict_table_t* table = dict_table_open_on_id(
-			slot->table_id, FALSE, DICT_TABLE_OP_NORMAL);
-		if (!table) {
+		if (!slot->table) {
 			continue;
 		}
 
-		if (table->fts && table->fts->cache) {
-			total_memory += table->fts->cache->total_size;
+		if (slot->table->fts && slot->table->fts->cache) {
+			total_memory += slot->table->fts->cache->total_size;
 		}
 
-		dict_table_close(table, FALSE, FALSE);
-
 		if (total_memory > fts_max_total_cache_size) {
 			return(true);
 		}
@@ -2793,22 +2772,14 @@ static bool fts_is_sync_needed()
 }
 
 /** Sync fts cache of a table
-@param[in]	table_id	table id */
-static void fts_optimize_sync_table(table_id_t table_id)
+@param[in,out]	table	table to be synced */
+static void fts_optimize_sync_table(dict_table_t* table)
 {
-	if (dict_table_t* table = dict_table_open_on_id(
-		    table_id, FALSE, DICT_TABLE_OP_NORMAL)) {
-		if (fil_table_accessible(table)
-		    && table->fts && table->fts->cache) {
-			fts_sync_table(table, false);
-		}
-
-		DBUG_EXECUTE_IF(
-			"ib_optimize_wq_hang",
-			os_thread_sleep(6000000););
-
-		dict_table_close(table, FALSE, FALSE);
+	if (table->fts && table->fts->cache && fil_table_accessible(table)) {
+		fts_sync_table(table, false);
 	}
+
+	DBUG_EXECUTE_IF("ib_optimize_wq_hang", os_thread_sleep(6000000););
 }
 
 /**********************************************************************//**
@@ -2847,7 +2818,7 @@ DECLARE_THREAD(fts_optimize_thread)(
 				ib_vector_get(fts_slots, current));
 
 			/* Handle the case of empty slots. */
-			if (slot->table_id) {
+			if (slot->table) {
 				slot->running = true;
 				fts_optimize_table_bk(slot);
 			}
@@ -2906,7 +2877,7 @@ DECLARE_THREAD(fts_optimize_thread)(
 					os_thread_sleep(300000););
 
 				fts_optimize_sync_table(
-					*static_cast<table_id_t*>(msg->ptr));
+					static_cast<dict_table_t*>(msg->ptr));
 				break;
 
 			default:
@@ -2925,8 +2896,8 @@ DECLARE_THREAD(fts_optimize_thread)(
 			fts_slot_t* slot = static_cast<fts_slot_t*>(
 				ib_vector_get(fts_slots, i));
 
-			if (table_id_t table_id = slot->table_id) {
-				fts_optimize_sync_table(table_id);
+			if (slot->table) {
+				fts_optimize_sync_table(slot->table);
 			}
 		}
 	}
@@ -2954,7 +2925,6 @@ fts_optimize_init(void)
 {
 	mem_heap_t*	heap;
 	ib_alloc_t*     heap_alloc;
-	dict_table_t*   table;
 
 	ut_ad(!srv_read_only_mode);
 
@@ -2970,31 +2940,25 @@ fts_optimize_init(void)
 	heap_alloc = ib_heap_allocator_create(heap);
 	fts_slots = ib_vector_create(heap_alloc, sizeof(fts_slot_t), 4);
 
-	/* Add fts tables to the fts_slots vector which were skipped during restart */
-	std::vector<dict_table_t*> table_vector;
-	std::vector<dict_table_t*>::iterator it;
-
+	/* Add fts tables to fts_slots which could be skipped
+	during dict_load_table_one() because fts_optimize_thread
+	wasn't even started. */
 	mutex_enter(&dict_sys->mutex);
-	for (table = UT_LIST_GET_FIRST(dict_sys->table_LRU);
-             table != NULL;
-             table = UT_LIST_GET_NEXT(table_LRU, table)) {
-                if (table->fts &&
-                    dict_table_has_fts_index(table)) {
-			if (fts_optimize_new_table(table)){
-				table_vector.push_back(table);
-			}
+	for (dict_table_t* table = UT_LIST_GET_FIRST(dict_sys->table_LRU);
+	     table != NULL;
+	     table = UT_LIST_GET_NEXT(table_LRU, table)) {
+		if (!table->fts || !dict_table_has_fts_index(table)) {
+			continue;
 		}
-	}
 
-	/* It is better to call dict_table_prevent_eviction()
-	outside the above loop because it operates on
-	dict_sys->table_LRU list.*/
-	for (it=table_vector.begin();it!=table_vector.end();++it) {
-		dict_table_prevent_eviction(*it);
+		/* fts_optimize_thread is not started yet. So there is no
+		need to acquire fts_optimize_wq->mutex for adding the fts
+		table to the fts slots. */
+		ut_ad(!table->can_be_evicted);
+		fts_optimize_new_table(table);
+		table->fts->in_queue = true;
 	}
-
 	mutex_exit(&dict_sys->mutex);
-	table_vector.clear();
 
 	fts_opt_shutdown_event = os_event_create(0);
 	last_check_sync_time = time(NULL);