@nxtedition/rocksdb 5.2.21 → 5.2.28

package/deps/rocksdb/rocksdb/table/two_level_iterator.cc

@@ -201,6 +201,10 @@ void TwoLevelIndexIterator::InitDataBlock() {
           state_->NewSecondaryIterator(handle);
       data_block_handle_ = handle;
       SetSecondLevelIterator(iter);
+      if (iter == nullptr) {
+        status_ = Status::Corruption("Missing block for partition " +
+                                     handle.ToString());
+      }
     }
   }
 }

package/deps/rocksdb/rocksdb/table/unique_id.cc

@@ -0,0 +1,166 @@
+//  Copyright (c) Facebook, Inc. and its affiliates. 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).
+
+#include <cstdint>
+
+#include "table/unique_id_impl.h"
+#include "util/coding_lean.h"
+#include "util/hash.h"
+#include "util/string_util.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+std::string EncodeSessionId(uint64_t upper, uint64_t lower) {
+  std::string db_session_id(20U, '\0');
+  char *buf = &db_session_id[0];
+  // Preserving `lower` is slightly tricky. 36^12 is slightly more than
+  // 62 bits, so we use 12 chars plus the bottom two bits of one more.
+  // (A tiny fraction of 20 digit strings go unused.)
+  uint64_t a = (upper << 2) | (lower >> 62);
+  uint64_t b = lower & (UINT64_MAX >> 2);
+  PutBaseChars<36>(&buf, 8, a, /*uppercase*/ true);
+  PutBaseChars<36>(&buf, 12, b, /*uppercase*/ true);
+  assert(buf == &db_session_id.back() + 1);
+  return db_session_id;
+}
+
+Status DecodeSessionId(const std::string &db_session_id, uint64_t *upper,
+                       uint64_t *lower) {
+  const size_t len = db_session_id.size();
+  if (len == 0) {
+    return Status::NotSupported("Missing db_session_id");
+  }
+  // Anything from 13 to 24 chars is reasonable. We don't have to limit to
+  // exactly 20.
+  if (len < 13) {
+    return Status::NotSupported("Too short db_session_id");
+  }
+  if (len > 24) {
+    return Status::NotSupported("Too long db_session_id");
+  }
+  uint64_t a = 0, b = 0;
+  const char *buf = &db_session_id.front();
+  bool success = ParseBaseChars<36>(&buf, len - 12U, &a);
+  if (!success) {
+    return Status::NotSupported("Bad digit in db_session_id");
+  }
+  success = ParseBaseChars<36>(&buf, 12U, &b);
+  if (!success) {
+    return Status::NotSupported("Bad digit in db_session_id");
+  }
+  assert(buf == &db_session_id.back() + 1);
+  *upper = a >> 2;
+  *lower = (b & (UINT64_MAX >> 2)) | (a << 62);
+  return Status::OK();
+}
+
+Status GetSstInternalUniqueId(const std::string &db_id,
+                              const std::string &db_session_id,
+                              uint64_t file_number, UniqueId64x3 *out) {
+  if (db_id.empty()) {
+    return Status::NotSupported("Missing db_id");
+  }
+  if (file_number == 0) {
+    return Status::NotSupported("Missing or bad file number");
+  }
+  if (db_session_id.empty()) {
+    return Status::NotSupported("Missing db_session_id");
+  }
+  uint64_t session_upper = 0;  // Assignment to appease clang-analyze
+  uint64_t session_lower = 0;  // Assignment to appease clang-analyze
+  {
+    Status s = DecodeSessionId(db_session_id, &session_upper, &session_lower);
+    if (!s.ok()) {
+      return s;
+    }
+  }
+
+  // Exactly preserve session lower to ensure that session ids generated
+  // during the same process lifetime are guaranteed unique.
+  // DBImpl also guarantees (in recent versions) that this is not zero,
+  // so that we can guarantee unique ID is never all zeros. (Can't assert
+  // that here because of testing and old versions.)
+  // We put this first in anticipation of matching a small-ish set of cache
+  // key prefixes to cover entries relevant to any DB.
+  (*out)[0] = session_lower;
+
+  // Hash the session upper (~39 bits entropy) and DB id (120+ bits entropy)
+  // for very high global uniqueness entropy.
+  // (It is possible that many DBs descended from one common DB id are copied
+  // around and proliferate, in which case session id is critical, but it is
+  // more common for different DBs to have different DB ids.)
+  uint64_t db_a, db_b;
+  Hash2x64(db_id.data(), db_id.size(), session_upper, &db_a, &db_b);
+
+  // Xor in file number for guaranteed uniqueness by file number for a given
+  // session and DB id. (Xor slightly better than + here. See
+  // https://github.com/pdillinger/unique_id )
+  (*out)[1] = db_a ^ file_number;
+
+  // Extra (optional) global uniqueness
+  (*out)[2] = db_b;
+
+  return Status::OK();
+}
+
+namespace {
+// For InternalUniqueIdToExternal / ExternalUniqueIdToInternal we want all
+// zeros in first 128 bits to map to itself, so that excluding zero in
+// internal IDs (session_lower != 0 above) does the same for external IDs.
+// These values are meaningless except for making that work.
+constexpr uint64_t kHiOffsetForZero = 17391078804906429400U;
+constexpr uint64_t kLoOffsetForZero = 6417269962128484497U;
+}  // namespace
+
+void InternalUniqueIdToExternal(UniqueId64x3 *in_out) {
+  uint64_t hi, lo;
+  BijectiveHash2x64((*in_out)[1] + kHiOffsetForZero,
+                    (*in_out)[0] + kLoOffsetForZero, &hi, &lo);
+  (*in_out)[0] = lo;
+  (*in_out)[1] = hi;
+  (*in_out)[2] += lo + hi;
+}
+
+void ExternalUniqueIdToInternal(UniqueId64x3 *in_out) {
+  uint64_t lo = (*in_out)[0];
+  uint64_t hi = (*in_out)[1];
+  (*in_out)[2] -= lo + hi;
+  BijectiveUnhash2x64(hi, lo, &hi, &lo);
+  (*in_out)[0] = lo - kLoOffsetForZero;
+  (*in_out)[1] = hi - kHiOffsetForZero;
+}
+
+std::string EncodeUniqueIdBytes(const UniqueId64x3 &in) {
+  std::string ret(24U, '\0');
+  EncodeFixed64(&ret[0], in[0]);
+  EncodeFixed64(&ret[8], in[1]);
+  EncodeFixed64(&ret[16], in[2]);
+  return ret;
+}
+
+Status GetUniqueIdFromTableProperties(const TableProperties &props,
+                                      std::string *out_id) {
+  UniqueId64x3 tmp{};
+  Status s = GetSstInternalUniqueId(props.db_id, props.db_session_id,
+                                    props.orig_file_number, &tmp);
+  if (s.ok()) {
+    InternalUniqueIdToExternal(&tmp);
+    *out_id = EncodeUniqueIdBytes(tmp);
+  } else {
+    out_id->clear();
+  }
+  return s;
+}
+
+std::string UniqueIdToHumanString(const std::string &id) {
+  // Not so efficient, but that's OK
+  std::string str = Slice(id).ToString(/*hex*/ true);
+  for (size_t i = 16; i < str.size(); i += 17) {
+    str.insert(i, "-");
+  }
+  return str;
+}
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/table/unique_id_impl.h

