Struct tikv::server::lock_manager::LockManager

pub struct LockManager {
    waiter_mgr_worker: Option<FutureWorker<Task>>,
    detector_worker: Option<FutureWorker<Task>>,
    waiter_mgr_scheduler: WaiterMgrScheduler,
    detector_scheduler: DetectorScheduler,
    waiter_count: Arc<AtomicUsize>,
    detected: Arc<[CachePadded<Mutex<HashSet<TimeStamp>>>]>,
    pipelined: Arc<AtomicBool>,
}

LockManager has two components working in two threads:

• One is the WaiterManager which manages transactions waiting for locks.
• The other one is the Detector which detects deadlocks between transactions.

Fields

waiter_mgr_worker: Option<FutureWorker<Task>>

detector_worker: Option<FutureWorker<Task>>

waiter_mgr_scheduler: WaiterMgrScheduler

detector_scheduler: DetectorScheduler

waiter_count: Arc<AtomicUsize>

detected: Arc<[CachePadded<Mutex<HashSet<TimeStamp>>>]>

Record transactions which have sent requests to detect deadlock.

pipelined: Arc<AtomicBool>

Implementations

impl LockManager

pub fn new(pipelined: bool) -> Self

pub fn start<S, P>(
    &mut self,
    store_id: u64,
    pd_client: Arc<P>,
    resolver: S,
    security_mgr: Arc<SecurityManager>,
    cfg: &Config
) -> Result<()> where
    S: StoreAddrResolver + 'static,
    P: PdClient + 'static, 

Starts WaiterManager and Detector.

pub fn stop(&mut self)

Stops WaiterManager and Detector.

fn start_waiter_manager(&mut self, cfg: &Config) -> Result<()>

fn stop_waiter_manager(&mut self)

fn start_deadlock_detector<S, P>(
    &mut self,
    store_id: u64,
    pd_client: Arc<P>,
    resolver: S,
    security_mgr: Arc<SecurityManager>,
    cfg: &Config
) -> Result<()> where
    S: StoreAddrResolver + 'static,
    P: PdClient + 'static, 

fn stop_deadlock_detector(&mut self)

pub fn register_detector_role_change_observer(
    &self,
    host: &mut CoprocessorHost<impl KvEngine>
)

Creates a RoleChangeNotifier of the deadlock detector worker and registers it to the CoprocessorHost to observe the role change events of the leader region.

pub fn deadlock_service(&self) -> DeadlockService

Creates a DeadlockService to handle deadlock detect requests from other nodes.

pub fn config_manager(&self) -> LockManagerConfigManager

pub fn get_pipelined(&self) -> Arc<AtomicBool>

fn add_to_detected(&self, txn_ts: TimeStamp)

fn remove_from_detected(&self, txn_ts: TimeStamp) -> bool

Trait Implementations

impl Clone for LockManager

fn clone(&self) -> Self

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl LockManager for LockManager

fn wait_for(
    &self,
    start_ts: TimeStamp,
    cb: StorageCallback,
    pr: ProcessResult,
    lock: Lock,
    is_first_lock: bool,
    timeout: Option<WaitTimeout>,
    diag_ctx: DiagnosticContext
)

Transaction with start_ts waits for lock released.

fn wake_up(
    &self,
    lock_ts: TimeStamp,
    hashes: Vec<u64>,
    commit_ts: TimeStamp,
    is_pessimistic_txn: bool
)

The locks with lock_ts and hashes are released, tries to wake up transactions.

fn has_waiter(&self) -> bool

Returns true if there are waiters in the LockManager.

fn dump_wait_for_entries(&self, cb: Callback)