@nxtedition/rocksdb 5.2.21 → 5.2.28

package/deps/rocksdb/rocksdb/utilities/transactions/lock/range/range_tree/lib/locktree/locktree.h

@@ -85,6 +85,9 @@ typedef void (*lt_destroy_cb)(locktree *lt);
 typedef void (*lt_escalate_cb)(TXNID txnid, const locktree *lt,
                                const range_buffer &buffer, void *extra);
 
+typedef bool (*lt_escalation_barrier_check_func)(const DBT *a, const DBT *b,
+                                                 void *extra);
+
 struct lt_counters {
   uint64_t wait_count, wait_time;
   uint64_t long_wait_count, long_wait_time;
@@ -343,6 +346,20 @@ class locktree {
 
   void set_comparator(const comparator &cmp);
 
+  // Set the user-provided Lock Escalation Barrier check function and its
+  // argument
+  //
+  // Lock Escalation Barrier limits the scope of Lock Escalation.
+  // For two keys A and B (such that A < B),
+  // escalation_barrier_check_func(A, B)==true means that there's a lock
+  // escalation barrier between A and B, and lock escalation is not allowed to
+  // bridge the gap between A and B.
+  //
+  // This method sets the user-provided barrier check function and its
+  // parameter.
+  void set_escalation_barrier_func(lt_escalation_barrier_check_func func,
+                                   void *extra);
+
   int compare(const locktree *lt) const;
 
   DICTIONARY_ID get_dict_id() const;
@@ -373,6 +390,9 @@ class locktree {
   // userdata pointer below. see locktree_manager::get_lt w/ on_create_extra
   comparator m_cmp;
 
+  lt_escalation_barrier_check_func m_escalation_barrier;
+  void *m_escalation_barrier_arg;
+
   concurrent_tree *m_rangetree;
 
   void *m_userdata;

package/deps/rocksdb/rocksdb/utilities/transactions/lock/range/range_tree/lib/portability/toku_external_pthread.h

@@ -1,6 +1,7 @@
 /*
-  A wrapper around rocksdb::TransactionDBMutexFactory-provided condition and
-  mutex that provides toku_pthread_*-like interface. The functions are named
+  A wrapper around ROCKSDB_NAMESPACE::TransactionDBMutexFactory-provided
+  condition and mutex that provides toku_pthread_*-like interface. The functions
+  are named
 
     toku_external_{mutex|cond}_XXX
 

package/deps/rocksdb/rocksdb/utilities/transactions/lock/range/range_tree/lib/portability/toku_time.h

@@ -133,6 +133,10 @@ static inline tokutime_t toku_time_now(void) {
   return result;
 #elif defined(__powerpc__)
   return __ppc_get_timebase();
+#elif defined(__s390x__)
+  uint64_t result;
+  asm volatile("stckf %0" : "=Q"(result) : : "cc");
+  return result;
 #else
 #error No timer implementation for this platform
 #endif

package/deps/rocksdb/rocksdb/utilities/transactions/lock/range/range_tree/range_tree_lock_manager.cc

@@ -48,14 +48,15 @@ void serialize_endpoint(const Endpoint& endp, std::string* buf) {
 }
 
 // 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) {
+// the one used outside: either Endpoint or EndpointWithString
+template <typename EndpointStruct>
+void deserialize_endpoint(const DBT* dbt, EndpointStruct* 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);
+  endp->slice = decltype(EndpointStruct::slice)(dbt_data + 1, dbt->size - 1);
 }
 
 // Get a range lock on [start_key; end_key] range
@@ -148,7 +149,7 @@ Status RangeTreeLockManager::TryLock(PessimisticTransaction* txn,
 
 // 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) {
+void wait_callback_for_locktree(void*, toku::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;
@@ -249,7 +250,8 @@ 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);
+      std::unordered_map<ColumnFamilyId, std::shared_ptr<toku::locktree>>*>(
+      ptr);
   delete lock_tree_map_cache;
 }
 }  // anonymous namespace
@@ -262,6 +264,21 @@ RangeTreeLockManager::RangeTreeLockManager(
   ltm_.create(on_create, on_destroy, on_escalate, nullptr, mutex_factory_);
 }
 
+int RangeTreeLockManager::on_create(toku::locktree* lt, void* arg) {
+  // arg is a pointer to RangeTreeLockManager
+  lt->set_escalation_barrier_func(&OnEscalationBarrierCheck, arg);
+  return 0;
+}
+
+bool RangeTreeLockManager::OnEscalationBarrierCheck(const DBT* a, const DBT* b,
+                                                    void* extra) {
+  Endpoint a_endp, b_endp;
+  deserialize_endpoint(a, &a_endp);
+  deserialize_endpoint(b, &b_endp);
+  auto self = static_cast<RangeTreeLockManager*>(extra);
+  return self->barrier_func_(a_endp, b_endp);
+}
+
 void RangeTreeLockManager::SetRangeDeadlockInfoBufferSize(
     uint32_t target_size) {
   dlock_buffer_.Resize(target_size);
@@ -299,8 +316,9 @@ std::vector<DeadlockPath> RangeTreeLockManager::GetDeadlockInfoBuffer() {
 // @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*) {
+void RangeTreeLockManager::on_escalate(TXNID txnid, const toku::locktree* lt,
+                                       const toku::range_buffer& buffer,
+                                       void*) {
   auto txn = (PessimisticTransaction*)txnid;
   ((RangeTreeLockTracker*)&txn->GetTrackedLocks())->ReplaceLocks(lt, buffer);
 }
@@ -329,6 +347,10 @@ RangeLockManagerHandle::Counters RangeTreeLockManager::GetStatus() {
       res.escalation_count = status->value.num;
       continue;
     }
+    if (strcmp(status->keyname, "LTM_WAIT_COUNT") == 0) {
+      res.lock_wait_count = status->value.num;
+      continue;
+    }
     if (strcmp(status->keyname, "LTM_SIZE_CURRENT") == 0) {
       res.current_lock_memory = status->value.num;
     }
@@ -336,10 +358,11 @@ RangeLockManagerHandle::Counters RangeTreeLockManager::GetStatus() {
   return res;
 }
 
-std::shared_ptr<locktree> RangeTreeLockManager::MakeLockTreePtr(locktree* lt) {
-  locktree_manager* ltm = &ltm_;
-  return std::shared_ptr<locktree>(lt,
-                                   [ltm](locktree* p) { ltm->release_lt(p); });
+std::shared_ptr<toku::locktree> RangeTreeLockManager::MakeLockTreePtr(
+    toku::locktree* lt) {
+  toku::locktree_manager* ltm = &ltm_;
+  return std::shared_ptr<toku::locktree>(
+      lt, [ltm](toku::locktree* p) { ltm->release_lt(p); });
 }
 
 void RangeTreeLockManager::AddColumnFamily(const ColumnFamilyHandle* cfh) {
@@ -350,8 +373,9 @@ void RangeTreeLockManager::AddColumnFamily(const ColumnFamilyHandle* cfh) {
     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);
+    toku::locktree* ltree =
+        ltm_.get_lt(dict_id, cmp,
+                    /* on_create_extra*/ static_cast<void*>(this));
     // This is ok to because get_lt has copied the comparator:
     cmp.destroy();
 
@@ -394,7 +418,7 @@ void RangeTreeLockManager::RemoveColumnFamily(const ColumnFamilyHandle* cfh) {
   }
 }
 
-std::shared_ptr<locktree> RangeTreeLockManager::GetLockTreeForCF(
+std::shared_ptr<toku::locktree> RangeTreeLockManager::GetLockTreeForCF(
     ColumnFamilyId column_family_id) {
   // First check thread-local cache
   if (ltree_lookup_cache_->Get() == nullptr) {

package/deps/rocksdb/rocksdb/utilities/transactions/lock/range/range_tree/range_tree_lock_manager.h

@@ -19,8 +19,6 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-using namespace toku;
-
 typedef DeadlockInfoBufferTempl<RangeDeadlockPath> RangeDeadlockInfoBuffer;
 
 // A Range Lock Manager that uses PerconaFT's locktree library
@@ -91,17 +89,24 @@ class RangeTreeLockManager : public RangeLockManagerBase,
   }
 
   // Get the locktree which stores locks for the Column Family with given cf_id
-  std::shared_ptr<locktree> GetLockTreeForCF(ColumnFamilyId cf_id);
+  std::shared_ptr<toku::locktree> GetLockTreeForCF(ColumnFamilyId cf_id);
+
+  void SetEscalationBarrierFunc(EscalationBarrierFunc func) override {
+    barrier_func_ = func;
+  }
 
  private:
   toku::locktree_manager ltm_;
 
+  EscalationBarrierFunc barrier_func_ =
+      [](const Endpoint&, const Endpoint&) -> bool { return false; };
+
   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>>;
+      std::unordered_map<ColumnFamilyId, std::shared_ptr<toku::locktree>>;
   LockTreeMap ltree_map_;
 
   InstrumentedMutex ltree_map_mutex_;
@@ -112,18 +117,20 @@ class RangeTreeLockManager : public RangeLockManagerBase,
 
   RangeDeadlockInfoBuffer dlock_buffer_;
 
-  std::shared_ptr<locktree> MakeLockTreePtr(locktree* lt);
+  std::shared_ptr<toku::locktree> MakeLockTreePtr(toku::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);
+  static int on_create(toku::locktree*, void*);
+  static void on_destroy(toku::locktree*) {}
+  static void on_escalate(TXNID txnid, const toku::locktree* lt,
+                          const toku::range_buffer& buffer, void* extra);
+
+  static bool OnEscalationBarrierCheck(const DBT* a, const DBT* b, void* extra);
 };
 
 void serialize_endpoint(const Endpoint& endp, std::string* buf);
-void wait_callback_for_locktree(void* cdata, lock_wait_infos* infos);
+void wait_callback_for_locktree(void* cdata, toku::lock_wait_infos* infos);
 
 }  // namespace ROCKSDB_NAMESPACE
 #endif  // OS_WIN

package/deps/rocksdb/rocksdb/utilities/transactions/optimistic_transaction_db_impl.h

@@ -47,6 +47,7 @@ class OptimisticTransactionDBImpl : public OptimisticTransactionDB {
                                 Transaction* old_txn) override;
 
   // Transactional `DeleteRange()` is not yet supported.
+  using StackableDB::DeleteRange;
   virtual Status DeleteRange(const WriteOptions&, ColumnFamilyHandle*,
                              const Slice&, const Slice&) override {
     return Status::NotSupported();

package/deps/rocksdb/rocksdb/utilities/transactions/optimistic_transaction_test.cc

@@ -37,7 +37,7 @@ class OptimisticTransactionTest
   OptimisticTransactionTest() {
     options.create_if_missing = true;
     options.max_write_buffer_number = 2;
-    options.max_write_buffer_size_to_maintain = 1600;
+    options.max_write_buffer_size_to_maintain = 2 * Arena::kInlineSize;
     options.merge_operator.reset(new TestPutOperator());
     dbname = test::PerThreadDBPath("optimistic_transaction_testdb");
 
@@ -318,7 +318,6 @@ TEST_P(OptimisticTransactionTest, CheckKeySkipOldMemtable) {
   const int kAttemptImmMemTable = 1;
   for (int attempt = kAttemptHistoryMemtable; attempt <= kAttemptImmMemTable;
        attempt++) {
-    options.max_write_buffer_number_to_maintain = 3;
     Reopen();
 
     WriteOptions write_options;