Range Locking: Implementation of range locking (#7506)
Summary: Range Locking - an implementation based on the locktree library - Add a RangeTreeLockManager and RangeTreeLockTracker which implement range locking using the locktree library. - Point locks are handled as locks on single-point ranges. - Add a unit test: range_locking_test Pull Request resolved: https://github.com/facebook/rocksdb/pull/7506 Reviewed By: akankshamahajan15 Differential Revision: D25320703 Pulled By: cheng-chang fbshipit-source-id: f86347384b42ba2b0257d67eca0f45f806b69da7main
Sergei Petrunia
4 years ago
committed by
Facebook GitHub Bot
parent
f4db3e4119
commit
daab7603f6
@ -0,0 +1,304 @@ |
|||||||
|
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
||||||
|
// This source code is licensed under both the GPLv2 (found in the
|
||||||
|
// COPYING file in the root directory) and Apache 2.0 License
|
||||||
|
// (found in the LICENSE.Apache file in the root directory).
|
||||||
|
|
||||||
|
#ifndef ROCKSDB_LITE |
||||||
|
#ifndef OS_WIN |
||||||
|
|
||||||
|
#include <algorithm> |
||||||
|
#include <functional> |
||||||
|
#include <string> |
||||||
|
#include <thread> |
||||||
|
|
||||||
|
#include "db/db_impl/db_impl.h" |
||||||
|
#include "port/port.h" |
||||||
|
#include "rocksdb/db.h" |
||||||
|
#include "rocksdb/options.h" |
||||||
|
#include "rocksdb/perf_context.h" |
||||||
|
#include "rocksdb/utilities/transaction.h" |
||||||
|
#include "rocksdb/utilities/transaction_db.h" |
||||||
|
#include "utilities/transactions/lock/point/point_lock_manager_test.h" |
||||||
|
#include "utilities/transactions/pessimistic_transaction_db.h" |
||||||
|
#include "utilities/transactions/transaction_test.h" |
||||||
|
|
||||||
|
using std::string; |
||||||
|
|
||||||
|
namespace ROCKSDB_NAMESPACE { |
||||||
|
|
||||||
|
class RangeLockingTest : public ::testing::Test { |
||||||
|
public: |
||||||
|
TransactionDB* db; |
||||||
|
std::string dbname; |
||||||
|
Options options; |
||||||
|
|
||||||
|
std::shared_ptr<RangeLockManagerHandle> range_lock_mgr; |
||||||
|
TransactionDBOptions txn_db_options; |
||||||
|
|
||||||
|
RangeLockingTest() : db(nullptr) { |
||||||
|
options.create_if_missing = true; |
||||||
|
dbname = test::PerThreadDBPath("range_locking_testdb"); |
||||||
|
|
||||||
|
DestroyDB(dbname, options); |
||||||
|
|
||||||
|
range_lock_mgr.reset(NewRangeLockManager(nullptr)); |
||||||
|
txn_db_options.lock_mgr_handle = range_lock_mgr; |
||||||
|
|
||||||
|
auto s = TransactionDB::Open(options, txn_db_options, dbname, &db); |
||||||
|
assert(s.ok()); |
||||||
|
} |
||||||
|
|
||||||
|
~RangeLockingTest() { |
||||||
|
delete db; |
||||||
|
db = nullptr; |
||||||
|
// This is to skip the assert statement in FaultInjectionTestEnv. There
|
||||||
|
// seems to be a bug in btrfs that the makes readdir return recently
|
||||||
|
// unlink-ed files. By using the default fs we simply ignore errors resulted
|
||||||
|
// from attempting to delete such files in DestroyDB.
|
||||||
|
DestroyDB(dbname, options); |
||||||
|
} |
||||||
|
|
||||||
|
PessimisticTransaction* NewTxn( |
||||||
|
TransactionOptions txn_opt = TransactionOptions()) { |
||||||
|
Transaction* txn = db->BeginTransaction(WriteOptions(), txn_opt); |
||||||
|
return reinterpret_cast<PessimisticTransaction*>(txn); |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
// TODO: set a smaller lock wait timeout so that the test runs faster.
|
||||||
|
TEST_F(RangeLockingTest, BasicRangeLocking) { |
||||||
|
WriteOptions write_options; |
||||||
|
TransactionOptions txn_options; |
||||||
|
std::string value; |
||||||
|
ReadOptions read_options; |
||||||
|
auto cf = db->DefaultColumnFamily(); |
||||||
|
|
||||||
|
Transaction* txn0 = db->BeginTransaction(write_options, txn_options); |
||||||
|
Transaction* txn1 = db->BeginTransaction(write_options, txn_options); |
||||||
|
|
||||||
|
// Get a range lock
|
||||||
|
ASSERT_OK(txn0->GetRangeLock(cf, Endpoint("a"), Endpoint("c"))); |
||||||
|
|
||||||
|
// Check that range Lock inhibits an overlapping range lock
|
||||||
|
{ |
||||||
|
auto s = txn1->GetRangeLock(cf, Endpoint("b"), Endpoint("z")); |
||||||
|
ASSERT_TRUE(s.IsTimedOut()); |
||||||
|
} |
||||||
|
|
||||||
|
// Check that range Lock inhibits an overlapping point lock
|
||||||
|
{ |
||||||
|
auto s = txn1->GetForUpdate(read_options, cf, Slice("b"), &value); |
||||||
|
ASSERT_TRUE(s.IsTimedOut()); |
||||||
|
} |
||||||
|
|
||||||
|
// Get a point lock, check that it inhibits range locks
|
||||||
|
ASSERT_OK(txn0->Put(cf, Slice("n"), Slice("value"))); |
||||||
|
{ |
||||||
|
auto s = txn1->GetRangeLock(cf, Endpoint("m"), Endpoint("p")); |
||||||
|
ASSERT_TRUE(s.IsTimedOut()); |
||||||
|
} |
||||||
|
|
||||||
|
ASSERT_OK(txn0->Commit()); |
||||||
|
txn1->Rollback(); |
||||||
|
|
||||||
|
delete txn0; |
||||||
|
delete txn1; |
||||||
|
} |
||||||
|
|
||||||
|
TEST_F(RangeLockingTest, MyRocksLikeUpdate) { |
||||||
|
WriteOptions write_options; |
||||||
|
TransactionOptions txn_options; |
||||||
|
Transaction* txn0 = db->BeginTransaction(write_options, txn_options); |
||||||
|
auto cf = db->DefaultColumnFamily(); |
||||||
|
Status s; |
||||||
|
|
||||||
|
// Get a range lock for the range we are about to update
|
||||||
|
ASSERT_OK(txn0->GetRangeLock(cf, Endpoint("a"), Endpoint("c"))); |
||||||
|
|
||||||
|
bool try_range_lock_called = false; |
||||||
|
|
||||||
|
ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack( |
||||||
|
"RangeTreeLockManager::TryRangeLock:enter", |
||||||
|
[&](void* /*arg*/) { try_range_lock_called = true; }); |
||||||
|
ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing(); |
||||||
|
|
||||||
|
// For performance reasons, the following must NOT call lock_mgr->TryLock():
|
||||||
|
// We verify that by checking the value of try_range_lock_called.
|
||||||
|
ASSERT_OK(txn0->Put(cf, Slice("b"), Slice("value"), |
||||||
|
/*assume_tracked=*/true)); |
||||||
|
|
||||||
|
ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing(); |
||||||
|
ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks(); |
||||||
|
ASSERT_FALSE(try_range_lock_called); |
||||||
|
|
||||||
|
txn0->Rollback(); |
||||||
|
|
||||||
|
delete txn0; |
||||||
|
} |
||||||
|
|
||||||
|
TEST_F(RangeLockingTest, SnapshotValidation) { |
||||||
|
Status s; |
||||||
|
Slice key_slice = Slice("k"); |
||||||
|
ColumnFamilyHandle* cfh = db->DefaultColumnFamily(); |
||||||
|
|
||||||
|
auto txn0 = NewTxn(); |
||||||
|
txn0->Put(key_slice, Slice("initial")); |
||||||
|
txn0->Commit(); |
||||||
|
|
||||||
|
// txn1
|
||||||
|
auto txn1 = NewTxn(); |
||||||
|
txn1->SetSnapshot(); |
||||||
|
std::string val1; |
||||||
|
ASSERT_OK(txn1->Get(ReadOptions(), cfh, key_slice, &val1)); |
||||||
|
ASSERT_EQ(val1, "initial"); |
||||||
|
val1 = val1 + std::string("-txn1"); |
||||||
|
|
||||||
|
ASSERT_OK(txn1->Put(cfh, key_slice, Slice(val1))); |
||||||
|
|
||||||
|
// txn2
|
||||||
|
auto txn2 = NewTxn(); |
||||||
|
txn2->SetSnapshot(); |
||||||
|
std::string val2; |
||||||
|
// This will see the original value as nothing is committed
|
||||||
|
// This is also Get, so it is doesn't acquire any locks.
|
||||||
|
ASSERT_OK(txn2->Get(ReadOptions(), cfh, key_slice, &val2)); |
||||||
|
ASSERT_EQ(val2, "initial"); |
||||||
|
|
||||||
|
// txn1
|
||||||
|
ASSERT_OK(txn1->Commit()); |
||||||
|
|
||||||
|
// txn2
|
||||||
|
val2 = val2 + std::string("-txn2"); |
||||||
|
// Now, this call should do Snapshot Validation and fail:
|
||||||
|
s = txn2->Put(cfh, key_slice, Slice(val2)); |
||||||
|
ASSERT_TRUE(s.IsBusy()); |
||||||
|
|
||||||
|
ASSERT_OK(txn2->Commit()); |
||||||
|
|
||||||
|
delete txn0; |
||||||
|
delete txn1; |
||||||
|
delete txn2; |
||||||
|
} |
||||||
|
|
||||||
|
TEST_F(RangeLockingTest, MultipleTrxLockStatusData) { |
||||||
|
WriteOptions write_options; |
||||||
|
TransactionOptions txn_options; |
||||||
|
auto cf = db->DefaultColumnFamily(); |
||||||
|
|
||||||
|
Transaction* txn0 = db->BeginTransaction(write_options, txn_options); |
||||||
|
Transaction* txn1 = db->BeginTransaction(write_options, txn_options); |
||||||
|
|
||||||
|
// Get a range lock
|
||||||
|
ASSERT_OK(txn0->GetRangeLock(cf, Endpoint("z"), Endpoint("z"))); |
||||||
|
ASSERT_OK(txn1->GetRangeLock(cf, Endpoint("b"), Endpoint("e"))); |
||||||
|
|
||||||
|
auto s = range_lock_mgr->GetRangeLockStatusData(); |
||||||
|
ASSERT_EQ(s.size(), 2); |
||||||
|
for (auto it = s.begin(); it != s.end(); ++it) { |
||||||
|
ASSERT_EQ(it->first, cf->GetID()); |
||||||
|
auto val = it->second; |
||||||
|
ASSERT_FALSE(val.start.inf_suffix); |
||||||
|
ASSERT_FALSE(val.end.inf_suffix); |
||||||
|
ASSERT_TRUE(val.exclusive); |
||||||
|
ASSERT_EQ(val.ids.size(), 1); |
||||||
|
if (val.ids[0] == txn0->GetID()) { |
||||||
|
ASSERT_EQ(val.start.slice, "z"); |
||||||
|
ASSERT_EQ(val.end.slice, "z"); |
||||||
|
} else if (val.ids[0] == txn1->GetID()) { |
||||||
|
ASSERT_EQ(val.start.slice, "b"); |
||||||
|
ASSERT_EQ(val.end.slice, "e"); |
||||||
|
} else { |
||||||
|
FAIL(); // Unknown transaction ID.
|
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
delete txn0; |
||||||
|
delete txn1; |
||||||
|
} |
||||||
|
|
||||||
|
#if defined(__has_feature) |
||||||
|
#if __has_feature(thread_sanitizer) |
||||||
|
#define SKIP_LOCK_ESCALATION_TEST 1 |
||||||
|
#endif |
||||||
|
#endif |
||||||
|
|
||||||
|
#ifndef SKIP_LOCK_ESCALATION_TEST |
||||||
|
TEST_F(RangeLockingTest, BasicLockEscalation) { |
||||||
|
auto cf = db->DefaultColumnFamily(); |
||||||
|
|
||||||
|
auto counters = range_lock_mgr->GetStatus(); |
||||||
|
|
||||||
|
// Initially not using any lock memory
|
||||||
|
ASSERT_EQ(counters.current_lock_memory, 0); |
||||||
|
ASSERT_EQ(counters.escalation_count, 0); |
||||||
|
|
||||||
|
ASSERT_EQ(0, range_lock_mgr->SetMaxLockMemory(2000)); |
||||||
|
|
||||||
|
// Insert until we see lock escalations
|
||||||
|
auto txn = NewTxn(); |
||||||
|
|
||||||
|
// Get the locks until we hit an escalation
|
||||||
|
for (int i = 0; i < 2020; i++) { |
||||||
|
char buf[32]; |
||||||
|
snprintf(buf, sizeof(buf) - 1, "%08d", i); |
||||||
|
ASSERT_OK(txn->GetRangeLock(cf, Endpoint(buf), Endpoint(buf))); |
||||||
|
} |
||||||
|
counters = range_lock_mgr->GetStatus(); |
||||||
|
ASSERT_GT(counters.escalation_count, 0); |
||||||
|
ASSERT_LE(counters.current_lock_memory, 2000); |
||||||
|
|
||||||
|
delete txn; |
||||||
|
} |
||||||
|
#endif |
||||||
|
|
||||||
|
void PointLockManagerTestExternalSetup(PointLockManagerTest* self) { |
||||||
|
self->env_ = Env::Default(); |
||||||
|
self->db_dir_ = test::PerThreadDBPath("point_lock_manager_test"); |
||||||
|
ASSERT_OK(self->env_->CreateDir(self->db_dir_)); |
||||||
|
|
||||||
|
Options opt; |
||||||
|
opt.create_if_missing = true; |
||||||
|
TransactionDBOptions txn_opt; |
||||||
|
txn_opt.transaction_lock_timeout = 0; |
||||||
|
|
||||||
|
auto mutex_factory = std::make_shared<TransactionDBMutexFactoryImpl>(); |
||||||
|
self->locker_.reset(NewRangeLockManager(mutex_factory)->getLockManager()); |
||||||
|
std::shared_ptr<RangeLockManagerHandle> range_lock_mgr = |
||||||
|
std::dynamic_pointer_cast<RangeLockManagerHandle>(self->locker_); |
||||||
|
txn_opt.lock_mgr_handle = range_lock_mgr; |
||||||
|
|
||||||
|
ASSERT_OK(TransactionDB::Open(opt, txn_opt, self->db_dir_, &self->db_)); |
||||||
|
self->wait_sync_point_name_ = "RangeTreeLockManager::TryRangeLock:WaitingTxn"; |
||||||
|
} |
||||||
|
|
||||||
|
INSTANTIATE_TEST_CASE_P(RangeLockManager, AnyLockManagerTest, |
||||||
|
::testing::Values(PointLockManagerTestExternalSetup)); |
||||||
|
|
||||||
|
} // namespace ROCKSDB_NAMESPACE
|
||||||
|
|
||||||
|
int main(int argc, char** argv) { |
||||||
|
ROCKSDB_NAMESPACE::port::InstallStackTraceHandler(); |
||||||
|
::testing::InitGoogleTest(&argc, argv); |
||||||
|
return RUN_ALL_TESTS(); |
||||||
|
} |
||||||
|
|
||||||
|
#else // OS_WIN
|
||||||
|
|
||||||
|
#include <stdio.h> |
||||||
|
int main(int /*argc*/, char** /*argv*/) { |
||||||
|
fprintf(stderr, "skipped as Range Locking is not supported on Windows\n"); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
#endif // OS_WIN
|
||||||
|
|
||||||
|
#else |
||||||
|
#include <stdio.h> |
||||||
|
|
||||||
|
int main(int /*argc*/, char** /*argv*/) { |
||||||
|
fprintf(stderr, |
||||||
|
"skipped as transactions are not supported in rocksdb_lite\n"); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
#endif // ROCKSDB_LITE
|
||||||
@ -1 +0,0 @@ |
|||||||
Implement LockTracker and LockManager for range lock with range tree. |
|
||||||
@ -0,0 +1,479 @@ |
|||||||
|
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
||||||
|
// This source code is licensed under both the GPLv2 (found in the
|
||||||
|
// COPYING file in the root directory) and Apache 2.0 License
|
||||||
|
// (found in the LICENSE.Apache file in the root directory).
|
||||||
|
|
||||||
|
#ifndef ROCKSDB_LITE |
||||||
|
#ifndef OS_WIN |
||||||
|
|
||||||
|
#include "utilities/transactions/lock/range/range_tree/range_tree_lock_manager.h" |
||||||
|
|
||||||
|
#include <algorithm> |
||||||
|
#include <cinttypes> |
||||||
|
#include <mutex> |
||||||
|
|
||||||
|
#include "monitoring/perf_context_imp.h" |
||||||
|
#include "rocksdb/slice.h" |
||||||
|
#include "rocksdb/utilities/transaction_db_mutex.h" |
||||||
|
#include "test_util/sync_point.h" |
||||||
|
#include "util/cast_util.h" |
||||||
|
#include "util/hash.h" |
||||||
|
#include "util/thread_local.h" |
||||||
|
#include "utilities/transactions/lock/range/range_tree/range_tree_lock_tracker.h" |
||||||
|
#include "utilities/transactions/pessimistic_transaction_db.h" |
||||||
|
#include "utilities/transactions/transaction_db_mutex_impl.h" |
||||||
|
|
||||||
|
namespace ROCKSDB_NAMESPACE { |
||||||
|
|
||||||
|
RangeLockManagerHandle* NewRangeLockManager( |
||||||
|
std::shared_ptr<TransactionDBMutexFactory> mutex_factory) { |
||||||
|
std::shared_ptr<TransactionDBMutexFactory> use_factory; |
||||||
|
|
||||||
|
if (mutex_factory) { |
||||||
|
use_factory = mutex_factory; |
||||||
|
} else { |
||||||
|
use_factory.reset(new TransactionDBMutexFactoryImpl()); |
||||||
|
} |
||||||
|
return new RangeTreeLockManager(use_factory); |
||||||
|
} |
||||||
|
|
||||||
|
static const char SUFFIX_INFIMUM = 0x0; |
||||||
|
static const char SUFFIX_SUPREMUM = 0x1; |
||||||
|
|
||||||
|
// Convert Endpoint into an internal format used for storing it in locktree
|
||||||
|
// (DBT structure is used for passing endpoints to locktree and getting back)
|
||||||
|
void serialize_endpoint(const Endpoint& endp, std::string* buf) { |
||||||
|
buf->push_back(endp.inf_suffix ? SUFFIX_SUPREMUM : SUFFIX_INFIMUM); |
||||||
|
buf->append(endp.slice.data(), endp.slice.size()); |
||||||
|
} |
||||||
|
|
||||||
|
// Decode the endpoint from the format it is stored in the locktree (DBT) to
|
||||||
|
// one used outside (EndpointWithString)
|
||||||
|
void deserialize_endpoint(const DBT* dbt, EndpointWithString* endp) { |
||||||
|
assert(dbt->size >= 1); |
||||||
|
const char* dbt_data = (const char*)dbt->data; |
||||||
|
char suffix = dbt_data[0]; |
||||||
|
assert(suffix == SUFFIX_INFIMUM || suffix == SUFFIX_SUPREMUM); |
||||||
|
endp->inf_suffix = (suffix == SUFFIX_SUPREMUM); |
||||||
|
endp->slice.assign(dbt_data + 1, dbt->size - 1); |
||||||
|
} |
||||||
|
|
||||||
|
// Get a range lock on [start_key; end_key] range
|
||||||
|
Status RangeTreeLockManager::TryLock(PessimisticTransaction* txn, |
||||||
|
uint32_t column_family_id, |
||||||
|
const Endpoint& start_endp, |
||||||
|
const Endpoint& end_endp, Env*, |
||||||
|
bool exclusive) { |
||||||
|
toku::lock_request request; |
||||||
|
request.create(mutex_factory_); |
||||||
|
DBT start_key_dbt, end_key_dbt; |
||||||
|
|
||||||
|
TEST_SYNC_POINT("RangeTreeLockManager::TryRangeLock:enter"); |
||||||
|
std::string start_key; |
||||||
|
std::string end_key; |
||||||
|
serialize_endpoint(start_endp, &start_key); |
||||||
|
serialize_endpoint(end_endp, &end_key); |
||||||
|
|
||||||
|
toku_fill_dbt(&start_key_dbt, start_key.data(), start_key.size()); |
||||||
|
toku_fill_dbt(&end_key_dbt, end_key.data(), end_key.size()); |
||||||
|
|
||||||
|
auto lt = GetLockTreeForCF(column_family_id); |
||||||
|
|
||||||
|
// Put the key waited on into request's m_extra. See
|
||||||
|
// wait_callback_for_locktree for details.
|
||||||
|
std::string wait_key(start_endp.slice.data(), start_endp.slice.size()); |
||||||
|
|
||||||
|
request.set(lt.get(), (TXNID)txn, &start_key_dbt, &end_key_dbt, |
||||||
|
exclusive ? toku::lock_request::WRITE : toku::lock_request::READ, |
||||||
|
false /* not a big txn */, &wait_key); |
||||||
|
|
||||||
|
// This is for "periodically wake up and check if the wait is killed" feature
|
||||||
|
// which we are not using.
|
||||||
|
uint64_t killed_time_msec = 0; |
||||||
|
uint64_t wait_time_msec = txn->GetLockTimeout(); |
||||||
|
|
||||||
|
if (wait_time_msec == static_cast<uint64_t>(-1)) { |
||||||
|
// The transaction has no wait timeout. lock_request::wait doesn't support
|
||||||
|
// this, it needs a number of milliseconds to wait. Pass it one year to
|
||||||
|
// be safe.
|
||||||
|
wait_time_msec = uint64_t(1000) * 60 * 60 * 24 * 365; |
||||||
|
} else { |
||||||
|
// convert microseconds to milliseconds
|
||||||
|
wait_time_msec = (wait_time_msec + 500) / 1000; |
||||||
|
} |
||||||
|
|
||||||
|
std::vector<RangeDeadlockInfo> di_path; |
||||||
|
request.m_deadlock_cb = [&](TXNID txnid, bool is_exclusive, |
||||||
|
const DBT* start_dbt, const DBT* end_dbt) { |
||||||
|
EndpointWithString start; |
||||||
|
EndpointWithString end; |
||||||
|
deserialize_endpoint(start_dbt, &start); |
||||||
|
deserialize_endpoint(end_dbt, &end); |
||||||
|
|
||||||
|
di_path.push_back({((PessimisticTransaction*)txnid)->GetID(), |
||||||
|
column_family_id, is_exclusive, std::move(start), |
||||||
|
std::move(end)}); |
||||||
|
}; |
||||||
|
|
||||||
|
request.start(); |
||||||
|
|
||||||
|
const int r = request.wait(wait_time_msec, killed_time_msec, |
||||||
|
nullptr, // killed_callback
|
||||||
|
wait_callback_for_locktree, nullptr); |
||||||
|
|
||||||
|
// Inform the txn that we are no longer waiting:
|
||||||
|
txn->ClearWaitingTxn(); |
||||||
|
|
||||||
|
request.destroy(); |
||||||
|
switch (r) { |
||||||
|
case 0: |
||||||
|
break; // fall through
|
||||||
|
case DB_LOCK_NOTGRANTED: |
||||||
|
return Status::TimedOut(Status::SubCode::kLockTimeout); |
||||||
|
case TOKUDB_OUT_OF_LOCKS: |
||||||
|
return Status::Busy(Status::SubCode::kLockLimit); |
||||||
|
case DB_LOCK_DEADLOCK: { |
||||||
|
std::reverse(di_path.begin(), di_path.end()); |
||||||
|
dlock_buffer_.AddNewPath( |
||||||
|
RangeDeadlockPath(di_path, request.get_start_time())); |
||||||
|
return Status::Busy(Status::SubCode::kDeadlock); |
||||||
|
} |
||||||
|
default: |
||||||
|
assert(0); |
||||||
|
return Status::Busy(Status::SubCode::kLockLimit); |
||||||
|
} |
||||||
|
|
||||||
|
return Status::OK(); |
||||||
|
} |
||||||
|
|
||||||
|
// Wait callback that locktree library will call to inform us about
|
||||||
|
// the lock waits that are in progress.
|
||||||
|
void wait_callback_for_locktree(void*, lock_wait_infos* infos) { |
||||||
|
for (auto wait_info : *infos) { |
||||||
|
auto txn = (PessimisticTransaction*)wait_info.waiter; |
||||||
|
auto cf_id = (ColumnFamilyId)wait_info.ltree->get_dict_id().dictid; |
||||||
|
|
||||||
|
autovector<TransactionID> waitee_ids; |
||||||
|
for (auto waitee : wait_info.waitees) { |
||||||
|
waitee_ids.push_back(((PessimisticTransaction*)waitee)->GetID()); |
||||||
|
} |
||||||
|
txn->SetWaitingTxn(waitee_ids, cf_id, (std::string*)wait_info.m_extra); |
||||||
|
} |
||||||
|
|
||||||
|
// Here we can assume that the locktree code will now wait for some lock
|
||||||
|
TEST_SYNC_POINT("RangeTreeLockManager::TryRangeLock:WaitingTxn"); |
||||||
|
} |
||||||
|
|
||||||
|
void RangeTreeLockManager::UnLock(PessimisticTransaction* txn, |
||||||
|
ColumnFamilyId column_family_id, |
||||||
|
const std::string& key, Env*) { |
||||||
|
auto locktree = GetLockTreeForCF(column_family_id); |
||||||
|
std::string endp_image; |
||||||
|
serialize_endpoint({key.data(), key.size(), false}, &endp_image); |
||||||
|
|
||||||
|
DBT key_dbt; |
||||||
|
toku_fill_dbt(&key_dbt, endp_image.data(), endp_image.size()); |
||||||
|
|
||||||
|
toku::range_buffer range_buf; |
||||||
|
range_buf.create(); |
||||||
|
range_buf.append(&key_dbt, &key_dbt); |
||||||
|
|
||||||
|
locktree->release_locks((TXNID)txn, &range_buf); |
||||||
|
range_buf.destroy(); |
||||||
|
|
||||||
|
toku::lock_request::retry_all_lock_requests( |
||||||
|
locktree.get(), wait_callback_for_locktree, nullptr); |
||||||
|
} |
||||||
|
|
||||||
|
void RangeTreeLockManager::UnLock(PessimisticTransaction* txn, |
||||||
|
const LockTracker& tracker, Env*) { |
||||||
|
const RangeTreeLockTracker* range_tracker = |
||||||
|
static_cast<const RangeTreeLockTracker*>(&tracker); |
||||||
|
|
||||||
|
RangeTreeLockTracker* range_trx_tracker = |
||||||
|
static_cast<RangeTreeLockTracker*>(&txn->GetTrackedLocks()); |
||||||
|
bool all_keys = (range_trx_tracker == range_tracker); |
||||||
|
|
||||||
|
// tracked_locks_->range_list may hold nullptr if the transaction has never
|
||||||
|
// acquired any locks.
|
||||||
|
((RangeTreeLockTracker*)range_tracker)->ReleaseLocks(this, txn, all_keys); |
||||||
|
} |
||||||
|
|
||||||
|
int RangeTreeLockManager::CompareDbtEndpoints(void* arg, const DBT* a_key, |
||||||
|
const DBT* b_key) { |
||||||
|
const char* a = (const char*)a_key->data; |
||||||
|
const char* b = (const char*)b_key->data; |
||||||
|
|
||||||
|
size_t a_len = a_key->size; |
||||||
|
size_t b_len = b_key->size; |
||||||
|
|
||||||
|
size_t min_len = std::min(a_len, b_len); |
||||||
|
|
||||||
|
// Compare the values. The first byte encodes the endpoint type, its value
|
||||||
|
// is either SUFFIX_INFIMUM or SUFFIX_SUPREMUM.
|
||||||
|
Comparator* cmp = (Comparator*)arg; |
||||||
|
int res = cmp->Compare(Slice(a + 1, min_len - 1), Slice(b + 1, min_len - 1)); |
||||||
|
if (!res) { |
||||||
|
if (b_len > min_len) { |
||||||
|
// a is shorter;
|
||||||
|
if (a[0] == SUFFIX_INFIMUM) { |
||||||
|
return -1; //"a is smaller"
|
||||||
|
} else { |
||||||
|
// a is considered padded with 0xFF:FF:FF:FF...
|
||||||
|
return 1; // "a" is bigger
|
||||||
|
} |
||||||
|
} else if (a_len > min_len) { |
||||||
|
// the opposite of the above: b is shorter.
|
||||||
|
if (b[0] == SUFFIX_INFIMUM) { |
||||||
|
return 1; //"b is smaller"
|
||||||
|
} else { |
||||||
|
// b is considered padded with 0xFF:FF:FF:FF...
|
||||||
|
return -1; // "b" is bigger
|
||||||
|
} |
||||||
|
} else { |
||||||
|
// the lengths are equal (and the key values, too)
|
||||||
|
if (a[0] < b[0]) { |
||||||
|
return -1; |
||||||
|
} else if (a[0] > b[0]) { |
||||||
|
return 1; |
||||||
|
} else { |
||||||
|
return 0; |
||||||
|
} |
||||||
|
} |
||||||
|
} else { |
||||||
|
return res; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
namespace { |
||||||
|
void UnrefLockTreeMapsCache(void* ptr) { |
||||||
|
// Called when a thread exits or a ThreadLocalPtr gets destroyed.
|
||||||
|
auto lock_tree_map_cache = static_cast< |
||||||
|
std::unordered_map<ColumnFamilyId, std::shared_ptr<locktree>>*>(ptr); |
||||||
|
delete lock_tree_map_cache; |
||||||
|
} |
||||||
|
} // anonymous namespace
|
||||||
|
|
||||||
|
RangeTreeLockManager::RangeTreeLockManager( |
||||||
|
std::shared_ptr<TransactionDBMutexFactory> mutex_factory) |
||||||
|
: mutex_factory_(mutex_factory), |
||||||
|
ltree_lookup_cache_(new ThreadLocalPtr(&UnrefLockTreeMapsCache)), |
||||||
|
dlock_buffer_(10) { |
||||||
|
ltm_.create(on_create, on_destroy, on_escalate, nullptr, mutex_factory_); |
||||||
|
} |
||||||
|
|
||||||
|
void RangeTreeLockManager::SetRangeDeadlockInfoBufferSize( |
||||||
|
uint32_t target_size) { |
||||||
|
dlock_buffer_.Resize(target_size); |
||||||
|
} |
||||||
|
|
||||||
|
void RangeTreeLockManager::Resize(uint32_t target_size) { |
||||||
|
SetRangeDeadlockInfoBufferSize(target_size); |
||||||
|
} |
||||||
|
|
||||||
|
std::vector<RangeDeadlockPath> |
||||||
|
RangeTreeLockManager::GetRangeDeadlockInfoBuffer() { |
||||||
|
return dlock_buffer_.PrepareBuffer(); |
||||||
|
} |
||||||
|
|
||||||
|
std::vector<DeadlockPath> RangeTreeLockManager::GetDeadlockInfoBuffer() { |
||||||
|
std::vector<DeadlockPath> res; |
||||||
|
std::vector<RangeDeadlockPath> data = GetRangeDeadlockInfoBuffer(); |
||||||
|
// report left endpoints
|
||||||
|
for (auto it = data.begin(); it != data.end(); ++it) { |
||||||
|
std::vector<DeadlockInfo> path; |
||||||
|
|
||||||
|
for (auto it2 = it->path.begin(); it2 != it->path.end(); ++it2) { |
||||||
|
path.push_back( |
||||||
|
{it2->m_txn_id, it2->m_cf_id, it2->m_exclusive, it2->m_start.slice}); |
||||||
|
} |
||||||
|
res.push_back(DeadlockPath(path, it->deadlock_time)); |
||||||
|
} |
||||||
|
return res; |
||||||
|
} |
||||||
|
|
||||||
|
// @brief Lock Escalation Callback function
|
||||||
|
//
|
||||||
|
// @param txnid Transaction whose locks got escalated
|
||||||
|
// @param lt Lock Tree where escalation is happening
|
||||||
|
// @param buffer Escalation result: list of locks that this transaction now
|
||||||
|
// owns in this lock tree.
|
||||||
|
// @param void* Callback context
|
||||||
|
void RangeTreeLockManager::on_escalate(TXNID txnid, const locktree* lt, |
||||||
|
const range_buffer& buffer, void*) { |
||||||
|
auto txn = (PessimisticTransaction*)txnid; |
||||||
|
((RangeTreeLockTracker*)&txn->GetTrackedLocks())->ReplaceLocks(lt, buffer); |
||||||
|
} |
||||||
|
|
||||||
|
RangeTreeLockManager::~RangeTreeLockManager() { |
||||||
|
autovector<void*> local_caches; |
||||||
|
ltree_lookup_cache_->Scrape(&local_caches, nullptr); |
||||||
|
for (auto cache : local_caches) { |
||||||
|
delete static_cast<LockTreeMap*>(cache); |
||||||
|
} |
||||||
|
ltree_map_.clear(); // this will call release_lt() for all locktrees
|
||||||
|
ltm_.destroy(); |
||||||
|
} |
||||||
|
|
||||||
|
RangeLockManagerHandle::Counters RangeTreeLockManager::GetStatus() { |
||||||
|
LTM_STATUS_S ltm_status_test; |
||||||
|
ltm_.get_status(<m_status_test); |
||||||
|
Counters res; |
||||||
|
|
||||||
|
// Searching status variable by its string name is how Toku's unit tests
|
||||||
|
// do it (why didn't they make LTM_ESCALATION_COUNT constant visible?)
|
||||||
|
// lookup keyname in status
|
||||||
|
for (int i = 0; i < LTM_STATUS_S::LTM_STATUS_NUM_ROWS; i++) { |
||||||
|
TOKU_ENGINE_STATUS_ROW status = <m_status_test.status[i]; |
||||||
|
if (strcmp(status->keyname, "LTM_ESCALATION_COUNT") == 0) { |
||||||
|
res.escalation_count = status->value.num; |
||||||
|
continue; |
||||||
|
} |
||||||
|
if (strcmp(status->keyname, "LTM_SIZE_CURRENT") == 0) { |
||||||
|
res.current_lock_memory = status->value.num; |
||||||
|
} |
||||||
|
} |
||||||
|
return res; |
||||||
|
} |
||||||
|
|
||||||
|
std::shared_ptr<locktree> RangeTreeLockManager::MakeLockTreePtr(locktree* lt) { |
||||||
|
locktree_manager* ltm = <m_; |
||||||
|
return std::shared_ptr<locktree>(lt, |
||||||
|
[ltm](locktree* p) { ltm->release_lt(p); }); |
||||||
|
} |
||||||
|
|
||||||
|
void RangeTreeLockManager::AddColumnFamily(const ColumnFamilyHandle* cfh) { |
||||||
|
uint32_t column_family_id = cfh->GetID(); |
||||||
|
|
||||||
|
InstrumentedMutexLock l(<ree_map_mutex_); |
||||||
|
if (ltree_map_.find(column_family_id) == ltree_map_.end()) { |
||||||
|
DICTIONARY_ID dict_id = {.dictid = column_family_id}; |
||||||
|
toku::comparator cmp; |
||||||
|
cmp.create(CompareDbtEndpoints, (void*)cfh->GetComparator()); |
||||||
|
toku::locktree* ltree = ltm_.get_lt(dict_id, cmp, |
||||||
|
/* on_create_extra*/ nullptr); |
||||||
|
// This is ok to because get_lt has copied the comparator:
|
||||||
|
cmp.destroy(); |
||||||
|
|
||||||
|
ltree_map_.insert({column_family_id, MakeLockTreePtr(ltree)}); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void RangeTreeLockManager::RemoveColumnFamily(const ColumnFamilyHandle* cfh) { |
||||||
|
uint32_t column_family_id = cfh->GetID(); |
||||||
|
// Remove lock_map for this column family. Since the lock map is stored
|
||||||
|
// as a shared ptr, concurrent transactions can still keep using it
|
||||||
|
// until they release their references to it.
|
||||||
|
|
||||||
|
// TODO what if one drops a column family while transaction(s) still have
|
||||||
|
// locks in it?
|
||||||
|
// locktree uses column family'c Comparator* as the criteria to do tree
|
||||||
|
// ordering. If the comparator is gone, we won't even be able to remove the
|
||||||
|
// elements from the locktree.
|
||||||
|
// A possible solution might be to remove everything right now:
|
||||||
|
// - wait until everyone traversing the locktree are gone
|
||||||
|
// - remove everything from the locktree.
|
||||||
|
// - some transactions may have acquired locks in their LockTracker objects.
|
||||||
|
// Arrange something so we don't blow up when they try to release them.
|
||||||
|
// - ...
|
||||||
|
// This use case (drop column family while somebody is using it) doesn't seem
|
||||||
|
// the priority, though.
|
||||||
|
|
||||||
|
{ |
||||||
|
InstrumentedMutexLock l(<ree_map_mutex_); |
||||||
|
|
||||||
|
auto lock_maps_iter = ltree_map_.find(column_family_id); |
||||||
|
assert(lock_maps_iter != ltree_map_.end()); |
||||||
|
ltree_map_.erase(lock_maps_iter); |
||||||
|
} // lock_map_mutex_
|
||||||
|
|
||||||
|
autovector<void*> local_caches; |
||||||
|
ltree_lookup_cache_->Scrape(&local_caches, nullptr); |
||||||
|
for (auto cache : local_caches) { |
||||||
|
delete static_cast<LockTreeMap*>(cache); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
std::shared_ptr<locktree> RangeTreeLockManager::GetLockTreeForCF( |
||||||
|
ColumnFamilyId column_family_id) { |
||||||
|
// First check thread-local cache
|
||||||
|
if (ltree_lookup_cache_->Get() == nullptr) { |
||||||
|
ltree_lookup_cache_->Reset(new LockTreeMap()); |
||||||
|
} |
||||||
|
|
||||||
|
auto ltree_map_cache = static_cast<LockTreeMap*>(ltree_lookup_cache_->Get()); |
||||||
|
|
||||||
|
auto it = ltree_map_cache->find(column_family_id); |
||||||
|
if (it != ltree_map_cache->end()) { |
||||||
|
// Found lock map for this column family.
|
||||||
|
return it->second; |
||||||
|
} |
||||||
|
|
||||||
|
// Not found in local cache, grab mutex and check shared LockMaps
|
||||||
|
InstrumentedMutexLock l(<ree_map_mutex_); |
||||||
|
|
||||||
|
it = ltree_map_.find(column_family_id); |
||||||
|
if (it == ltree_map_.end()) { |
||||||
|
return nullptr; |
||||||
|
} else { |
||||||
|
// Found lock map. Store in thread-local cache and return.
|
||||||
|
ltree_map_cache->insert({column_family_id, it->second}); |
||||||
|
return it->second; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
struct LOCK_PRINT_CONTEXT { |
||||||
|
RangeLockManagerHandle::RangeLockStatus* data; // Save locks here
|
||||||
|
uint32_t cfh_id; // Column Family whose tree we are traversing
|
||||||
|
}; |
||||||
|
|
||||||
|
// Report left endpoints of the acquired locks
|
||||||
|
LockManager::PointLockStatus RangeTreeLockManager::GetPointLockStatus() { |
||||||
|
PointLockStatus res; |
||||||
|
LockManager::RangeLockStatus data = GetRangeLockStatus(); |
||||||
|
// report left endpoints
|
||||||
|
for (auto it = data.begin(); it != data.end(); ++it) { |
||||||
|
auto& val = it->second; |
||||||
|
res.insert({it->first, {val.start.slice, val.ids, val.exclusive}}); |
||||||
|
} |
||||||
|
return res; |
||||||
|
} |
||||||
|
|
||||||
|
static void push_into_lock_status_data(void* param, const DBT* left, |
||||||
|
const DBT* right, TXNID txnid_arg, |
||||||
|
bool is_shared, TxnidVector* owners) { |
||||||
|
struct LOCK_PRINT_CONTEXT* ctx = (LOCK_PRINT_CONTEXT*)param; |
||||||
|
struct RangeLockInfo info; |
||||||
|
|
||||||
|
info.exclusive = !is_shared; |
||||||
|
|
||||||
|
deserialize_endpoint(left, &info.start); |
||||||
|
deserialize_endpoint(right, &info.end); |
||||||
|
|
||||||
|
if (txnid_arg != TXNID_SHARED) { |
||||||
|
TXNID txnid = ((PessimisticTransaction*)txnid_arg)->GetID(); |
||||||
|
info.ids.push_back(txnid); |
||||||
|
} else { |
||||||
|
for (auto it : *owners) { |
||||||
|
TXNID real_id = ((PessimisticTransaction*)it)->GetID(); |
||||||
|
info.ids.push_back(real_id); |
||||||
|
} |
||||||
|
} |
||||||
|
ctx->data->insert({ctx->cfh_id, info}); |
||||||
|
} |
||||||
|
|
||||||
|
LockManager::RangeLockStatus RangeTreeLockManager::GetRangeLockStatus() { |
||||||
|
LockManager::RangeLockStatus data; |
||||||
|
{ |
||||||
|
InstrumentedMutexLock l(<ree_map_mutex_); |
||||||
|
for (auto it : ltree_map_) { |
||||||
|
LOCK_PRINT_CONTEXT ctx = {&data, it.first}; |
||||||
|
it.second->dump_locks((void*)&ctx, push_into_lock_status_data); |
||||||
|
} |
||||||
|
} |
||||||
|
return data; |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace ROCKSDB_NAMESPACE
|
||||||
|
#endif // OS_WIN
|
||||||
|
#endif // ROCKSDB_LITE
|
||||||
@ -0,0 +1,130 @@ |
|||||||
|
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
||||||
|
// This source code is licensed under both the GPLv2 (found in the
|
||||||
|
// COPYING file in the root directory) and Apache 2.0 License
|
||||||
|
// (found in the LICENSE.Apache file in the root directory).
|
||||||
|
|
||||||
|
#pragma once |
||||||
|
#ifndef ROCKSDB_LITE |
||||||
|
#ifndef OS_WIN |
||||||
|
|
||||||
|
// For DeadlockInfoBuffer:
|
||||||
|
#include "util/thread_local.h" |
||||||
|
#include "utilities/transactions/lock/point/point_lock_manager.h" |
||||||
|
#include "utilities/transactions/lock/range/range_lock_manager.h" |
||||||
|
|
||||||
|
// Lock Tree library:
|
||||||
|
#include "utilities/transactions/lock/range/range_tree/lib/locktree/lock_request.h" |
||||||
|
#include "utilities/transactions/lock/range/range_tree/lib/locktree/locktree.h" |
||||||
|
#include "utilities/transactions/lock/range/range_tree/range_tree_lock_tracker.h" |
||||||
|
|
||||||
|
namespace ROCKSDB_NAMESPACE { |
||||||
|
|
||||||
|
using namespace toku; |
||||||
|
|
||||||
|
typedef DeadlockInfoBufferTempl<RangeDeadlockPath> RangeDeadlockInfoBuffer; |
||||||
|
|
||||||
|
// A Range Lock Manager that uses PerconaFT's locktree library
|
||||||
|
class RangeTreeLockManager : public RangeLockManagerBase, |
||||||
|
public RangeLockManagerHandle { |
||||||
|
public: |
||||||
|
LockManager* getLockManager() override { return this; } |
||||||
|
|
||||||
|
void AddColumnFamily(const ColumnFamilyHandle* cfh) override; |
||||||
|
void RemoveColumnFamily(const ColumnFamilyHandle* cfh) override; |
||||||
|
|
||||||
|
void Resize(uint32_t) override; |
||||||
|
std::vector<DeadlockPath> GetDeadlockInfoBuffer() override; |
||||||
|
|
||||||
|
std::vector<RangeDeadlockPath> GetRangeDeadlockInfoBuffer() override; |
||||||
|
void SetRangeDeadlockInfoBufferSize(uint32_t target_size) override; |
||||||
|
|
||||||
|
// Get a lock on a range
|
||||||
|
// @note only exclusive locks are currently supported (requesting a
|
||||||
|
// non-exclusive lock will get an exclusive one)
|
||||||
|
using LockManager::TryLock; |
||||||
|
Status TryLock(PessimisticTransaction* txn, ColumnFamilyId column_family_id, |
||||||
|
const Endpoint& start_endp, const Endpoint& end_endp, Env* env, |
||||||
|
bool exclusive) override; |
||||||
|
|
||||||
|
void UnLock(PessimisticTransaction* txn, const LockTracker& tracker, |
||||||
|
Env* env) override; |
||||||
|
void UnLock(PessimisticTransaction* txn, ColumnFamilyId column_family_id, |
||||||
|
const std::string& key, Env* env) override; |
||||||
|
void UnLock(PessimisticTransaction*, ColumnFamilyId, const Endpoint&, |
||||||
|
const Endpoint&, Env*) override { |
||||||
|
// TODO: range unlock does nothing...
|
||||||
|
} |
||||||
|
|
||||||
|
explicit RangeTreeLockManager( |
||||||
|
std::shared_ptr<TransactionDBMutexFactory> mutex_factory); |
||||||
|
|
||||||
|
~RangeTreeLockManager() override; |
||||||
|
|
||||||
|
int SetMaxLockMemory(size_t max_lock_memory) override { |
||||||
|
return ltm_.set_max_lock_memory(max_lock_memory); |
||||||
|
} |
||||||
|
|
||||||
|
size_t GetMaxLockMemory() override { return ltm_.get_max_lock_memory(); } |
||||||
|
|
||||||
|
Counters GetStatus() override; |
||||||
|
|
||||||
|
bool IsPointLockSupported() const override { |
||||||
|
// One could have acquired a point lock (it is reduced to range lock)
|
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
PointLockStatus GetPointLockStatus() override; |
||||||
|
|
||||||
|
// This is from LockManager
|
||||||
|
LockManager::RangeLockStatus GetRangeLockStatus() override; |
||||||
|
|
||||||
|
// This has the same meaning as GetRangeLockStatus but is from
|
||||||
|
// RangeLockManagerHandle
|
||||||
|
RangeLockManagerHandle::RangeLockStatus GetRangeLockStatusData() override { |
||||||
|
return GetRangeLockStatus(); |
||||||
|
} |
||||||
|
|
||||||
|
bool IsRangeLockSupported() const override { return true; } |
||||||
|
|
||||||
|
const LockTrackerFactory& GetLockTrackerFactory() const override { |
||||||
|
return RangeTreeLockTrackerFactory::Get(); |
||||||
|
} |
||||||
|
|
||||||
|
// Get the locktree which stores locks for the Column Family with given cf_id
|
||||||
|
std::shared_ptr<locktree> GetLockTreeForCF(ColumnFamilyId cf_id); |
||||||
|
|
||||||
|
private: |
||||||
|
toku::locktree_manager ltm_; |
||||||
|
|
||||||
|
std::shared_ptr<TransactionDBMutexFactory> mutex_factory_; |
||||||
|
|
||||||
|
// Map from cf_id to locktree*. Can only be accessed while holding the
|
||||||
|
// ltree_map_mutex_. Must use a custom deleter that calls ltm_.release_lt
|
||||||
|
using LockTreeMap = |
||||||
|
std::unordered_map<ColumnFamilyId, std::shared_ptr<locktree>>; |
||||||
|
LockTreeMap ltree_map_; |
||||||
|
|
||||||
|
InstrumentedMutex ltree_map_mutex_; |
||||||
|
|
||||||
|
// Per-thread cache of ltree_map_.
|
||||||
|
// (uses the same approach as TransactionLockMgr::lock_maps_cache_)
|
||||||
|
std::unique_ptr<ThreadLocalPtr> ltree_lookup_cache_; |
||||||
|
|
||||||
|
RangeDeadlockInfoBuffer dlock_buffer_; |
||||||
|
|
||||||
|
std::shared_ptr<locktree> MakeLockTreePtr(locktree* lt); |
||||||
|
static int CompareDbtEndpoints(void* arg, const DBT* a_key, const DBT* b_key); |
||||||
|
|
||||||
|
// Callbacks
|
||||||
|
static int on_create(locktree*, void*) { return 0; /* no error */ } |
||||||
|
static void on_destroy(locktree*) {} |
||||||
|
static void on_escalate(TXNID txnid, const locktree* lt, |
||||||
|
const range_buffer& buffer, void* extra); |
||||||
|
}; |
||||||
|
|
||||||
|
void serialize_endpoint(const Endpoint& endp, std::string* buf); |
||||||
|
void wait_callback_for_locktree(void* cdata, lock_wait_infos* infos); |
||||||
|
|
||||||
|
} // namespace ROCKSDB_NAMESPACE
|
||||||
|
#endif // OS_WIN
|
||||||
|
#endif // ROCKSDB_LITE
|
||||||
@ -0,0 +1,156 @@ |
|||||||
|
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
||||||
|
// This source code is licensed under both the GPLv2 (found in the
|
||||||
|
// COPYING file in the root directory) and Apache 2.0 License
|
||||||
|
// (found in the LICENSE.Apache file in the root directory).
|
||||||
|
|
||||||
|
#ifndef ROCKSDB_LITE |
||||||
|
#ifndef OS_WIN |
||||||
|
|
||||||
|
#include "utilities/transactions/lock/range/range_tree/range_tree_lock_tracker.h" |
||||||
|
|
||||||
|
#include "utilities/transactions/lock/range/range_tree/range_tree_lock_manager.h" |
||||||
|
|
||||||
|
namespace ROCKSDB_NAMESPACE { |
||||||
|
|
||||||
|
RangeLockList *RangeTreeLockTracker::getOrCreateList() { |
||||||
|
if (range_list_) return range_list_.get(); |
||||||
|
|
||||||
|
// Doesn't exist, create
|
||||||
|
range_list_.reset(new RangeLockList()); |
||||||
|
return range_list_.get(); |
||||||
|
} |
||||||
|
|
||||||
|
void RangeTreeLockTracker::Track(const PointLockRequest &lock_req) { |
||||||
|
DBT key_dbt; |
||||||
|
std::string key; |
||||||
|
serialize_endpoint(Endpoint(lock_req.key, false), &key); |
||||||
|
toku_fill_dbt(&key_dbt, key.data(), key.size()); |
||||||
|
RangeLockList *rl = getOrCreateList(); |
||||||
|
rl->Append(lock_req.column_family_id, &key_dbt, &key_dbt); |
||||||
|
} |
||||||
|
|
||||||
|
void RangeTreeLockTracker::Track(const RangeLockRequest &lock_req) { |
||||||
|
DBT start_dbt, end_dbt; |
||||||
|
std::string start_key, end_key; |
||||||
|
|
||||||
|
serialize_endpoint(lock_req.start_endp, &start_key); |
||||||
|
serialize_endpoint(lock_req.end_endp, &end_key); |
||||||
|
|
||||||
|
toku_fill_dbt(&start_dbt, start_key.data(), start_key.size()); |
||||||
|
toku_fill_dbt(&end_dbt, end_key.data(), end_key.size()); |
||||||
|
|
||||||
|
RangeLockList *rl = getOrCreateList(); |
||||||
|
rl->Append(lock_req.column_family_id, &start_dbt, &end_dbt); |
||||||
|
} |
||||||
|
|
||||||
|
PointLockStatus RangeTreeLockTracker::GetPointLockStatus( |
||||||
|
ColumnFamilyId /*cf_id*/, const std::string & /*key*/) const { |
||||||
|
// This function is not expected to be called as RangeTreeLockTracker::
|
||||||
|
// IsPointLockSupported() returns false. Return the status which indicates
|
||||||
|
// the point is not locked.
|
||||||
|
PointLockStatus p; |
||||||
|
p.locked = false; |
||||||
|
p.exclusive = true; |
||||||
|
p.seq = 0; |
||||||
|
return p; |
||||||
|
} |
||||||
|
|
||||||
|
void RangeTreeLockTracker::Clear() { range_list_.reset(); } |
||||||
|
|
||||||
|
void RangeLockList::Append(ColumnFamilyId cf_id, const DBT *left_key, |
||||||
|
const DBT *right_key) { |
||||||
|
MutexLock l(&mutex_); |
||||||
|
// Only the transaction owner thread calls this function.
|
||||||
|
// The same thread does the lock release, so we can be certain nobody is
|
||||||
|
// releasing the locks concurrently.
|
||||||
|
assert(!releasing_locks_.load()); |
||||||
|
auto it = buffers_.find(cf_id); |
||||||
|
if (it == buffers_.end()) { |
||||||
|
// create a new one
|
||||||
|
it = buffers_.emplace(cf_id, std::make_shared<toku::range_buffer>()).first; |
||||||
|
it->second->create(); |
||||||
|
} |
||||||
|
it->second->append(left_key, right_key); |
||||||
|
} |
||||||
|
|
||||||
|
void RangeLockList::ReleaseLocks(RangeTreeLockManager *mgr, |
||||||
|
PessimisticTransaction *txn, |
||||||
|
bool all_trx_locks) { |
||||||
|
{ |
||||||
|
MutexLock l(&mutex_); |
||||||
|
// The lt->release_locks() call below will walk range_list->buffer_. We
|
||||||
|
// need to prevent lock escalation callback from replacing
|
||||||
|
// range_list->buffer_ while we are doing that.
|
||||||
|
//
|
||||||
|
// Additional complication here is internal mutex(es) in the locktree
|
||||||
|
// (let's call them latches):
|
||||||
|
// - Lock escalation first obtains latches on the lock tree
|
||||||
|
// - Then, it calls RangeTreeLockManager::on_escalate to replace
|
||||||
|
// transaction's range_list->buffer_. = Access to that buffer must be
|
||||||
|
// synchronized, so it will want to acquire the range_list->mutex_.
|
||||||
|
//
|
||||||
|
// While in this function we would want to do the reverse:
|
||||||
|
// - Acquire range_list->mutex_ to prevent access to the range_list.
|
||||||
|
// - Then, lt->release_locks() call will walk through the range_list
|
||||||
|
// - and acquire latches on parts of the lock tree to remove locks from
|
||||||
|
// it.
|
||||||
|
//
|
||||||
|
// How do we avoid the deadlock? The idea is that here we set
|
||||||
|
// releasing_locks_=true, and release the mutex.
|
||||||
|
// All other users of the range_list must:
|
||||||
|
// - Acquire the mutex, then check that releasing_locks_=false.
|
||||||
|
// (the code in this function doesnt do that as there's only one thread
|
||||||
|
// that releases transaction's locks)
|
||||||
|
releasing_locks_.store(true); |
||||||
|
} |
||||||
|
|
||||||
|
for (auto it : buffers_) { |
||||||
|
// Don't try to call release_locks() if the buffer is empty! if we are
|
||||||
|
// not holding any locks, the lock tree might be in the STO-mode with
|
||||||
|
// another transaction, and our attempt to release an empty set of locks
|
||||||
|
// will cause an assertion failure.
|
||||||
|
if (it.second->get_num_ranges()) { |
||||||
|
auto lt_ptr = mgr->GetLockTreeForCF(it.first); |
||||||
|
toku::locktree *lt = lt_ptr.get(); |
||||||
|
|
||||||
|
lt->release_locks((TXNID)txn, it.second.get(), all_trx_locks); |
||||||
|
|
||||||
|
it.second->destroy(); |
||||||
|
it.second->create(); |
||||||
|
|
||||||
|
toku::lock_request::retry_all_lock_requests(lt, |
||||||
|
wait_callback_for_locktree); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
Clear(); |
||||||
|
releasing_locks_.store(false); |
||||||
|
} |
||||||
|
|
||||||
|
void RangeLockList::ReplaceLocks(const toku::locktree *lt, |
||||||
|
const toku::range_buffer &buffer) { |
||||||
|
MutexLock l(&mutex_); |
||||||
|
if (releasing_locks_.load()) { |
||||||
|
// Do nothing. The transaction is releasing its locks, so it will not care
|
||||||
|
// about having a correct list of ranges. (In TokuDB,
|
||||||
|
// toku_db_txn_escalate_callback() makes use of this property, too)
|
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
ColumnFamilyId cf_id = (ColumnFamilyId)lt->get_dict_id().dictid; |
||||||
|
|
||||||
|
auto it = buffers_.find(cf_id); |
||||||
|
it->second->destroy(); |
||||||
|
it->second->create(); |
||||||
|
|
||||||
|
toku::range_buffer::iterator iter(&buffer); |
||||||
|
toku::range_buffer::iterator::record rec; |
||||||
|
while (iter.current(&rec)) { |
||||||
|
it->second->append(rec.get_left_key(), rec.get_right_key()); |
||||||
|
iter.next(); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace ROCKSDB_NAMESPACE
|
||||||
|
#endif // OS_WIN
|
||||||
|
#endif // ROCKSDB_LITE
|
||||||
@ -0,0 +1,146 @@ |
|||||||
|
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
||||||
|
// This source code is licensed under both the GPLv2 (found in the
|
||||||
|
// COPYING file in the root directory) and Apache 2.0 License
|
||||||
|
// (found in the LICENSE.Apache file in the root directory).
|
||||||
|
|
||||||
|
#pragma once |
||||||
|
|
||||||
|
#include <memory> |
||||||
|
#include <string> |
||||||
|
#include <unordered_map> |
||||||
|
|
||||||
|
#include "util/mutexlock.h" |
||||||
|
#include "utilities/transactions/lock/lock_tracker.h" |
||||||
|
#include "utilities/transactions/pessimistic_transaction.h" |
||||||
|
|
||||||
|
// Range Locking:
|
||||||
|
#include "lib/locktree/lock_request.h" |
||||||
|
#include "lib/locktree/locktree.h" |
||||||
|
|
||||||
|
namespace ROCKSDB_NAMESPACE { |
||||||
|
|
||||||
|
class RangeTreeLockManager; |
||||||
|
|
||||||
|
// Storage for locks that are currently held by a transaction.
|
||||||
|
//
|
||||||
|
// Locks are kept in toku::range_buffer because toku::locktree::release_locks()
|
||||||
|
// accepts that as an argument.
|
||||||
|
//
|
||||||
|
// Note: the list of locks may differ slighly from the contents of the lock
|
||||||
|
// tree, due to concurrency between lock acquisition, lock release, and lock
|
||||||
|
// escalation. See MDEV-18227 and RangeTreeLockManager::UnLock for details.
|
||||||
|
// This property is currently harmless.
|
||||||
|
//
|
||||||
|
// Append() and ReleaseLocks() are not thread-safe, as they are expected to be
|
||||||
|
// called only by the owner transaction. ReplaceLocks() is safe to call from
|
||||||
|
// other threads.
|
||||||
|
class RangeLockList { |
||||||
|
public: |
||||||
|
~RangeLockList() { Clear(); } |
||||||
|
|
||||||
|
RangeLockList() : releasing_locks_(false) {} |
||||||
|
|
||||||
|
void Append(ColumnFamilyId cf_id, const DBT* left_key, const DBT* right_key); |
||||||
|
void ReleaseLocks(RangeTreeLockManager* mgr, PessimisticTransaction* txn, |
||||||
|
bool all_trx_locks); |
||||||
|
void ReplaceLocks(const toku::locktree* lt, const toku::range_buffer& buffer); |
||||||
|
|
||||||
|
private: |
||||||
|
void Clear() { |
||||||
|
for (auto it : buffers_) { |
||||||
|
it.second->destroy(); |
||||||
|
} |
||||||
|
buffers_.clear(); |
||||||
|
} |
||||||
|
|
||||||
|
std::unordered_map<ColumnFamilyId, std::shared_ptr<toku::range_buffer>> |
||||||
|
buffers_; |
||||||
|
port::Mutex mutex_; |
||||||
|
std::atomic<bool> releasing_locks_; |
||||||
|
}; |
||||||
|
|
||||||
|
// A LockTracker-based object that is used together with RangeTreeLockManager.
|
||||||
|
class RangeTreeLockTracker : public LockTracker { |
||||||
|
public: |
||||||
|
RangeTreeLockTracker() : range_list_(nullptr) {} |
||||||
|
|
||||||
|
RangeTreeLockTracker(const RangeTreeLockTracker&) = delete; |
||||||
|
RangeTreeLockTracker& operator=(const RangeTreeLockTracker&) = delete; |
||||||
|
|
||||||
|
void Track(const PointLockRequest&) override; |
||||||
|
void Track(const RangeLockRequest&) override; |
||||||
|
|
||||||
|
bool IsPointLockSupported() const override { |
||||||
|
// This indicates that we don't implement GetPointLockStatus()
|
||||||
|
return false; |
||||||
|
} |
||||||
|
bool IsRangeLockSupported() const override { return true; } |
||||||
|
|
||||||
|
// a Not-supported dummy implementation.
|
||||||
|
UntrackStatus Untrack(const RangeLockRequest& /*lock_request*/) override { |
||||||
|
return UntrackStatus::NOT_TRACKED; |
||||||
|
} |
||||||
|
|
||||||
|
UntrackStatus Untrack(const PointLockRequest& /*lock_request*/) override { |
||||||
|
return UntrackStatus::NOT_TRACKED; |
||||||
|
} |
||||||
|
|
||||||
|
// "If this method is not supported, leave it as a no-op."
|
||||||
|
void Merge(const LockTracker&) override {} |
||||||
|
|
||||||
|
// "If this method is not supported, leave it as a no-op."
|
||||||
|
void Subtract(const LockTracker&) override {} |
||||||
|
|
||||||
|
void Clear() override; |
||||||
|
|
||||||
|
// "If this method is not supported, returns nullptr."
|
||||||
|
virtual LockTracker* GetTrackedLocksSinceSavePoint( |
||||||
|
const LockTracker&) const override { |
||||||
|
return nullptr; |
||||||
|
} |
||||||
|
|
||||||
|
PointLockStatus GetPointLockStatus(ColumnFamilyId column_family_id, |
||||||
|
const std::string& key) const override; |
||||||
|
|
||||||
|
// The return value is only used for tests
|
||||||
|
uint64_t GetNumPointLocks() const override { return 0; } |
||||||
|
|
||||||
|
ColumnFamilyIterator* GetColumnFamilyIterator() const override { |
||||||
|
return nullptr; |
||||||
|
} |
||||||
|
|
||||||
|
KeyIterator* GetKeyIterator( |
||||||
|
ColumnFamilyId /*column_family_id*/) const override { |
||||||
|
return nullptr; |
||||||
|
} |
||||||
|
|
||||||
|
void ReleaseLocks(RangeTreeLockManager* mgr, PessimisticTransaction* txn, |
||||||
|
bool all_trx_locks) { |
||||||
|
if (range_list_) range_list_->ReleaseLocks(mgr, txn, all_trx_locks); |
||||||
|
} |
||||||
|
|
||||||
|
void ReplaceLocks(const toku::locktree* lt, |
||||||
|
const toku::range_buffer& buffer) { |
||||||
|
// range_list_ cannot be NULL here
|
||||||
|
range_list_->ReplaceLocks(lt, buffer); |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
RangeLockList* getOrCreateList(); |
||||||
|
std::unique_ptr<RangeLockList> range_list_; |
||||||
|
}; |
||||||
|
|
||||||
|
class RangeTreeLockTrackerFactory : public LockTrackerFactory { |
||||||
|
public: |
||||||
|
static const RangeTreeLockTrackerFactory& Get() { |
||||||
|
static const RangeTreeLockTrackerFactory instance; |
||||||
|
return instance; |
||||||
|
} |
||||||
|
|
||||||
|
LockTracker* Create() const override { return new RangeTreeLockTracker(); } |
||||||
|
|
||||||
|
private: |
||||||
|
RangeTreeLockTrackerFactory() {} |
||||||
|
}; |
||||||
|
|
||||||
|
} // namespace ROCKSDB_NAMESPACE
|
||||||
Loading…
Reference in new issue