2005c88a75
Summary: This is an implementation of non-exclusive locks for pessimistic transactions. It is relatively simple and does not prevent starvation (ie. it's possible that request for exclusive access will never be granted if there are always threads holding shared access). It is done by changing `KeyLockInfo` to hold an set a transaction ids, instead of just one, and adding a flag specifying whether this lock is currently held with exclusive access or not. Some implementation notes: - Some lock diagnostic functions had to be updated to return a set of transaction ids for a given lock, eg. `GetWaitingTxn` and `GetLockStatusData`. - Deadlock detection is a bit more complicated since a transaction can now wait on multiple other transactions. A BFS is done in this case, and deadlock detection depth is now just a limit on the number of transactions we visit. - Expirable transactions do not work efficiently with shared locks at the moment, but that's okay for now. Closes https://github.com/facebook/rocksdb/pull/1573 Differential Revision: D4239097 Pulled By: lth fbshipit-source-id: da7c074
128 lines
4.7 KiB
C++
128 lines
4.7 KiB
C++
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
|
// This source code is licensed under the BSD-style license found in the
|
|
// LICENSE file in the root directory of this source tree. An additional grant
|
|
// of patent rights can be found in the PATENTS file in the same directory.
|
|
|
|
#pragma once
|
|
#ifndef ROCKSDB_LITE
|
|
|
|
#include <mutex>
|
|
#include <queue>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
#include "rocksdb/db.h"
|
|
#include "rocksdb/options.h"
|
|
#include "rocksdb/utilities/transaction_db.h"
|
|
#include "utilities/transactions/transaction_impl.h"
|
|
#include "utilities/transactions/transaction_lock_mgr.h"
|
|
|
|
namespace rocksdb {
|
|
|
|
class TransactionDBImpl : public TransactionDB {
|
|
public:
|
|
explicit TransactionDBImpl(DB* db,
|
|
const TransactionDBOptions& txn_db_options);
|
|
|
|
explicit TransactionDBImpl(StackableDB* db,
|
|
const TransactionDBOptions& txn_db_options);
|
|
|
|
~TransactionDBImpl();
|
|
|
|
Status Initialize(const std::vector<size_t>& compaction_enabled_cf_indices,
|
|
const std::vector<ColumnFamilyHandle*>& handles);
|
|
|
|
Transaction* BeginTransaction(const WriteOptions& write_options,
|
|
const TransactionOptions& txn_options,
|
|
Transaction* old_txn) override;
|
|
|
|
using StackableDB::Put;
|
|
virtual Status Put(const WriteOptions& options,
|
|
ColumnFamilyHandle* column_family, const Slice& key,
|
|
const Slice& val) override;
|
|
|
|
using StackableDB::Delete;
|
|
virtual Status Delete(const WriteOptions& wopts,
|
|
ColumnFamilyHandle* column_family,
|
|
const Slice& key) override;
|
|
|
|
using StackableDB::Merge;
|
|
virtual Status Merge(const WriteOptions& options,
|
|
ColumnFamilyHandle* column_family, const Slice& key,
|
|
const Slice& value) override;
|
|
|
|
using StackableDB::Write;
|
|
virtual Status Write(const WriteOptions& opts, WriteBatch* updates) override;
|
|
|
|
using StackableDB::CreateColumnFamily;
|
|
virtual Status CreateColumnFamily(const ColumnFamilyOptions& options,
|
|
const std::string& column_family_name,
|
|
ColumnFamilyHandle** handle) override;
|
|
|
|
using StackableDB::DropColumnFamily;
|
|
virtual Status DropColumnFamily(ColumnFamilyHandle* column_family) override;
|
|
|
|
Status TryLock(TransactionImpl* txn, uint32_t cfh_id, const std::string& key,
|
|
bool exclusive);
|
|
|
|
void UnLock(TransactionImpl* txn, const TransactionKeyMap* keys);
|
|
void UnLock(TransactionImpl* txn, uint32_t cfh_id, const std::string& key);
|
|
|
|
void AddColumnFamily(const ColumnFamilyHandle* handle);
|
|
|
|
static TransactionDBOptions ValidateTxnDBOptions(
|
|
const TransactionDBOptions& txn_db_options);
|
|
|
|
const TransactionDBOptions& GetTxnDBOptions() const {
|
|
return txn_db_options_;
|
|
}
|
|
|
|
void InsertExpirableTransaction(TransactionID tx_id, TransactionImpl* tx);
|
|
void RemoveExpirableTransaction(TransactionID tx_id);
|
|
|
|
// If transaction is no longer available, locks can be stolen
|
|
// If transaction is available, try stealing locks directly from transaction
|
|
// It is the caller's responsibility to ensure that the referred transaction
|
|
// is expirable (GetExpirationTime() > 0) and that it is expired.
|
|
bool TryStealingExpiredTransactionLocks(TransactionID tx_id);
|
|
|
|
Transaction* GetTransactionByName(const TransactionName& name) override;
|
|
|
|
void RegisterTransaction(Transaction* txn);
|
|
void UnregisterTransaction(Transaction* txn);
|
|
|
|
// not thread safe. current use case is during recovery (single thread)
|
|
void GetAllPreparedTransactions(std::vector<Transaction*>* trans) override;
|
|
|
|
TransactionLockMgr::LockStatusData GetLockStatusData() override;
|
|
|
|
private:
|
|
void ReinitializeTransaction(
|
|
Transaction* txn, const WriteOptions& write_options,
|
|
const TransactionOptions& txn_options = TransactionOptions());
|
|
|
|
DBImpl* db_impl_;
|
|
const TransactionDBOptions txn_db_options_;
|
|
TransactionLockMgr lock_mgr_;
|
|
|
|
// Must be held when adding/dropping column families.
|
|
InstrumentedMutex column_family_mutex_;
|
|
Transaction* BeginInternalTransaction(const WriteOptions& options);
|
|
Status WriteHelper(WriteBatch* updates, TransactionImpl* txn_impl);
|
|
|
|
// Used to ensure that no locks are stolen from an expirable transaction
|
|
// that has started a commit. Only transactions with an expiration time
|
|
// should be in this map.
|
|
std::mutex map_mutex_;
|
|
std::unordered_map<TransactionID, TransactionImpl*>
|
|
expirable_transactions_map_;
|
|
|
|
// map from name to two phase transaction instance
|
|
std::mutex name_map_mutex_;
|
|
std::unordered_map<TransactionName, Transaction*> transactions_;
|
|
};
|
|
|
|
} // namespace rocksdb
|
|
#endif // ROCKSDB_LITE
|