浅析MySQL死锁检测

*** (1) WAITING FOR THIS LOCK TO BE GRANTED:
RECORD LOCKS space id 124 page no 4 n bits 80 index idx_id of table `dhy`.`t` trx id 45909 lock_mode X waiting
Record lock, heap no 2 PHYSICAL RECORD: n_fields 2; compact format; info bits 32
 0: len 4; hex 80000002; asc     ;;
 1: len 6; hex 000000000601; asc       ;;

struct lock_rec_t {
	ib_uint32_t	space;		/*!< space id */
	ib_uint32_t	page_no;	/*!< page number */
	ib_uint32_t	n_bits;		/*!< number of bits in the lock
					bitmap; NOTE: the lock bitmap is
					placed immediately after the
					lock struct */ 

	/** Print the record lock into the given output stream
	@param[in,out]	out	the output stream
	@return the given output stream. */
	std::ostream& print(std::ostream& out) const;
};

rec_lock.n_bits = static_cast<uint32_t>(8 * size);

size大小:
static size_t lock_size(const page_t* page)
	{
		ulint	n_recs = page_dir_get_n_heap(page);

		/* Make lock bitmap bigger by a safety margin */

		return(1 + ((n_recs + LOCK_PAGE_BITMAP_MARGIN) / 8));
	}

ulint		n_bytes = size + sizeof(*lock);
mem_heap_t*	heap = trx->lock.lock_heap;

lock = reinterpret_cast<lock_t*>(mem_heap_alloc(heap, n_bytes));

lock_rec_set_nth_bit(
/*=================*/
	lock_t*	lock,	/*!< in: record lock */
	ulint	i)	/*!< in: index of the bit */
{
	ulint	byte_index; 
	ulint	bit_index;

	byte_index = i / 8; //标识第几个字节 
	bit_index = i % 8; //标识字节中的第几位

	((byte*) &lock[1])[byte_index] |= 1 << bit_index; //将对应byte上相应的bit位设置为1

	++lock->trx->lock.n_rec_locks;
}

ulint	key = m_rec_id.fold();

++lock->index->table->n_rec_locks;

HASH_INSERT(lock_t, hash, lock_hash_get(m_mode), key, lock);


/**
	@return the "folded" value of {space, page_no} */
ulint fold() const
{
	return(m_fold);
}
    
        

UNIV_INLINE
ibool
lock_rec_get_nth_bit(
/*=================*/
	const lock_t*	lock,	/*!< in: record lock */
	ulint		i)	/*!< in: index of the bit */
{
	const byte*     b;


	if (i >= lock->un_member.rec_lock.n_bits) {

		return(FALSE);
	}

	b = ((const byte*) &lock[1]) + (i / 8);  //根据i(也就是heap_no)计算出是lock之后的第几个字节

	return(1 & *b >> (i % 8)); //判断对应的bit位上是否为1
}

DeadlockChecker::get_first_lock(ulint* heap_no) const
{

	const lock_t*	lock = m_wait_lock;

	if (lock_get_type_low(lock) == LOCK_REC) {
		hash_table_t*	lock_hash;

		lock_hash = lock->type_mode & LOCK_PREDICATE
			? lock_sys->prdt_hash
			: lock_sys->rec_hash;

		/* We are only interested in records that match the heap_no. */
		*heap_no = lock_rec_find_set_bit(lock); // 查找lock对应的heap_no


		/* Find the locks on the page. */
		lock = lock_rec_get_first_on_page_addr(
			lock_hash,
			lock->un_member.rec_lock.space,
			lock->un_member.rec_lock.page_no); //找出page上的第一个lock

		/* Position on the first lock on the physical record.*/
		if (!lock_rec_get_nth_bit(lock, *heap_no)) { //如果lock的bitmap对应bit位上存在锁，则返回lock，否则查找下一个lock，直到对应bit位上存在锁
			lock = lock_rec_get_next_const(*heap_no, lock);
		}

	} else {
		/* Table locks don't care about the heap_no. */
		*heap_no = ULINT_UNDEFINED;
		dict_table_t*	table = lock->un_member.tab_lock.table;
		lock = UT_LIST_GET_FIRST(table->locks);
	}

	return(lock);
}