@@ -0,0 +1,59 @@
+//  Copyright (c) Facebook, Inc. and its affiliates. 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 <array>
+
+#include "rocksdb/unique_id.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+using UniqueId64x3 = std::array<uint64_t, 3>;
+
+// Helper for GetUniqueIdFromTableProperties. This function can also be used
+// for temporary ids for files without sufficient information in table
+// properties. The internal unique id is more structured than the public
+// unique id, so can be manipulated in more ways but very carefully.
+// These must be long term stable to ensure GetUniqueIdFromTableProperties
+// is long term stable.
+Status GetSstInternalUniqueId(const std::string &db_id,
+                              const std::string &db_session_id,
+                              uint64_t file_number, UniqueId64x3 *out);
+
+// Helper for GetUniqueIdFromTableProperties. External unique ids go through
+// this extra hashing layer so that prefixes of the unique id have predictable
+// "full" entropy. This hashing layer is 1-to-1 on the first 128 bits and on
+// the full 192 bits.
+// This transformation must be long term stable to ensure
+// GetUniqueIdFromTableProperties is long term stable.
+void InternalUniqueIdToExternal(UniqueId64x3 *in_out);
+
+// Reverse of InternalUniqueIdToExternal mostly for testing purposes
+// (demonstrably 1-to-1 on the first 128 bits and on the full 192 bits).
+void ExternalUniqueIdToInternal(UniqueId64x3 *in_out);
+
+// Convert numerical format to byte format for public API
+std::string EncodeUniqueIdBytes(const UniqueId64x3 &in);
+
+// Reformat a random value down to our "DB session id" format,
+// which is intended to be compact and friendly for use in file names.
+// `lower` is fully preserved and data is lost from `upper`.
+//
+// Detail: Encoded into 20 chars in base-36 ([0-9A-Z]), which is ~103 bits of
+// entropy, which is enough to expect no collisions across a billion servers
+// each opening DBs a million times (~2^50). Benefits vs. RFC-4122 unique id:
+// * Save ~ dozen bytes per SST file
+// * Shorter shared backup file names (some platforms have low limits)
+// * Visually distinct from DB id format (usually RFC-4122)
+std::string EncodeSessionId(uint64_t upper, uint64_t lower);
+
+// Reverse of EncodeSessionId. Returns NotSupported on error rather than
+// Corruption because non-standard session IDs should be allowed with degraded
+// functionality.
+Status DecodeSessionId(const std::string &db_session_id, uint64_t *upper,
+                       uint64_t *lower);
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/test_util/mock_time_env.cc

