InnoDB: Do not distinguish explicitly requested table locks. (2e2a4e4f) · Commits · Software / OSDI20 Artifacts / mariadb

innobase/include/lock0lock.h

+1 −15

Original line number	Diff line number	Diff line
		@@ -413,9 +413,7 @@ lock_table(
		/* out: DB_SUCCESS, DB_LOCK_WAIT,
		DB_DEADLOCK, or DB_QUE_THR_SUSPENDED */
		ulint flags, /* in: if BTR_NO_LOCKING_FLAG bit is set,
		does nothing;
		if LOCK_TABLE_EXP bits are set,
		creates an explicit table lock */
		does nothing */
		dict_table_t* table, /* in: database table in dictionary cache */
		ulint mode, /* in: lock mode */
		que_thr_t* thr); /* in: query thread */
		@@ -452,15 +450,6 @@ lock_release_off_kernel(
		/====================/
		trx_t* trx); /* in: transaction */
		/*************************************************************************
		Releases table locks explicitly requested with LOCK TABLES (indicated by
		lock type LOCK_TABLE_EXP), and releases possible other transactions waiting
		because of these locks. */

		void
		lock_release_tables_off_kernel(
		/===========================/
		trx_t* trx); /* in: transaction */
		/*************************************************************************
		Cancels a waiting lock request and releases possible other transactions
		waiting behind it. */

		@@ -612,9 +601,6 @@ extern lock_sys_t* lock_sys;
		/* Lock types */
		#define LOCK_TABLE 16 /* these type values should be so high that */
		#define LOCK_REC 32 /* they can be ORed to the lock mode */
		#define LOCK_TABLE_EXP 80 /* explicit table lock (80 = 16 + 64) */
		#define LOCK_TABLE_TRANSACTIONAL 144
		/* transactional table lock (144 = 16 + 128)*/
		#define LOCK_TYPE_MASK 0xF0UL /* mask used to extract lock type from the
		type_mode field in a lock */
		/* Waiting lock flag */

innobase/include/row0mysql.h

+3 −10

Original line number	Diff line number	Diff line
		@@ -172,14 +172,6 @@ row_lock_table_autoinc_for_mysql(
		row_prebuilt_t* prebuilt); /* in: prebuilt struct in the MySQL
		table handle */
		/*************************************************************************
		Unlocks all table locks explicitly requested by trx (with LOCK TABLES,
		lock type LOCK_TABLE_EXP). */

		void
		row_unlock_tables_for_mysql(
		/========================/
		trx_t* trx); /* in: transaction */
		/*************************************************************************
		Sets a table lock on the table mentioned in prebuilt. */

		int
		@@ -190,9 +182,10 @@ row_lock_table_for_mysql(
		table handle */
		dict_table_t* table, /* in: table to lock, or NULL
		if prebuilt->table should be
		locked as LOCK_TABLE_EXP \|
		locked as
		prebuilt->select_lock_type */
		ulint mode); /* in: lock mode of table */
		ulint mode); /* in: lock mode of table
		(ignored if table==NULL) */

		/*************************************************************************
		Does an insert for MySQL. */

innobase/include/trx0trx.h

+0 −7

