innodb 트 랜 잭 션 잠 금 의 일반적인 데이터 구조
17472 단어 데이터 구조 와 알고리즘데이터 뱅 크
전체 innodb 의 잠 금 시스템 관리 구조 체 는 lock0 lock. h 에 정의 되 어 있 습 니 다.lock 0 lock. cc 에 lock 이 있 습 니 다.sys_t 의 전역 포인터 locksys, locksys_create 할당.
/** The lock system struct */
struct lock_sys_t{
char pad1[CACHE_LINE_SIZE]; /*!< padding to prevent other
memory update hotspots from
residing on the same memory
cache line */
LockMutex mutex; /*!< Mutex protecting the
locks */
/* */
hash_table_t* rec_hash; /*!< hash table of the record
locks */
/* */
hash_table_t* prdt_hash; /*!< hash table of the predicate
lock */
/* */
hash_table_t* prdt_page_hash; /*!< hash table of the page
lock */
char pad2[CACHE_LINE_SIZE]; /*!< Padding */
LockMutex wait_mutex; /*!< Mutex protecting the
next two fields */
/* */
srv_slot_t* waiting_threads; /*!< Array of user threads
suspended while waiting for
locks within InnoDB, protected
by the lock_sys->wait_mutex */
/* , */
srv_slot_t* last_slot; /*!< highest slot ever used
in the waiting_threads array,
protected by
lock_sys->wait_mutex */
ibool rollback_complete;
/*!< TRUE if rollback of all
recovered transactions is
complete. Protected by
lock_sys->mutex */
ulint n_lock_max_wait_time; /*!< Max wait time */
/* */
os_event_t timeout_event; /*!< Set to the event that is
created in the lock wait monitor
thread. A value of 0 means the
thread is not active */
bool timeout_thread_active; /*!< True if the timeout thread
is running */
};
그 중의 rechash,prdt_hash, prdt_page_hash 는 줄 자물쇠, 시계 자물쇠, 페이지 자물쇠 의 해시 표 입 니 다.
lock_rec_t
잠 금 을 기록 하 는 구조 체 를 설명 하고 lock0priv. h 로 정의 합 니 다.
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;
};
기록 잠 금 통과 space: pageno:heap_no 로 유일 하 게 확인, space 와 pageno. 해시 표 에서 사용 하 는 key 를 계산 합 니 다. 이 구조 체 는 실제 적 으로 분 배 된 메모리 가 그 자체 보다 큽 니 다. 뒤에 바짝 붙 어 있 는 것 은 하나의 비트 맵 입 니 다. 모든 비트 는 이 페이지 에 있 는 기록 에 자 물 쇠 를 추가 해 야 하 는 지 여 부 를 나타 내 는 데 사 용 됩 니 다. 모든 비트 의 오프셋 은 모든 기록 의 힙 입 니 다.no。
lock_table_t
표 잠 금 구조 체, lock0priv. h 에 정의
/** A table lock */
struct lock_table_t {
/* */
dict_table_t* table; /*!< database table in dictionary
cache */
/* */
UT_LIST_NODE_T(lock_t)
locks; /*!< list of locks on the same
table */
/** Print the table 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;
};
lock_t
lock0prive. h 에서 통용 되 는 자물쇠 구조 체 유형 을 정의 합 니 다. 각종 유형의 자 물 쇠 는 이런 구조 체 로 표현 할 수 있 습 니 다. locksys_t 의 해시 표 에 저 장 된 자물쇠 도 이런 유형의 자물쇠 구조 체 이다.
/** Lock struct; protected by lock_sys->mutex */
struct lock_t {
/* */
trx_t* trx; /*!< transaction owning the
lock */
/* */
UT_LIST_NODE_T(lock_t)
trx_locks; /*!< list of the locks of the
transaction */
dict_index_t* index; /*!< index for a record lock */
/* key */
lock_t* hash; /*!< hash chain node for a record
lock. The link node in a singly linked
list, used during hashing. */
/* lock_table_t, lock_rec_t, type_mode */
union {
lock_table_t tab_lock;/*!< table lock */
lock_rec_t rec_lock;/*!< record lock */
} un_member; /*!< lock details */
/* ,type_mode lock0lock.h (LOCK_GAP )*/
ib_uint32_t type_mode; /*!< lock type, mode, LOCK_GAP or
LOCK_REC_NOT_GAP,
LOCK_INSERT_INTENTION,
wait flag, ORed */
/** Determine if the lock object is a record lock.
@return true if record lock, false otherwise. */
bool is_record_lock() const
{
return(type() == LOCK_REC);
}
bool is_waiting() const
{
return(type_mode & LOCK_WAIT);
}
bool is_gap() const
{
return(type_mode & LOCK_GAP);
}
bool is_record_not_gap() const
{
return(type_mode & LOCK_REC_NOT_GAP);
}
bool is_insert_intention() const
{
return(type_mode & LOCK_INSERT_INTENTION);
}
ulint type() const {
return(type_mode & LOCK_TYPE_MASK);
}
enum lock_mode mode() const
{
return(static_cast(type_mode & LOCK_MODE_MASK));
}
/** Print the lock object into the given output stream.
@param[in,out] out the output stream
@return the given output stream. */
std::ostream& print(std::ostream& out) const;
/** Convert the member 'type_mode' into a human readable string.
@return human readable string */
std::string type_mode_string() const;
const char* type_string() const
{
switch (type_mode & LOCK_TYPE_MASK) {
case LOCK_REC:
return("LOCK_REC");
case LOCK_TABLE:
return("LOCK_TABLE");
default:
ut_error;
}
}
};
trx_t
이 구조 체 는 하나의 사 무 를 대표 하 는데 자물쇠 시스템 에서 주로 구성원 trxlock_t
struct trx_t {
···
trx_lock_t lock; /*!< Information about the transaction
locks and state. Protected by
trx->mutex or lock_sys->mutex
or both */
···
}
trx_lock_t
트 랜 잭 션 처리 중 잠 금 시스템 과 관련 된 부분 은 trx 입 니 다.t 의 멤버
struct trx_lock_t {
ulint n_active_thrs; /*!< number of active query threads */
/* */
trx_que_t que_state; /*!< valid when trx->state
== TRX_STATE_ACTIVE: TRX_QUE_RUNNING,
TRX_QUE_LOCK_WAIT, ... */
/* */
lock_t* wait_lock; /*!< if trx execution state is
TRX_QUE_LOCK_WAIT, this points to
the lock request, otherwise this is
NULL; set to non-NULL when holding
both trx->mutex and lock_sys->mutex;
set to NULL when holding
lock_sys->mutex; readers should
hold lock_sys->mutex, except when
they are holding trx->mutex and
wait_lock==NULL */
/* */
ib_uint64_t deadlock_mark; /*!< A mark field that is initialized
to and checked against lock_mark_counter
by lock_deadlock_recursive(). */
/* , */
bool was_chosen_as_deadlock_victim;
/*!< when the transaction decides to
wait for a lock, it sets this to false;
if another transaction chooses this
transaction as a victim in deadlock
resolution, it sets this to true.
Protected by trx->mutex. */
time_t wait_started; /*!< lock wait started at this time,
protected only by lock_sys->mutex */
que_thr_t* wait_thr; /*!< query thread belonging to this
trx that is in QUE_THR_LOCK_WAIT
state. For threads suspended in a
lock wait, this is protected by
lock_sys->mutex. Otherwise, this may
only be modified by the thread that is
serving the running transaction. */
lock_pool_t rec_pool; /*!< Pre-allocated record locks */
lock_pool_t table_pool; /*!< Pre-allocated table locks */
ulint rec_cached; /*!< Next free rec lock in pool */
ulint table_cached; /*!< Next free table lock in pool */
mem_heap_t* lock_heap; /*!< memory heap for trx_locks;
protected by lock_sys->mutex */
/* */
trx_lock_list_t trx_locks; /*!< locks requested by the transaction;
insertions are protected by trx->mutex
and lock_sys->mutex; removals are
protected by lock_sys->mutex */
lock_pool_t table_locks; /*!< All table locks requested by this
transaction, including AUTOINC locks */
bool cancel; /*!< true if the transaction is being
rolled back either via deadlock
detection or due to lock timeout. The
caller has to acquire the trx_t::mutex
in order to cancel the locks. In
lock_trx_table_locks_remove() we
check for this cancel of a transaction's
locks and avoid reacquiring the trx
mutex to prevent recursive deadlocks.
Protected by both the lock sys mutex
and the trx_t::mutex. */
ulint n_rec_locks; /*!< number of rec locks in this trx */
/** The transaction called ha_innobase::start_stmt() to
lock a table. Most likely a temporary table. */
bool start_stmt;
};
DeadlockChecker
자물쇠 검사 류 는 자 물 쇠 를 추가 할 때마다 이 종 류 를 사용 하여 자물쇠 검 사 를 한다.
/** Deadlock checker. */
class DeadlockChecker {
public:
/** Checks if a joining lock request results in a deadlock. If
a deadlock is found this function will resolve the deadlock
by choosing a victim transaction and rolling it back. It
will attempt to resolve all deadlocks. The returned transaction
id will be the joining transaction id or 0 if some other
transaction was chosen as a victim and rolled back or no
deadlock found.
@param lock lock the transaction is requesting
@param trx transaction requesting the lock
@return id of transaction chosen as victim or 0 */
/* */
static const trx_t* check_and_resolve(
const lock_t* lock,
trx_t* trx);
private:
/* , check_and_resolve DeadlockChecker */
/** Do a shallow copy. Default destructor OK.
@param trx the start transaction (start node)
@param wait_lock lock that a transaction wants
@param mark_start visited node counter */
DeadlockChecker(
const trx_t* trx,
const lock_t* wait_lock,
ib_uint64_t mark_start)
:
m_cost(),
m_start(trx),
m_too_deep(),
m_wait_lock(wait_lock),
m_mark_start(mark_start),
m_n_elems()
{
}
/** Check if the search is too deep. */
bool is_too_deep() const
{
return(m_n_elems > LOCK_MAX_DEPTH_IN_DEADLOCK_CHECK
|| m_cost > LOCK_MAX_N_STEPS_IN_DEADLOCK_CHECK);
}
/** Save current state.
@param lock lock to push on the stack.
@param heap_no the heap number to push on the stack.
@return false if stack is full. */
bool push(const lock_t* lock, ulint heap_no)
{
ut_ad((lock_get_type_low(lock) & LOCK_REC)
|| (lock_get_type_low(lock) & LOCK_TABLE));
ut_ad(((lock_get_type_low(lock) & LOCK_TABLE) != 0)
== (heap_no == ULINT_UNDEFINED));
/* Ensure that the stack is bounded. */
if (m_n_elems >= UT_ARR_SIZE(s_states)) {
return(false);
}
state_t& state = s_states[m_n_elems++];
state.m_lock = lock;
state.m_wait_lock = m_wait_lock;
state.m_heap_no =heap_no;
return(true);
}
/** Restore state.
@param[out] lock current lock
@param[out] heap_no current heap_no */
void pop(const lock_t*& lock, ulint& heap_no)
{
ut_a(m_n_elems > 0);
const state_t& state = s_states[--m_n_elems];
lock = state.m_lock;
heap_no = state.m_heap_no;
m_wait_lock = state.m_wait_lock;
}
/** Check whether the node has been visited.
@param lock lock to check
@return true if the node has been visited */
bool is_visited(const lock_t* lock) const
{
return(lock->trx->lock.deadlock_mark > m_mark_start);
}
/** Get the next lock in the queue that is owned by a transaction
whose sub-tree has not already been searched.
Note: "next" here means PREV for table locks.
@param lock Lock in queue
@param heap_no heap_no if lock is a record lock else ULINT_UNDEFINED
@return next lock or NULL if at end of queue */
const lock_t* get_next_lock(const lock_t* lock, ulint heap_no) const;
/** Get the first lock to search. The search starts from the current
wait_lock. What we are really interested in is an edge from the
current wait_lock's owning transaction to another transaction that has
a lock ahead in the queue. We skip locks where the owning transaction's
sub-tree has already been searched.
Note: The record locks are traversed from the oldest lock to the
latest. For table locks we go from latest to oldest.
For record locks, we first position the iterator on first lock on
the page and then reposition on the actual heap_no. This is required
due to the way the record lock has is implemented.
@param[out] heap_no if rec lock, else ULINT_UNDEFINED.
@return first lock or NULL */
const lock_t* get_first_lock(ulint* heap_no) const;
/** Notify that a deadlock has been detected and print the conflicting
transaction info.
@param lock lock causing deadlock */
void notify(const lock_t* lock) const;
/** Select the victim transaction that should be rolledback.
@return victim transaction */
const trx_t* select_victim() const;
/** Rollback transaction selected as the victim. */
void trx_rollback();
/** Looks iteratively for a deadlock. Note: the joining transaction
may have been granted its lock by the deadlock checks.
@return 0 if no deadlock else the victim transaction.*/
const trx_t* search();
/** Print transaction data to the deadlock file and possibly to stderr.
@param trx transaction
@param max_query_len max query length to print */
static void print(const trx_t* trx, ulint max_query_len);
/** rewind(3) the file used for storing the latest detected deadlock
and print a heading message to stderr if printing of all deadlocks to
stderr is enabled. */
static void start_print();
/** Print lock data to the deadlock file and possibly to stderr.
@param lock record or table type lock */
static void print(const lock_t* lock);
/** Print a message to the deadlock file and possibly to stderr.
@param msg message to print */
static void print(const char* msg);
/** Print info about transaction that was rolled back.
@param trx transaction rolled back
@param lock lock trx wants */
static void rollback_print(const trx_t* trx, const lock_t* lock);
private:
/** DFS state information, used during deadlock checking. */
struct state_t {
const lock_t* m_lock; /*!< Current lock */
const lock_t* m_wait_lock; /*!< Waiting for lock */
ulint m_heap_no; /*!< heap number if rec lock */
};
/** Used in deadlock tracking. Protected by lock_sys->mutex. */
static ib_uint64_t s_lock_mark_counter;
/** Calculation steps thus far. It is the count of the nodes visited. */
ulint m_cost;
/** Joining transaction that is requesting a lock in an
incompatible mode */
const trx_t* m_start;
/** TRUE if search was too deep and was aborted */
bool m_too_deep;
/** Lock that trx wants */
const lock_t* m_wait_lock;
/** Value of lock_mark_count at the start of the deadlock check. */
ib_uint64_t m_mark_start;
/** Number of states pushed onto the stack */
size_t m_n_elems;
/** This is to avoid malloc/free calls. */
static state_t s_states[MAX_STACK_SIZE];
};
다음으로 전송:https://www.cnblogs.com/FateTHarlaown/p/9364091.html
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
[JAVA] 배열 회전 출력요소 가 출력 을 시작 하 는 위치 에 주의 하 십시오. 모두 몇 라운드 의 수출 이 있 습 니까? n/2 + 1 매 라 운 드 는 상, 우, 하, 좌 로 나 뉜 다. 각 방향의 시작 위치 와 좌표 의 관 계 를 구...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.