@@ -12,7 +12,7 @@ namespace ROCKSDB_NAMESPACE {
 // TODO: this is a workaround for the different behavior on different platform
 // for timedwait timeout. Ideally timedwait API should be moved to env.
 // details: PR #7101.
-void MockTimeEnv::InstallTimedWaitFixCallback() {
+void MockSystemClock::InstallTimedWaitFixCallback() {
 #ifndef NDEBUG
   SyncPoint::GetInstance()->DisableProcessing();
   SyncPoint::GetInstance()->ClearAllCallBacks();

package/deps/rocksdb/rocksdb/test_util/mock_time_env.h

@@ -6,18 +6,22 @@
 #pragma once
 
 #include <atomic>
+#include <limits>
 
-#include "rocksdb/env.h"
+#include "rocksdb/system_clock.h"
 
 namespace ROCKSDB_NAMESPACE {
 
 // NOTE: SpecialEnv offers most of this functionality, along with hooks
 // for safe DB behavior under a mock time environment, so should be used
-// instead of MockTimeEnv for DB tests.
-class MockTimeEnv : public EnvWrapper {
+// instead of MockSystemClock for DB tests.
+class MockSystemClock : public SystemClockWrapper {
  public:
-  explicit MockTimeEnv(Env* base) : EnvWrapper(base) {}
+  explicit MockSystemClock(const std::shared_ptr<SystemClock>& base)
+      : SystemClockWrapper(base) {}
 
+  static const char* kClassName() { return "MockSystemClock"; }
+  const char* Name() const override { return kClassName(); }
   virtual Status GetCurrentTime(int64_t* time_sec) override {
     assert(time_sec != nullptr);
     *time_sec = static_cast<int64_t>(current_time_us_ / kMicrosInSecond);
@@ -33,9 +37,9 @@ class MockTimeEnv : public EnvWrapper {
     return current_time_us_ * 1000;
   }
 
-  uint64_t RealNowMicros() { return target()->NowMicros(); }
+  uint64_t RealNowMicros() { return target_->NowMicros(); }
 
-  void set_current_time(uint64_t time_sec) {
+  void SetCurrentTime(uint64_t time_sec) {
     assert(time_sec < std::numeric_limits<uint64_t>::max() / kMicrosInSecond);
     assert(time_sec * kMicrosInSecond >= current_time_us_);
     current_time_us_ = time_sec * kMicrosInSecond;
@@ -47,7 +51,7 @@ class MockTimeEnv : public EnvWrapper {
   // It's also similar to `set_current_time()`, which takes an absolute time in
   // seconds, vs. this one takes the sleep in microseconds.
   // Note: Not thread safe.
-  void MockSleepForMicroseconds(int micros) {
+  void SleepForMicroseconds(int micros) override {
     assert(micros >= 0);
     assert(current_time_us_ + static_cast<uint64_t>(micros) >=
            current_time_us_);
@@ -56,9 +60,8 @@ class MockTimeEnv : public EnvWrapper {
 
   void MockSleepForSeconds(int seconds) {
     assert(seconds >= 0);
-    uint64_t micros = static_cast<uint64_t>(seconds) * kMicrosInSecond;
-    assert(current_time_us_ + micros >= current_time_us_);
-    current_time_us_.fetch_add(micros);
+    int micros = seconds * kMicrosInSecond;
+    SleepForMicroseconds(micros);
   }
 
   // TODO: this is a workaround for the different behavior on different platform

package/deps/rocksdb/rocksdb/test_util/sync_point.cc

@@ -9,7 +9,6 @@
 
 #include "test_util/sync_point_impl.h"
 
-int rocksdb_kill_odds = 0;
 std::vector<std::string> rocksdb_kill_exclude_prefixes;
 
 #ifndef NDEBUG
@@ -61,7 +60,7 @@ void SyncPoint::ClearTrace() {
   impl_->ClearTrace();
 }
 
-void SyncPoint::Process(const std::string& point, void* cb_arg) {
+void SyncPoint::Process(const Slice& point, void* cb_arg) {
   impl_->Process(point, cb_arg);
 }
 

package/deps/rocksdb/rocksdb/test_util/sync_point.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <assert.h>
+
 #include <functional>
 #include <mutex>
 #include <string>
@@ -12,35 +13,44 @@
 #include <vector>
 
 #include "rocksdb/rocksdb_namespace.h"
-
-// This is only set from db_stress.cc and for testing only.
-// If non-zero, kill at various points in source code with probability 1/this
-extern int rocksdb_kill_odds;
-// If kill point has a prefix on this list, will skip killing.
-extern std::vector<std::string> rocksdb_kill_exclude_prefixes;
+#include "rocksdb/slice.h"
 
 #ifdef NDEBUG
 // empty in release build
-#define TEST_KILL_RANDOM(kill_point, rocksdb_kill_odds)
+#define TEST_KILL_RANDOM_WITH_WEIGHT(kill_point, rocksdb_kill_odds_weight)
+#define TEST_KILL_RANDOM(kill_point)
 #else
 
 namespace ROCKSDB_NAMESPACE {
-// Kill the process with probability 1/odds for testing.
-extern void TestKillRandom(std::string kill_point, int odds,
-                           const std::string& srcfile, int srcline);
 
 // To avoid crashing always at some frequently executed codepaths (during
 // kill random test), use this factor to reduce odds
 #define REDUCE_ODDS 2
 #define REDUCE_ODDS2 4
 
-#define TEST_KILL_RANDOM(kill_point, rocksdb_kill_odds)                  \
-  {                                                                      \
-    if (rocksdb_kill_odds > 0) {                                         \
-      TestKillRandom(kill_point, rocksdb_kill_odds, __FILE__, __LINE__); \
-    }                                                                    \
+// A class used to pass when a kill point is reached.
+struct KillPoint {
+ public:
+  // This is only set from db_stress.cc and for testing only.
+  // If non-zero, kill at various points in source code with probability 1/this
+  int rocksdb_kill_odds = 0;
+  // If kill point has a prefix on this list, will skip killing.
+  std::vector<std::string> rocksdb_kill_exclude_prefixes;
+  // Kill the process with probability 1/odds for testing.
+  void TestKillRandom(std::string kill_point, int odds,
+                      const std::string& srcfile, int srcline);
+
+  static KillPoint* GetInstance();
+};
+
+#define TEST_KILL_RANDOM_WITH_WEIGHT(kill_point, rocksdb_kill_odds_weight) \
+  {                                                                        \
+    KillPoint::GetInstance()->TestKillRandom(                              \
+        kill_point, rocksdb_kill_odds_weight, __FILE__, __LINE__);         \
   }
+#define TEST_KILL_RANDOM(kill_point) TEST_KILL_RANDOM_WITH_WEIGHT(kill_point, 1)
 }  // namespace ROCKSDB_NAMESPACE
+
 #endif
 
 #ifdef NDEBUG
@@ -109,7 +119,16 @@ class SyncPoint {
   // triggered by TEST_SYNC_POINT, blocking execution until all predecessors
   // are executed.
   // And/or call registered callback function, with argument `cb_arg`
-  void Process(const std::string& point, void* cb_arg = nullptr);
+  void Process(const Slice& point, void* cb_arg = nullptr);
+
+  // template gets length of const string at compile time,
+  //  avoiding strlen() at runtime
+  template <size_t kLen>
+  void Process(const char (&point)[kLen], void* cb_arg = nullptr) {
+    static_assert(kLen > 0, "Must not be empty");
+    assert(point[kLen - 1] == '\0');
+    Process(Slice(point, kLen - 1), cb_arg);
+  }
 
   // TODO: it might be useful to provide a function that blocks until all
   // sync points are cleared.

package/deps/rocksdb/rocksdb/test_util/sync_point_impl.cc

@@ -7,9 +7,17 @@
 
 #ifndef NDEBUG
 namespace ROCKSDB_NAMESPACE {
+KillPoint* KillPoint::GetInstance() {
+  static KillPoint kp;
+  return &kp;
+}
 
-void TestKillRandom(std::string kill_point, int odds,
-                    const std::string& srcfile, int srcline) {
+void KillPoint::TestKillRandom(std::string kill_point, int odds_weight,
+                               const std::string& srcfile, int srcline) {
+  if (rocksdb_kill_odds <= 0) {
+    return;
+  }
+  int odds = rocksdb_kill_odds * odds_weight;
   for (auto& p : rocksdb_kill_exclude_prefixes) {
     if (kill_point.substr(0, p.length()) == p) {
       return;
@@ -29,7 +37,6 @@ void TestKillRandom(std::string kill_point, int odds,
   }
 }
 
-
 void SyncPoint::Data::LoadDependency(const std::vector<SyncPointPair>& dependencies) {
   std::lock_guard<std::mutex> lock(mutex_);
   successors_.clear();
@@ -38,6 +45,8 @@ void SyncPoint::Data::LoadDependency(const std::vector<SyncPointPair>& dependenc
   for (const auto& dependency : dependencies) {
     successors_[dependency.predecessor].push_back(dependency.successor);
     predecessors_[dependency.successor].push_back(dependency.predecessor);
+    point_filter_.Add(dependency.successor);
+    point_filter_.Add(dependency.predecessor);
   }
   cv_.notify_all();
 }
@@ -54,11 +63,15 @@ void SyncPoint::Data::LoadDependencyAndMarkers(
   for (const auto& dependency : dependencies) {
     successors_[dependency.predecessor].push_back(dependency.successor);
     predecessors_[dependency.successor].push_back(dependency.predecessor);
+    point_filter_.Add(dependency.successor);
+    point_filter_.Add(dependency.predecessor);
   }
   for (const auto& marker : markers) {
     successors_[marker.predecessor].push_back(marker.successor);
     predecessors_[marker.successor].push_back(marker.predecessor);
     markers_[marker.predecessor].push_back(marker.successor);
+    point_filter_.Add(marker.predecessor);
+    point_filter_.Add(marker.successor);
   }
   cv_.notify_all();
 }
@@ -88,33 +101,42 @@ void SyncPoint::Data::ClearAllCallBacks() {
   callbacks_.clear();
 }
 
-void SyncPoint::Data::Process(const std::string& point, void* cb_arg) {
+void SyncPoint::Data::Process(const Slice& point, void* cb_arg) {
   if (!enabled_) {
     return;
   }
 
+  // Use a filter to prevent mutex lock if possible.
+  if (!point_filter_.MayContain(point)) {
+    return;
+  }
+
+  // Must convert to std::string for remaining work.  Take
+  //  heap hit.
+  std::string point_string(point.ToString());
   std::unique_lock<std::mutex> lock(mutex_);
   auto thread_id = std::this_thread::get_id();
 
-  auto marker_iter = markers_.find(point);
+  auto marker_iter = markers_.find(point_string);
   if (marker_iter != markers_.end()) {
     for (auto& marked_point : marker_iter->second) {
       marked_thread_id_.emplace(marked_point, thread_id);
+      point_filter_.Add(marked_point);
     }
   }
 
-  if (DisabledByMarker(point, thread_id)) {
+  if (DisabledByMarker(point_string, thread_id)) {
     return;
   }
 
-  while (!PredecessorsAllCleared(point)) {
+  while (!PredecessorsAllCleared(point_string)) {
     cv_.wait(lock);
-    if (DisabledByMarker(point, thread_id)) {
+    if (DisabledByMarker(point_string, thread_id)) {
       return;
     }
   }
 
-  auto callback_pair = callbacks_.find(point);
+  auto callback_pair = callbacks_.find(point_string);
   if (callback_pair != callbacks_.end()) {
     num_callbacks_running_++;
     mutex_.unlock();
@@ -122,7 +144,7 @@ void SyncPoint::Data::Process(const std::string& point, void* cb_arg) {
     mutex_.lock();
     num_callbacks_running_--;
   }
-  cleared_points_.insert(point);
+  cleared_points_.insert(point_string);
   cv_.notify_all();
 }
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/test_util/sync_point_impl.h

@@ -3,9 +3,8 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#include "test_util/sync_point.h"
-
 #include <assert.h>
+
 #include <atomic>
 #include <condition_variable>
 #include <functional>
@@ -15,15 +14,39 @@
 #include <unordered_map>
 #include <unordered_set>
 
+#include "memory/concurrent_arena.h"
 #include "port/port.h"
+#include "test_util/sync_point.h"
+#include "util/dynamic_bloom.h"
 #include "util/random.h"
 
 #pragma once
 
 #ifndef NDEBUG
 namespace ROCKSDB_NAMESPACE {
+// A hacky allocator for single use.
+// Arena depends on SyncPoint and create circular dependency.
+class SingleAllocator : public Allocator {
+ public:
+  char* Allocate(size_t) override {
+    assert(false);
+    return nullptr;
+  }
+  char* AllocateAligned(size_t bytes, size_t, Logger*) override {
+    buf_.resize(bytes);
+    return const_cast<char*>(buf_.data());
+  }
+  size_t BlockSize() const override {
+    assert(false);
+    return 0;
+  }
+
+ private:
+  std::string buf_;
+};
+
 struct SyncPoint::Data {
-  Data() : enabled_(false) {}
+  Data() : point_filter_(&alloc_, /*total_bits=*/8192), enabled_(false) {}
   // Enable proper deletion by subclasses
   virtual ~Data() {}
   // successor/predecessor map loaded from LoadDependency
@@ -37,6 +60,9 @@ struct SyncPoint::Data {
   std::condition_variable cv_;
   // sync points that have been passed through
   std::unordered_set<std::string> cleared_points_;
+  SingleAllocator alloc_;
+  // A filter before holding mutex to speed up process.
+  DynamicBloom point_filter_;
   std::atomic<bool> enabled_;
   int num_callbacks_running_ = 0;
 
@@ -48,6 +74,7 @@ struct SyncPoint::Data {
     const std::function<void(void*)>& callback) {
   std::lock_guard<std::mutex> lock(mutex_);
   callbacks_[point] = callback;
+  point_filter_.Add(point);
 }
 
   void ClearCallBack(const std::string& point);
@@ -68,7 +95,7 @@ struct SyncPoint::Data {
     return marked_point_iter != marked_thread_id_.end() &&
            thread_id != marked_point_iter->second;
   }
-  void Process(const std::string& point, void* cb_arg);
+  void Process(const Slice& point, void* cb_arg);
 };
 }  // namespace ROCKSDB_NAMESPACE
 #endif // NDEBUG

package/deps/rocksdb/rocksdb/test_util/testharness.cc

@@ -8,12 +8,22 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include "test_util/testharness.h"
+
+#include <regex>
 #include <string>
 #include <thread>
 
 namespace ROCKSDB_NAMESPACE {
 namespace test {
 
+#ifdef OS_WIN
+#include <windows.h>
+
+std::string GetPidStr() { return std::to_string(GetCurrentProcessId()); }
+#else
+std::string GetPidStr() { return std::to_string(getpid()); }
+#endif
+
 ::testing::AssertionResult AssertStatus(const char* s_expr, const Status& s) {
   if (s.ok()) {
     return ::testing::AssertionSuccess();
@@ -32,7 +42,7 @@ std::string TmpDir(Env* env) {
 
 std::string PerThreadDBPath(std::string dir, std::string name) {
   size_t tid = std::hash<std::thread::id>()(std::this_thread::get_id());
-  return dir + "/" + name + "_" + std::to_string(tid);
+  return dir + "/" + name + "_" + GetPidStr() + "_" + std::to_string(tid);
 }
 
 std::string PerThreadDBPath(std::string name) {
@@ -52,5 +62,47 @@ int RandomSeed() {
   return result;
 }
 
+TestRegex::TestRegex(const std::string& pattern)
+    : impl_(std::make_shared<Impl>(pattern)), pattern_(pattern) {}
+TestRegex::TestRegex(const char* pattern)
+    : impl_(std::make_shared<Impl>(pattern)), pattern_(pattern) {}
+
+const std::string& TestRegex::GetPattern() const { return pattern_; }
+
+class TestRegex::Impl : public std::regex {
+ public:
+  using std::regex::basic_regex;
+};
+
+bool TestRegex::Matches(const std::string& str) const {
+  if (impl_) {
+    return std::regex_match(str, *impl_);
+  } else {
+    // Should not call Matches on unset Regex
+    assert(false);
+    return false;
+  }
+}
+
+::testing::AssertionResult AssertMatchesRegex(const char* str_expr,
+                                              const char* pattern_expr,
+                                              const std::string& str,
+                                              const TestRegex& pattern) {
+  if (pattern.Matches(str)) {
+    return ::testing::AssertionSuccess();
+  } else if (TestRegex("\".*\"").Matches(pattern_expr)) {
+    // constant regex string
+    return ::testing::AssertionFailure()
+           << str << " (" << str_expr << ")" << std::endl
+           << "does not match regex " << pattern.GetPattern();
+  } else {
+    // runtime regex string
+    return ::testing::AssertionFailure()
+           << str << " (" << str_expr << ")" << std::endl
+           << "does not match regex" << std::endl
+           << pattern.GetPattern() << " (" << pattern_expr << ")";
+  }
+}
+
 }  // namespace test
 }  // namespace ROCKSDB_NAMESPACE