Original line number	Diff line number	Diff line
		@@ -497,13 +497,6 @@ struct trx_struct{
		in the lock list trx_locks */
		ibool trx_create_lock;/* this is TRUE if we have created a
		new lock for a record accessed */
		ulint n_lock_table_exp;/* number of explicit table locks
		(LOCK TABLES) reserved by the
		transaction, stored in trx_locks */
		ulint n_lock_table_transactional;
		/* number of transactional table locks
		(LOCK TABLES..WHERE ENGINE) reserved by
		the transaction, stored in trx_locks */
		UT_LIST_NODE_T(trx_t)
		trx_list; /* list of transactions */
		UT_LIST_NODE_T(trx_t)

innobase/lock/lock0lock.c

+5 −113

Original line number	Diff line number	Diff line
		@@ -2208,10 +2208,6 @@ lock_grant(
		release it at the end of the SQL statement */

		lock->trx->auto_inc_lock = lock;
		} else if (lock_get_type(lock) == LOCK_TABLE_EXP \|\|
		lock_get_type(lock) == LOCK_TABLE_TRANSACTIONAL) {
		ut_a(lock_get_mode(lock) == LOCK_S
		\|\| lock_get_mode(lock) == LOCK_X);
		}

		if (lock_print_waits) {
		@@ -3415,14 +3411,6 @@ lock_table_create(
		lock->type_mode = type_mode \| LOCK_TABLE;
		lock->trx = trx;

		if (lock_get_type(lock) == LOCK_TABLE_EXP) {
		lock->trx->n_lock_table_exp++;
		}

		if (lock_get_type(lock) == LOCK_TABLE_TRANSACTIONAL) {
		lock->trx->n_lock_table_transactional++;
		}

		lock->un_member.tab_lock.table = table;

		UT_LIST_ADD_LAST(un_member.tab_lock.locks, table->locks, lock);
		@@ -3459,14 +3447,6 @@ lock_table_remove_low(
		trx->auto_inc_lock = NULL;
		}

		if (lock_get_type(lock) == LOCK_TABLE_EXP) {
		trx->n_lock_table_exp--;
		}

		if (lock_get_type(lock) == LOCK_TABLE_TRANSACTIONAL) {
		trx->n_lock_table_transactional--;
		}

		UT_LIST_REMOVE(trx_locks, trx->trx_locks, lock);
		UT_LIST_REMOVE(un_member.tab_lock.locks, table->locks, lock);
		}
		@@ -3597,10 +3577,7 @@ lock_table(
		/* out: DB_SUCCESS, DB_LOCK_WAIT,
		DB_DEADLOCK, or DB_QUE_THR_SUSPENDED */
		ulint flags, /* in: if BTR_NO_LOCKING_FLAG bit is set,
		does nothing;
		if LOCK_TABLE_EXP\|LOCK_TABLE_TRANSACTIONAL
		bits are set,
		creates an explicit table lock */
		does nothing */
		dict_table_t* table, /* in: database table in dictionary cache */
		ulint mode, /* in: lock mode */
		que_thr_t* thr) /* in: query thread */
		@@ -3615,8 +3592,7 @@ lock_table(
		return(DB_SUCCESS);
		}

		ut_a(flags == 0 \|\| flags == LOCK_TABLE_EXP \|\|
		flags == LOCK_TABLE_TRANSACTIONAL);
		ut_a(flags == 0);

		trx = thr_get_trx(thr);

		@@ -3729,9 +3705,7 @@ lock_table_dequeue(
		#ifdef UNIV_SYNC_DEBUG
		ut_ad(mutex_own(&kernel_mutex));
		#endif /* UNIV_SYNC_DEBUG */
		ut_a(lock_get_type(in_lock) == LOCK_TABLE \|\|
		lock_get_type(in_lock) == LOCK_TABLE_EXP \|\|
		lock_get_type(in_lock) == LOCK_TABLE_TRANSACTIONAL);
		ut_a(lock_get_type(in_lock) == LOCK_TABLE);

		lock = UT_LIST_GET_NEXT(un_member.tab_lock.locks, in_lock);

		@@ -3835,12 +3809,6 @@ lock_release_off_kernel(
		}

		lock_table_dequeue(lock);

		if (lock_get_type(lock) == LOCK_TABLE_EXP \|\|
		lock_get_type(lock) == LOCK_TABLE_TRANSACTIONAL) {
		ut_a(lock_get_mode(lock) == LOCK_S
		\|\| lock_get_mode(lock) == LOCK_X);
		}
		}

		if (count == LOCK_RELEASE_KERNEL_INTERVAL) {
		@@ -3860,74 +3828,6 @@ lock_release_off_kernel(
		mem_heap_empty(trx->lock_heap);

		ut_a(trx->auto_inc_lock == NULL);
		ut_a(trx->n_lock_table_exp == 0);
		ut_a(trx->n_lock_table_transactional == 0);
		}

		/*************************************************************************
		Releases table locks explicitly requested with LOCK TABLES (indicated by
		lock type LOCK_TABLE_EXP), and releases possible other transactions waiting
		because of these locks. */

		void
		lock_release_tables_off_kernel(
		/===========================/
		trx_t* trx) /* in: transaction */
		{
		dict_table_t* table;
		ulint count;
		lock_t* lock;

		#ifdef UNIV_SYNC_DEBUG
		ut_ad(mutex_own(&kernel_mutex));
		#endif /* UNIV_SYNC_DEBUG */

		lock = UT_LIST_GET_LAST(trx->trx_locks);

		count = 0;

		while (lock != NULL) {

		count++;

		if (lock_get_type(lock) == LOCK_TABLE_EXP) {
		ut_a(lock_get_mode(lock) == LOCK_S
		\|\| lock_get_mode(lock) == LOCK_X);
		if (trx->insert_undo \|\| trx->update_undo) {

		/* The trx may have modified the table.
		We block the use of the MySQL query
		cache for all currently active
		transactions. */

		table = lock->un_member.tab_lock.table;

		table->query_cache_inv_trx_id =
		trx_sys->max_trx_id;
		}

		lock_table_dequeue(lock);

		lock = UT_LIST_GET_LAST(trx->trx_locks);
		continue;
		}

		if (count == LOCK_RELEASE_KERNEL_INTERVAL) {
		/* Release the kernel mutex for a while, so that we
		do not monopolize it */

		lock_mutex_exit_kernel();

		lock_mutex_enter_kernel();

		count = 0;
		}

		lock = UT_LIST_GET_PREV(trx_locks, lock);
		}

		ut_a(trx->n_lock_table_exp == 0);
		ut_a(trx->n_lock_table_transactional == 0);
		}

		/*************************************************************************
		@@ -4040,15 +3940,7 @@ lock_table_print(
		#ifdef UNIV_SYNC_DEBUG
		ut_ad(mutex_own(&kernel_mutex));
		#endif /* UNIV_SYNC_DEBUG */
		ut_a(lock_get_type(lock) == LOCK_TABLE \|\|
		lock_get_type(lock) == LOCK_TABLE_EXP \|\|
		lock_get_type(lock) == LOCK_TABLE_TRANSACTIONAL);

		if (lock_get_type(lock) == LOCK_TABLE_EXP) {
		fputs("EXPLICIT ", file);
		} else if (lock_get_type(lock) == LOCK_TABLE_TRANSACTIONAL) {
		fputs("TRANSACTIONAL ", file);
		}
		ut_a(lock_get_type(lock) == LOCK_TABLE);

		fputs("TABLE LOCK table ", file);
		ut_print_name(file, lock->trx, lock->un_member.tab_lock.table->name);

innobase/row/row0mysql.c

+5 −29

Original line number	Diff line number	Diff line
		@@ -970,25 +970,6 @@ row_lock_table_autoinc_for_mysql(
		return((int) err);
		}

		/*************************************************************************
		Unlocks all table locks explicitly requested by trx (with LOCK TABLES,
		lock type LOCK_TABLE_EXP). */

		void
		row_unlock_tables_for_mysql(
		/========================/
		trx_t* trx) /* in: transaction */
		{
		if (!trx->n_lock_table_exp) {

		return;
		}

		mutex_enter(&kernel_mutex);
		lock_release_tables_off_kernel(trx);
		mutex_exit(&kernel_mutex);
		}

		/*************************************************************************
		Sets a table lock on the table mentioned in prebuilt. */

		@@ -1000,9 +981,10 @@ row_lock_table_for_mysql(
		table handle */
		dict_table_t* table, /* in: table to lock, or NULL
		if prebuilt->table should be
		locked or a
		locked as
		prebuilt->select_lock_type */
		ulint mode) /* in: lock mode of table */
		ulint mode) /* in: lock mode of table
		(ignored if table==NULL) */
		{
		trx_t* trx = prebuilt->trx;
		que_thr_t* thr;
		@@ -1038,15 +1020,9 @@ row_lock_table_for_mysql(
		if (table) {
		err = lock_table(0, table, mode, thr);
		} else {
		if (mode == LOCK_TABLE_TRANSACTIONAL) {
		err = lock_table(LOCK_TABLE_TRANSACTIONAL,
		prebuilt->table,
		prebuilt->select_lock_type, thr);
		} else {
		err = lock_table(LOCK_TABLE_EXP, prebuilt->table,
		err = lock_table(0, prebuilt->table,
		prebuilt->select_lock_type, thr);
		}
		}

		trx->error_state = err;