From c06b54d0c6fb8c46ee98744544b003ff4f87c269 Mon Sep 17 00:00:00 2001 From: sdong Date: Thu, 19 Sep 2019 12:32:33 -0700 Subject: [PATCH] Apply formatter on recent 45 commits. (#5827) Summary: Some recent commits might not have passed through the formatter. I formatted recent 45 commits. The script hangs for more commits so I stopped there. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5827 Test Plan: Run all existing tests. Differential Revision: D17483727 fbshipit-source-id: af23113ee63015d8a43d89a3bc2c1056189afe8f --- db/arena_wrapped_db_iter.cc | 2 +- db/compaction/compaction_iterator.cc | 2 +- db/compaction/compaction_iterator.h | 50 ++++---- db/compaction/compaction_job.cc | 14 ++- db/compaction/compaction_job.h | 32 ++--- db/db_impl/db_impl_compaction_flush.cc | 17 ++- db/db_impl/db_impl_readonly.cc | 2 +- db/db_iter.h | 9 +- db/db_test2.cc | 16 ++- .../org/rocksdb/benchmark/DbBenchmark.java | 42 +++---- java/rocksjni/sst_file_reader_iterator.cc | 109 +++++++++--------- java/rocksjni/sst_file_readerjni.cc | 44 +++---- .../main/java/org/rocksdb/SstFileReader.java | 25 ++-- .../org/rocksdb/SstFileReaderIterator.java | 4 +- .../java/org/rocksdb/SstFileReaderTest.java | 18 ++- options/options_settable_test.cc | 3 +- .../block_cache_trace_analyzer.cc | 6 +- tools/db_stress.cc | 5 +- tools/sst_dump_tool.cc | 5 +- util/bloom_impl.h | 30 +++-- util/concurrent_task_limiter_impl.h | 4 +- util/crc32c_arm64.h | 24 ++-- util/dynamic_bloom.cc | 2 +- util/dynamic_bloom_test.cc | 72 ++++++------ util/mutexlock.h | 12 +- .../transactions/write_unprepared_txn_db.cc | 2 +- 26 files changed, 271 insertions(+), 280 deletions(-) diff --git a/db/arena_wrapped_db_iter.cc b/db/arena_wrapped_db_iter.cc index 6a1635f62..840c20e9e 100644 --- a/db/arena_wrapped_db_iter.cc +++ b/db/arena_wrapped_db_iter.cc @@ -19,7 +19,7 @@ namespace rocksdb { Status ArenaWrappedDBIter::GetProperty(std::string prop_name, - std::string* prop) { + std::string* prop) { if (prop_name == "rocksdb.iterator.super-version-number") { // First try to pass the value returned from inner iterator. if (!db_iter_->GetProperty(prop_name, prop).ok()) { diff --git a/db/compaction/compaction_iterator.cc b/db/compaction/compaction_iterator.cc index 68519bff9..89ceb06ea 100644 --- a/db/compaction/compaction_iterator.cc +++ b/db/compaction/compaction_iterator.cc @@ -230,7 +230,7 @@ void CompactionIterator::NextFromInput() { valid_ = false; while (!valid_ && input_->Valid() && !IsPausingManualCompaction() && - !IsShuttingDown()) { + !IsShuttingDown()) { key_ = input_->key(); value_ = input_->value(); iter_stats_.num_input_records++; diff --git a/db/compaction/compaction_iterator.h b/db/compaction/compaction_iterator.h index 69bffa85b..a06a867dd 100644 --- a/db/compaction/compaction_iterator.h +++ b/db/compaction/compaction_iterator.h @@ -59,32 +59,32 @@ class CompactionIterator { const Compaction* compaction_; }; - CompactionIterator(InternalIterator* input, const Comparator* cmp, - MergeHelper* merge_helper, SequenceNumber last_sequence, - std::vector* snapshots, - SequenceNumber earliest_write_conflict_snapshot, - const SnapshotChecker* snapshot_checker, Env* env, - bool report_detailed_time, bool expect_valid_internal_key, - CompactionRangeDelAggregator* range_del_agg, - const Compaction* compaction = nullptr, - const CompactionFilter* compaction_filter = nullptr, - const std::atomic* shutting_down = nullptr, - const SequenceNumber preserve_deletes_seqnum = 0, - const std::atomic* manual_compaction_paused = nullptr); + CompactionIterator( + InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper, + SequenceNumber last_sequence, std::vector* snapshots, + SequenceNumber earliest_write_conflict_snapshot, + const SnapshotChecker* snapshot_checker, Env* env, + bool report_detailed_time, bool expect_valid_internal_key, + CompactionRangeDelAggregator* range_del_agg, + const Compaction* compaction = nullptr, + const CompactionFilter* compaction_filter = nullptr, + const std::atomic* shutting_down = nullptr, + const SequenceNumber preserve_deletes_seqnum = 0, + const std::atomic* manual_compaction_paused = nullptr); // Constructor with custom CompactionProxy, used for tests. - CompactionIterator(InternalIterator* input, const Comparator* cmp, - MergeHelper* merge_helper, SequenceNumber last_sequence, - std::vector* snapshots, - SequenceNumber earliest_write_conflict_snapshot, - const SnapshotChecker* snapshot_checker, Env* env, - bool report_detailed_time, bool expect_valid_internal_key, - CompactionRangeDelAggregator* range_del_agg, - std::unique_ptr compaction, - const CompactionFilter* compaction_filter = nullptr, - const std::atomic* shutting_down = nullptr, - const SequenceNumber preserve_deletes_seqnum = 0, - const std::atomic* manual_compaction_paused = nullptr); + CompactionIterator( + InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper, + SequenceNumber last_sequence, std::vector* snapshots, + SequenceNumber earliest_write_conflict_snapshot, + const SnapshotChecker* snapshot_checker, Env* env, + bool report_detailed_time, bool expect_valid_internal_key, + CompactionRangeDelAggregator* range_del_agg, + std::unique_ptr compaction, + const CompactionFilter* compaction_filter = nullptr, + const std::atomic* shutting_down = nullptr, + const SequenceNumber preserve_deletes_seqnum = 0, + const std::atomic* manual_compaction_paused = nullptr); ~CompactionIterator(); @@ -231,7 +231,7 @@ class CompactionIterator { bool IsPausingManualCompaction() { // This is a best-effort facility, so memory_order_relaxed is sufficient. return manual_compaction_paused_ && - manual_compaction_paused_->load(std::memory_order_relaxed); + manual_compaction_paused_->load(std::memory_order_relaxed); } }; } // namespace rocksdb diff --git a/db/compaction/compaction_job.cc b/db/compaction/compaction_job.cc index 2111599f9..5d2a6bfd8 100644 --- a/db/compaction/compaction_job.cc +++ b/db/compaction/compaction_job.cc @@ -870,9 +870,10 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) { db_options_.statistics.get()); TEST_SYNC_POINT("CompactionJob::Run():Inprogress"); - TEST_SYNC_POINT_CALLBACK("CompactionJob::Run():PausingManualCompaction:1", - reinterpret_cast( - const_cast *>(manual_compaction_paused_))); + TEST_SYNC_POINT_CALLBACK( + "CompactionJob::Run():PausingManualCompaction:1", + reinterpret_cast( + const_cast*>(manual_compaction_paused_))); Slice* start = sub_compact->start; Slice* end = sub_compact->end; @@ -954,9 +955,10 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) { input_status = input->status(); output_file_ended = true; } - TEST_SYNC_POINT_CALLBACK("CompactionJob::Run():PausingManualCompaction:2", - reinterpret_cast( - const_cast *>(manual_compaction_paused_))); + TEST_SYNC_POINT_CALLBACK( + "CompactionJob::Run():PausingManualCompaction:2", + reinterpret_cast( + const_cast*>(manual_compaction_paused_))); c_iter->Next(); if (c_iter->status().IsManualCompactionPaused()) { break; diff --git a/db/compaction/compaction_job.h b/db/compaction/compaction_job.h index 783000506..bca4c9942 100644 --- a/db/compaction/compaction_job.h +++ b/db/compaction/compaction_job.h @@ -62,21 +62,23 @@ class VersionSet; // if needed. class CompactionJob { public: - CompactionJob( - int job_id, Compaction* compaction, const ImmutableDBOptions& db_options, - const EnvOptions env_options, VersionSet* versions, - const std::atomic* shutting_down, - const SequenceNumber preserve_deletes_seqnum, LogBuffer* log_buffer, - Directory* db_directory, Directory* output_directory, Statistics* stats, - InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler, - std::vector existing_snapshots, - SequenceNumber earliest_write_conflict_snapshot, - const SnapshotChecker* snapshot_checker, - std::shared_ptr table_cache, EventLogger* event_logger, - bool paranoid_file_checks, bool measure_io_stats, - const std::string& dbname, CompactionJobStats* compaction_job_stats, - Env::Priority thread_pri, - const std::atomic* manual_compaction_paused = nullptr); + CompactionJob(int job_id, Compaction* compaction, + const ImmutableDBOptions& db_options, + const EnvOptions env_options, VersionSet* versions, + const std::atomic* shutting_down, + const SequenceNumber preserve_deletes_seqnum, + LogBuffer* log_buffer, Directory* db_directory, + Directory* output_directory, Statistics* stats, + InstrumentedMutex* db_mutex, ErrorHandler* db_error_handler, + std::vector existing_snapshots, + SequenceNumber earliest_write_conflict_snapshot, + const SnapshotChecker* snapshot_checker, + std::shared_ptr table_cache, EventLogger* event_logger, + bool paranoid_file_checks, bool measure_io_stats, + const std::string& dbname, + CompactionJobStats* compaction_job_stats, + Env::Priority thread_pri, + const std::atomic* manual_compaction_paused = nullptr); ~CompactionJob(); diff --git a/db/db_impl/db_impl_compaction_flush.cc b/db/db_impl/db_impl_compaction_flush.cc index 6724f3e6f..42b0b93bb 100644 --- a/db/db_impl/db_impl_compaction_flush.cc +++ b/db/db_impl/db_impl_compaction_flush.cc @@ -983,8 +983,7 @@ Status DBImpl::CompactFilesImpl( snapshot_checker, table_cache_, &event_logger_, c->mutable_cf_options()->paranoid_file_checks, c->mutable_cf_options()->report_bg_io_stats, dbname_, - &compaction_job_stats, Env::Priority::USER, - &manual_compaction_paused_); + &compaction_job_stats, Env::Priority::USER, &manual_compaction_paused_); // Creating a compaction influences the compaction score because the score // takes running compactions into account (by skipping files that are already @@ -2313,8 +2312,7 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction, env_->SleepForMicroseconds(10000); // prevent hot loop mutex_.Lock(); } else if (!s.ok() && !s.IsShutdownInProgress() && - !s.IsManualCompactionPaused() && - !s.IsColumnFamilyDropped()) { + !s.IsManualCompactionPaused() && !s.IsColumnFamilyDropped()) { // Wait a little bit before retrying background compaction in // case this is an environmental problem and we do not want to // chew up resources for failed compactions for the duration of @@ -2332,11 +2330,10 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction, env_->SleepForMicroseconds(1000000); mutex_.Lock(); } else if (s.IsManualCompactionPaused()) { - ManualCompactionState *m = prepicked_compaction->manual_compaction_state; + ManualCompactionState* m = prepicked_compaction->manual_compaction_state; assert(m); ROCKS_LOG_BUFFER(&log_buffer, "[%s] [JOB %d] Manual compaction paused", - m->cfd->GetName().c_str(), - job_context.job_id); + m->cfd->GetName().c_str(), job_context.job_id); } ReleaseFileNumberFromPendingOutputs(pending_outputs_inserted_elem); @@ -2345,8 +2342,8 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction, // have created (they might not be all recorded in job_context in case of a // failure). Thus, we force full scan in FindObsoleteFiles() FindObsoleteFiles(&job_context, !s.ok() && !s.IsShutdownInProgress() && - !s.IsManualCompactionPaused() && - !s.IsColumnFamilyDropped()); + !s.IsManualCompactionPaused() && + !s.IsColumnFamilyDropped()); TEST_SYNC_POINT("DBImpl::BackgroundCallCompaction:FoundObsoleteFiles"); // delete unnecessary files if any, this is done outside the mutex @@ -2430,7 +2427,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress, if (shutting_down_.load(std::memory_order_acquire)) { status = Status::ShutdownInProgress(); } else if (is_manual && - manual_compaction_paused_.load(std::memory_order_acquire)) { + manual_compaction_paused_.load(std::memory_order_acquire)) { status = Status::Incomplete(Status::SubCode::kManualCompactionPaused); } } else { diff --git a/db/db_impl/db_impl_readonly.cc b/db/db_impl/db_impl_readonly.cc index d989bd8c7..8a8a9c9d0 100644 --- a/db/db_impl/db_impl_readonly.cc +++ b/db/db_impl/db_impl_readonly.cc @@ -3,8 +3,8 @@ // COPYING file in the root directory) and Apache 2.0 License // (found in the LICENSE.Apache file in the root directory). -#include "db/arena_wrapped_db_iter.h" #include "db/db_impl/db_impl_readonly.h" +#include "db/arena_wrapped_db_iter.h" #include "db/compacted_db_impl.h" #include "db/db_impl/db_impl.h" diff --git a/db/db_iter.h b/db/db_iter.h index 15ee56d50..e6e072c50 100644 --- a/db/db_iter.h +++ b/db/db_iter.h @@ -53,7 +53,7 @@ namespace rocksdb { // combines multiple entries for the same userkey found in the DB // representation into a single entry while accounting for sequence // numbers, deletion markers, overwrites, etc. -class DBIter final: public Iterator { +class DBIter final : public Iterator { public: // The following is grossly complicated. TODO: clean it up // Which direction is the iterator currently moving? @@ -66,10 +66,7 @@ class DBIter final: public Iterator { // this->key(). // (2) When moving backwards, the internal iterator is positioned // just before all entries whose user key == this->key(). - enum Direction { - kForward, - kReverse - }; + enum Direction { kForward, kReverse }; // LocalStatistics contain Statistics counters that will be aggregated per // each iterator instance and then will be sent to the global statistics when @@ -148,7 +145,7 @@ class DBIter final: public Iterator { bool Valid() const override { return valid_; } Slice key() const override { assert(valid_); - if(start_seqnum_ > 0) { + if (start_seqnum_ > 0) { return saved_key_.GetInternalKey(); } else { return saved_key_.GetUserKey(); diff --git a/db/db_test2.cc b/db/db_test2.cc index 746966bda..82df2a908 100644 --- a/db/db_test2.cc +++ b/db/db_test2.cc @@ -2458,8 +2458,7 @@ TEST_F(DBTest2, PausingManualCompaction1) { manual_compactions_paused = 0; // Now make sure CompactFiles also not run - dbfull()->CompactFiles(rocksdb::CompactionOptions(), - files_before_compact, 0); + dbfull()->CompactFiles(rocksdb::CompactionOptions(), files_before_compact, 0); // Wait for manual compaction to get scheduled and finish dbfull()->TEST_WaitForCompact(true); @@ -2510,14 +2509,14 @@ TEST_F(DBTest2, PausingManualCompaction3) { Random rnd(301); auto generate_files = [&]() { for (int i = 0; i < options.num_levels; i++) { - for (int j = 0; j < options.num_levels-i+1; j++) { + for (int j = 0; j < options.num_levels - i + 1; j++) { for (int k = 0; k < 1000; k++) { ASSERT_OK(Put(Key(k + j * 1000), RandomString(&rnd, 50))); } Flush(); } - for (int l = 1; l < options.num_levels-i; l++) { + for (int l = 1; l < options.num_levels - i; l++) { MoveFilesToLevel(l); } } @@ -2530,9 +2529,8 @@ TEST_F(DBTest2, PausingManualCompaction3) { #endif // !ROCKSDB_LITE int run_manual_compactions = 0; rocksdb::SyncPoint::GetInstance()->SetCallBack( - "CompactionJob::Run():PausingManualCompaction:1", [&](void* /*arg*/) { - run_manual_compactions++; - }); + "CompactionJob::Run():PausingManualCompaction:1", + [&](void* /*arg*/) { run_manual_compactions++; }); rocksdb::SyncPoint::GetInstance()->EnableProcessing(); dbfull()->DisableManualCompaction(); @@ -2565,14 +2563,14 @@ TEST_F(DBTest2, PausingManualCompaction4) { Random rnd(301); auto generate_files = [&]() { for (int i = 0; i < options.num_levels; i++) { - for (int j = 0; j < options.num_levels-i+1; j++) { + for (int j = 0; j < options.num_levels - i + 1; j++) { for (int k = 0; k < 1000; k++) { ASSERT_OK(Put(Key(k + j * 1000), RandomString(&rnd, 50))); } Flush(); } - for (int l = 1; l < options.num_levels-i; l++) { + for (int l = 1; l < options.num_levels - i; l++) { MoveFilesToLevel(l); } } diff --git a/java/benchmark/src/main/java/org/rocksdb/benchmark/DbBenchmark.java b/java/benchmark/src/main/java/org/rocksdb/benchmark/DbBenchmark.java index da515219f..ff36c74a4 100644 --- a/java/benchmark/src/main/java/org/rocksdb/benchmark/DbBenchmark.java +++ b/java/benchmark/src/main/java/org/rocksdb/benchmark/DbBenchmark.java @@ -646,8 +646,8 @@ public class DbBenchmark { currentTaskId++, randSeed_, num_, num_, writeOpt, 1)); break; case "fillbatch": - tasks.add(new WriteSequentialTask( - currentTaskId++, randSeed_, num_, num_, writeOpt, 1000)); + tasks.add( + new WriteSequentialTask(currentTaskId++, randSeed_, num_, num_, writeOpt, 1000)); break; case "fillrandom": tasks.add(new WriteRandomTask( @@ -901,27 +901,23 @@ public class DbBenchmark { } private enum Flag { - benchmarks( - Arrays.asList( - "fillseq", - "readrandom", - "fillrandom"), - "Comma-separated list of operations to run in the specified order\n" + - "\tActual benchmarks:\n" + - "\t\tfillseq -- write N values in sequential key order in async mode.\n" + - "\t\tfillrandom -- write N values in random key order in async mode.\n" + - "\t\tfillbatch -- write N/1000 batch where each batch has 1000 values\n" + - "\t\t in sequential key order in sync mode.\n" + - "\t\tfillsync -- write N/100 values in random key order in sync mode.\n" + - "\t\tfill100K -- write N/1000 100K values in random order in async mode.\n" + - "\t\treadseq -- read N times sequentially.\n" + - "\t\treadrandom -- read N times in random order.\n" + - "\t\treadhot -- read N times in random order from 1% section of DB.\n" + - "\t\treadwhilewriting -- measure the read performance of multiple readers\n" + - "\t\t with a bg single writer. The write rate of the bg\n" + - "\t\t is capped by --writes_per_second.\n" + - "\tMeta Operations:\n" + - "\t\tdelete -- delete DB") { + benchmarks(Arrays.asList("fillseq", "readrandom", "fillrandom"), + "Comma-separated list of operations to run in the specified order\n" + + "\tActual benchmarks:\n" + + "\t\tfillseq -- write N values in sequential key order in async mode.\n" + + "\t\tfillrandom -- write N values in random key order in async mode.\n" + + "\t\tfillbatch -- write N/1000 batch where each batch has 1000 values\n" + + "\t\t in sequential key order in sync mode.\n" + + "\t\tfillsync -- write N/100 values in random key order in sync mode.\n" + + "\t\tfill100K -- write N/1000 100K values in random order in async mode.\n" + + "\t\treadseq -- read N times sequentially.\n" + + "\t\treadrandom -- read N times in random order.\n" + + "\t\treadhot -- read N times in random order from 1% section of DB.\n" + + "\t\treadwhilewriting -- measure the read performance of multiple readers\n" + + "\t\t with a bg single writer. The write rate of the bg\n" + + "\t\t is capped by --writes_per_second.\n" + + "\tMeta Operations:\n" + + "\t\tdelete -- delete DB") { @Override public Object parseValue(String value) { return new ArrayList(Arrays.asList(value.split(","))); } diff --git a/java/rocksjni/sst_file_reader_iterator.cc b/java/rocksjni/sst_file_reader_iterator.cc index 7ab97e412..4cbbf04bd 100644 --- a/java/rocksjni/sst_file_reader_iterator.cc +++ b/java/rocksjni/sst_file_reader_iterator.cc @@ -6,13 +6,13 @@ // This file implements the "bridge" between Java and C++ and enables // calling c++ rocksdb::Iterator methods from Java side. +#include #include #include -#include #include "include/org_rocksdb_SstFileReaderIterator.h" -#include "rocksjni/portal.h" #include "rocksdb/iterator.h" +#include "rocksjni/portal.h" /* * Class: org_rocksdb_SstFileReaderIterator @@ -22,9 +22,9 @@ void Java_org_rocksdb_SstFileReaderIterator_disposeInternal(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { - auto* it = reinterpret_cast(handle); - assert(it != nullptr); - delete it; + auto* it = reinterpret_cast(handle); + assert(it != nullptr); + delete it; } /* @@ -35,7 +35,7 @@ void Java_org_rocksdb_SstFileReaderIterator_disposeInternal(JNIEnv* /*env*/, jboolean Java_org_rocksdb_SstFileReaderIterator_isValid0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { - return reinterpret_cast(handle)->Valid(); + return reinterpret_cast(handle)->Valid(); } /* @@ -46,7 +46,7 @@ jboolean Java_org_rocksdb_SstFileReaderIterator_isValid0(JNIEnv* /*env*/, void Java_org_rocksdb_SstFileReaderIterator_seekToFirst0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { - reinterpret_cast(handle)->SeekToFirst(); + reinterpret_cast(handle)->SeekToFirst(); } /* @@ -57,7 +57,7 @@ void Java_org_rocksdb_SstFileReaderIterator_seekToFirst0(JNIEnv* /*env*/, void Java_org_rocksdb_SstFileReaderIterator_seekToLast0(JNIEnv* /*env*/, jobject /*jobj*/, jlong handle) { - reinterpret_cast(handle)->SeekToLast(); + reinterpret_cast(handle)->SeekToLast(); } /* @@ -65,9 +65,10 @@ void Java_org_rocksdb_SstFileReaderIterator_seekToLast0(JNIEnv* /*env*/, * Method: next0 * Signature: (J)V */ -void Java_org_rocksdb_SstFileReaderIterator_next0(JNIEnv* /*env*/, jobject /*jobj*/, +void Java_org_rocksdb_SstFileReaderIterator_next0(JNIEnv* /*env*/, + jobject /*jobj*/, jlong handle) { - reinterpret_cast(handle)->Next(); + reinterpret_cast(handle)->Next(); } /* @@ -75,9 +76,10 @@ void Java_org_rocksdb_SstFileReaderIterator_next0(JNIEnv* /*env*/, jobject /*job * Method: prev0 * Signature: (J)V */ -void Java_org_rocksdb_SstFileReaderIterator_prev0(JNIEnv* /*env*/, jobject /*jobj*/, +void Java_org_rocksdb_SstFileReaderIterator_prev0(JNIEnv* /*env*/, + jobject /*jobj*/, jlong handle) { - reinterpret_cast(handle)->Prev(); + reinterpret_cast(handle)->Prev(); } /* @@ -86,21 +88,21 @@ void Java_org_rocksdb_SstFileReaderIterator_prev0(JNIEnv* /*env*/, jobject /*job * Signature: (J[BI)V */ void Java_org_rocksdb_SstFileReaderIterator_seek0(JNIEnv* env, jobject /*jobj*/, - jlong handle, jbyteArray jtarget, + jlong handle, + jbyteArray jtarget, jint jtarget_len) { - jbyte* target = env->GetByteArrayElements(jtarget, nullptr); - if(target == nullptr) { - // exception thrown: OutOfMemoryError - return; - } + jbyte* target = env->GetByteArrayElements(jtarget, nullptr); + if (target == nullptr) { + // exception thrown: OutOfMemoryError + return; + } - rocksdb::Slice target_slice( - reinterpret_cast(target), jtarget_len); + rocksdb::Slice target_slice(reinterpret_cast(target), jtarget_len); - auto* it = reinterpret_cast(handle); - it->Seek(target_slice); + auto* it = reinterpret_cast(handle); + it->Seek(target_slice); - env->ReleaseByteArrayElements(jtarget, target, JNI_ABORT); + env->ReleaseByteArrayElements(jtarget, target, JNI_ABORT); } /* @@ -108,23 +110,23 @@ void Java_org_rocksdb_SstFileReaderIterator_seek0(JNIEnv* env, jobject /*jobj*/, * Method: seekForPrev0 * Signature: (J[BI)V */ -void Java_org_rocksdb_SstFileReaderIterator_seekForPrev0(JNIEnv* env, jobject /*jobj*/, +void Java_org_rocksdb_SstFileReaderIterator_seekForPrev0(JNIEnv* env, + jobject /*jobj*/, jlong handle, jbyteArray jtarget, jint jtarget_len) { - jbyte* target = env->GetByteArrayElements(jtarget, nullptr); - if(target == nullptr) { - // exception thrown: OutOfMemoryError - return; - } + jbyte* target = env->GetByteArrayElements(jtarget, nullptr); + if (target == nullptr) { + // exception thrown: OutOfMemoryError + return; + } - rocksdb::Slice target_slice( - reinterpret_cast(target), jtarget_len); + rocksdb::Slice target_slice(reinterpret_cast(target), jtarget_len); - auto* it = reinterpret_cast(handle); - it->SeekForPrev(target_slice); + auto* it = reinterpret_cast(handle); + it->SeekForPrev(target_slice); - env->ReleaseByteArrayElements(jtarget, target, JNI_ABORT); + env->ReleaseByteArrayElements(jtarget, target, JNI_ABORT); } /* @@ -132,16 +134,17 @@ void Java_org_rocksdb_SstFileReaderIterator_seekForPrev0(JNIEnv* env, jobject /* * Method: status0 * Signature: (J)V */ -void Java_org_rocksdb_SstFileReaderIterator_status0(JNIEnv* env, jobject /*jobj*/, +void Java_org_rocksdb_SstFileReaderIterator_status0(JNIEnv* env, + jobject /*jobj*/, jlong handle) { - auto* it = reinterpret_cast(handle); - rocksdb::Status s = it->status(); + auto* it = reinterpret_cast(handle); + rocksdb::Status s = it->status(); - if (s.ok()) { - return; - } + if (s.ok()) { + return; + } - rocksdb::RocksDBExceptionJni::ThrowNew(env, s); + rocksdb::RocksDBExceptionJni::ThrowNew(env, s); } /* @@ -149,19 +152,21 @@ void Java_org_rocksdb_SstFileReaderIterator_status0(JNIEnv* env, jobject /*jobj* * Method: key0 * Signature: (J)[B */ -jbyteArray Java_org_rocksdb_SstFileReaderIterator_key0(JNIEnv* env, jobject /*jobj*/, +jbyteArray Java_org_rocksdb_SstFileReaderIterator_key0(JNIEnv* env, + jobject /*jobj*/, jlong handle) { - auto* it = reinterpret_cast(handle); - rocksdb::Slice key_slice = it->key(); + auto* it = reinterpret_cast(handle); + rocksdb::Slice key_slice = it->key(); - jbyteArray jkey = env->NewByteArray(static_cast(key_slice.size())); - if(jkey == nullptr) { - // exception thrown: OutOfMemoryError - return nullptr; - } - env->SetByteArrayRegion(jkey, 0, static_cast(key_slice.size()), - const_cast(reinterpret_cast(key_slice.data()))); - return jkey; + jbyteArray jkey = env->NewByteArray(static_cast(key_slice.size())); + if (jkey == nullptr) { + // exception thrown: OutOfMemoryError + return nullptr; + } + env->SetByteArrayRegion( + jkey, 0, static_cast(key_slice.size()), + const_cast(reinterpret_cast(key_slice.data()))); + return jkey; } /* diff --git a/java/rocksjni/sst_file_readerjni.cc b/java/rocksjni/sst_file_readerjni.cc index 32b914a2d..c8348c2e2 100644 --- a/java/rocksjni/sst_file_readerjni.cc +++ b/java/rocksjni/sst_file_readerjni.cc @@ -23,8 +23,8 @@ * Signature: (J)J */ jlong Java_org_rocksdb_SstFileReader_newSstFileReader(JNIEnv * /*env*/, - jclass /*jcls*/, - jlong joptions) { + jclass /*jcls*/, + jlong joptions) { auto *options = reinterpret_cast(joptions); rocksdb::SstFileReader *sst_file_reader = new rocksdb::SstFileReader(*options); @@ -53,18 +53,18 @@ void Java_org_rocksdb_SstFileReader_open(JNIEnv *env, jobject /*jobj*/, } /* -* Class: org_rocksdb_SstFileReader -* Method: newIterator -* Signature: (JJ)J -*/ -jlong Java_org_rocksdb_SstFileReader_newIterator(JNIEnv* /*env*/, + * Class: org_rocksdb_SstFileReader + * Method: newIterator + * Signature: (JJ)J + */ +jlong Java_org_rocksdb_SstFileReader_newIterator(JNIEnv * /*env*/, jobject /*jobj*/, jlong jhandle, jlong jread_options_handle) { - auto* sst_file_reader = reinterpret_cast(jhandle); - auto* read_options = - reinterpret_cast(jread_options_handle); - return reinterpret_cast(sst_file_reader->NewIterator(*read_options)); + auto *sst_file_reader = reinterpret_cast(jhandle); + auto *read_options = + reinterpret_cast(jread_options_handle); + return reinterpret_cast(sst_file_reader->NewIterator(*read_options)); } /* @@ -75,7 +75,7 @@ jlong Java_org_rocksdb_SstFileReader_newIterator(JNIEnv* /*env*/, void Java_org_rocksdb_SstFileReader_disposeInternal(JNIEnv * /*env*/, jobject /*jobj*/, jlong jhandle) { - delete reinterpret_cast(jhandle); + delete reinterpret_cast(jhandle); } /* @@ -84,9 +84,9 @@ void Java_org_rocksdb_SstFileReader_disposeInternal(JNIEnv * /*env*/, * Signature: (J)V */ void Java_org_rocksdb_SstFileReader_verifyChecksum(JNIEnv *env, - jobject /*jobj*/, - jlong jhandle) { - auto* sst_file_reader = reinterpret_cast(jhandle); + jobject /*jobj*/, + jlong jhandle) { + auto *sst_file_reader = reinterpret_cast(jhandle); auto s = sst_file_reader->VerifyChecksum(); if (!s.ok()) { rocksdb::RocksDBExceptionJni::ThrowNew(env, s); @@ -99,12 +99,12 @@ void Java_org_rocksdb_SstFileReader_verifyChecksum(JNIEnv *env, * Signature: (J)J */ jobject Java_org_rocksdb_SstFileReader_getTableProperties(JNIEnv *env, - jobject /*jobj*/, - jlong jhandle) { - auto* sst_file_reader = reinterpret_cast(jhandle); - std::shared_ptr tp = sst_file_reader->GetTableProperties(); - jobject jtable_properties = rocksdb::TablePropertiesJni::fromCppTableProperties( - env, *(tp.get())); + jobject /*jobj*/, + jlong jhandle) { + auto *sst_file_reader = reinterpret_cast(jhandle); + std::shared_ptr tp = + sst_file_reader->GetTableProperties(); + jobject jtable_properties = + rocksdb::TablePropertiesJni::fromCppTableProperties(env, *(tp.get())); return jtable_properties; } - diff --git a/java/src/main/java/org/rocksdb/SstFileReader.java b/java/src/main/java/org/rocksdb/SstFileReader.java index 66349f32f..53f96e3cc 100644 --- a/java/src/main/java/org/rocksdb/SstFileReader.java +++ b/java/src/main/java/org/rocksdb/SstFileReader.java @@ -31,19 +31,18 @@ public class SstFileReader extends RocksObject { * @return instance of iterator object. */ public SstFileReaderIterator newIterator(final ReadOptions readOptions) { - assert(isOwningHandle()); - long iter = newIterator(nativeHandle_, - readOptions.nativeHandle_); + assert (isOwningHandle()); + long iter = newIterator(nativeHandle_, readOptions.nativeHandle_); return new SstFileReaderIterator(this, iter); } /** - * Prepare SstFileReader to read a file. - * - * @param filePath the location of file - * - * @throws RocksDBException thrown if error happens in underlying - * native library. + * Prepare SstFileReader to read a file. + * + * @param filePath the location of file + * + * @throws RocksDBException thrown if error happens in underlying + * native library. */ public void open(final String filePath) throws RocksDBException { open(nativeHandle_, filePath); @@ -68,14 +67,10 @@ public class SstFileReader extends RocksObject { return getTableProperties(nativeHandle_); } - - @Override protected final native void disposeInternal(final long handle); - private native long newIterator(final long handle, - final long readOptionsHandle); + private native long newIterator(final long handle, final long readOptionsHandle); - private native void open(final long handle, final String filePath) - throws RocksDBException; + private native void open(final long handle, final String filePath) throws RocksDBException; private native static long newSstFileReader(final long optionsHandle); private native void verifyChecksum(final long handle) throws RocksDBException; diff --git a/java/src/main/java/org/rocksdb/SstFileReaderIterator.java b/java/src/main/java/org/rocksdb/SstFileReaderIterator.java index ef303f042..d01b7a390 100644 --- a/java/src/main/java/org/rocksdb/SstFileReaderIterator.java +++ b/java/src/main/java/org/rocksdb/SstFileReaderIterator.java @@ -33,7 +33,7 @@ public class SstFileReaderIterator extends AbstractRocksIterator * @return key for the current entry. */ public byte[] key() { - assert(isOwningHandle()); + assert (isOwningHandle()); return key0(nativeHandle_); } @@ -46,7 +46,7 @@ public class SstFileReaderIterator extends AbstractRocksIterator * @return value for the current entry. */ public byte[] value() { - assert(isOwningHandle()); + assert (isOwningHandle()); return value0(nativeHandle_); } diff --git a/java/src/test/java/org/rocksdb/SstFileReaderTest.java b/java/src/test/java/org/rocksdb/SstFileReaderTest.java index 5ccc8dec9..c0e3a73d8 100644 --- a/java/src/test/java/org/rocksdb/SstFileReaderTest.java +++ b/java/src/test/java/org/rocksdb/SstFileReaderTest.java @@ -48,9 +48,10 @@ public class SstFileReaderTest { @Rule public TemporaryFolder parentFolder = new TemporaryFolder(); - enum OpType { PUT, PUT_BYTES, MERGE, MERGE_BYTES, DELETE, DELETE_BYTES} + enum OpType { PUT, PUT_BYTES, MERGE, MERGE_BYTES, DELETE, DELETE_BYTES } - private File newSstFile(final List keyValues) throws IOException, RocksDBException { + private File newSstFile(final List keyValues) + throws IOException, RocksDBException { final EnvOptions envOptions = new EnvOptions(); final StringAppendOperator stringAppendOperator = new StringAppendOperator(); final Options options = new Options().setMergeOperator(stringAppendOperator); @@ -105,15 +106,11 @@ public class SstFileReaderTest { final List keyValues = new ArrayList<>(); keyValues.add(new KeyValueWithOp("key1", "value1", OpType.PUT)); - final File sstFile = newSstFile(keyValues); - try(final StringAppendOperator stringAppendOperator = - new StringAppendOperator(); - final Options options = new Options() - .setCreateIfMissing(true) - .setMergeOperator(stringAppendOperator); - final SstFileReader reader = new SstFileReader(options) - ) { + try (final StringAppendOperator stringAppendOperator = new StringAppendOperator(); + final Options options = + new Options().setCreateIfMissing(true).setMergeOperator(stringAppendOperator); + final SstFileReader reader = new SstFileReader(options)) { // Open the sst file and iterator reader.open(sstFile.getAbsolutePath()); final ReadOptions readOptions = new ReadOptions(); @@ -133,5 +130,4 @@ public class SstFileReaderTest { assertThat(iterator.value()).isEqualTo("value1".getBytes()); } } - } diff --git a/options/options_settable_test.cc b/options/options_settable_test.cc index d46a23da7..bc2e088a6 100644 --- a/options/options_settable_test.cc +++ b/options/options_settable_test.cc @@ -356,8 +356,7 @@ TEST_F(OptionsSettableTest, ColumnFamilyOptionsAllFieldsSettable) { {offset_of(&ColumnFamilyOptions::snap_refresh_nanos), sizeof(uint64_t)}, {offset_of(&ColumnFamilyOptions::table_factory), sizeof(std::shared_ptr)}, - {offset_of(&ColumnFamilyOptions::cf_paths), - sizeof(std::vector)}, + {offset_of(&ColumnFamilyOptions::cf_paths), sizeof(std::vector)}, {offset_of(&ColumnFamilyOptions::compaction_thread_limiter), sizeof(std::shared_ptr)}, }; diff --git a/tools/block_cache_analyzer/block_cache_trace_analyzer.cc b/tools/block_cache_analyzer/block_cache_trace_analyzer.cc index 0dd99dab8..709f07221 100644 --- a/tools/block_cache_analyzer/block_cache_trace_analyzer.cc +++ b/tools/block_cache_analyzer/block_cache_trace_analyzer.cc @@ -1830,8 +1830,10 @@ void BlockCacheTraceAnalyzer::PrintDataBlockAccessStats() const { hist_naccess_per_key.Add(caller_access.second); } } - uint64_t avg_accesses = static_cast(hist_naccess_per_key.Average()); - uint64_t stdev_accesses = static_cast(hist_naccess_per_key.StandardDeviation()); + uint64_t avg_accesses = + static_cast(hist_naccess_per_key.Average()); + uint64_t stdev_accesses = + static_cast(hist_naccess_per_key.StandardDeviation()); avg_naccesses_per_key_in_a_data_block.Add(avg_accesses); cf_avg_naccesses_per_key_in_a_data_block[cf_name].Add(avg_accesses); stdev_naccesses_per_key_in_a_data_block.Add(stdev_accesses); diff --git a/tools/db_stress.cc b/tools/db_stress.cc index 129ea7aa4..fb002592e 100644 --- a/tools/db_stress.cc +++ b/tools/db_stress.cc @@ -353,8 +353,9 @@ DEFINE_int32(bloom_bits, 10, "Bloom filter bits per key. " DEFINE_bool(use_block_based_filter, false, "use block based filter" "instead of full filter for block based table"); -DEFINE_bool(partition_filters, false, "use partitioned filters " - "for block-based table"); +DEFINE_bool(partition_filters, false, + "use partitioned filters " + "for block-based table"); DEFINE_int32( index_type, diff --git a/tools/sst_dump_tool.cc b/tools/sst_dump_tool.cc index efe272c09..9f3e7d6b2 100644 --- a/tools/sst_dump_tool.cc +++ b/tools/sst_dump_tool.cc @@ -405,8 +405,9 @@ Status SstFileDumper::ReadTableProperties( namespace { void print_help() { - fprintf(stderr, - R"(sst_dump --file= [--command=check|scan|raw|recompress] + fprintf( + stderr, + R"(sst_dump --file= [--command=check|scan|raw|recompress] --file= Path to SST file or directory containing SST files diff --git a/util/bloom_impl.h b/util/bloom_impl.h index 13c7a7ec6..500e04968 100644 --- a/util/bloom_impl.h +++ b/util/bloom_impl.h @@ -26,13 +26,13 @@ namespace rocksdb { // See e.g. RocksDB DynamicBloom. // class LegacyNoLocalityBloomImpl { -public: - static inline void AddHash(uint32_t h, uint32_t total_bits, - int num_probes, char *data) { + public: + static inline void AddHash(uint32_t h, uint32_t total_bits, int num_probes, + char *data) { const uint32_t delta = (h >> 17) | (h << 15); // Rotate right 17 bits for (int i = 0; i < num_probes; i++) { const uint32_t bitpos = h % total_bits; - data[bitpos/8] |= (1 << (bitpos % 8)); + data[bitpos / 8] |= (1 << (bitpos % 8)); h += delta; } } @@ -42,7 +42,7 @@ public: const uint32_t delta = (h >> 17) | (h << 15); // Rotate right 17 bits for (int i = 0; i < num_probes; i++) { const uint32_t bitpos = h % total_bits; - if ((data[bitpos/8] & (1 << (bitpos % 8))) == 0) { + if ((data[bitpos / 8] & (1 << (bitpos % 8))) == 0) { return false; } h += delta; @@ -51,7 +51,6 @@ public: } }; - // A legacy Bloom filter implementation with probes local to a single // cache line (fast). Because SST files might be transported between // platforms, the cache line size is a parameter rather than hard coded. @@ -72,15 +71,15 @@ public: // template class LegacyLocalityBloomImpl { -private: + private: static inline uint32_t GetLine(uint32_t h, uint32_t num_lines) { uint32_t offset_h = ExtraRotates ? (h >> 11) | (h << 21) : h; return offset_h % num_lines; } -public: - static inline void AddHash(uint32_t h, uint32_t num_lines, - int num_probes, char *data, - int log2_cache_line_bytes) { + + public: + static inline void AddHash(uint32_t h, uint32_t num_lines, int num_probes, + char *data, int log2_cache_line_bytes) { const int log2_cache_line_bits = log2_cache_line_bytes + 3; char *data_at_offset = @@ -99,12 +98,12 @@ public: static inline void PrepareHashMayMatch(uint32_t h, uint32_t num_lines, const char *data, - uint32_t /*out*/*byte_offset, + uint32_t /*out*/ *byte_offset, int log2_cache_line_bytes) { uint32_t b = GetLine(h, num_lines) << log2_cache_line_bytes; PREFETCH(data + b, 0 /* rw */, 1 /* locality */); - PREFETCH(data + b + ((1 << log2_cache_line_bytes) - 1), - 0 /* rw */, 1 /* locality */); + PREFETCH(data + b + ((1 << log2_cache_line_bytes) - 1), 0 /* rw */, + 1 /* locality */); *byte_offset = b; } @@ -112,8 +111,7 @@ public: int num_probes, const char *data, int log2_cache_line_bytes) { uint32_t b = GetLine(h, num_lines) << log2_cache_line_bytes; - return HashMayMatchPrepared(h, num_probes, - data + b, log2_cache_line_bytes); + return HashMayMatchPrepared(h, num_probes, data + b, log2_cache_line_bytes); } static inline bool HashMayMatchPrepared(uint32_t h, int num_probes, diff --git a/util/concurrent_task_limiter_impl.h b/util/concurrent_task_limiter_impl.h index 91b7bbe3d..4e6251f6a 100644 --- a/util/concurrent_task_limiter_impl.h +++ b/util/concurrent_task_limiter_impl.h @@ -24,8 +24,8 @@ class ConcurrentTaskLimiterImpl : public ConcurrentTaskLimiter { int32_t max_outstanding_task); // No copying allowed ConcurrentTaskLimiterImpl(const ConcurrentTaskLimiterImpl&) = delete; - ConcurrentTaskLimiterImpl& operator=( - const ConcurrentTaskLimiterImpl&) = delete; + ConcurrentTaskLimiterImpl& operator=(const ConcurrentTaskLimiterImpl&) = + delete; virtual ~ConcurrentTaskLimiterImpl(); diff --git a/util/crc32c_arm64.h b/util/crc32c_arm64.h index 2594f2470..ec87720ec 100644 --- a/util/crc32c_arm64.h +++ b/util/crc32c_arm64.h @@ -17,17 +17,21 @@ #define crc32c_u16(crc, v) __crc32ch(crc, v) #define crc32c_u32(crc, v) __crc32cw(crc, v) #define crc32c_u64(crc, v) __crc32cd(crc, v) -#define PREF4X64L1(buffer,PREF_OFFSET, ITR) \ - __asm__("PRFM PLDL1KEEP, [%x[v],%[c]]"::[v]"r"(buffer), [c]"I"((PREF_OFFSET) + ((ITR) + 0)*64));\ - __asm__("PRFM PLDL1KEEP, [%x[v],%[c]]"::[v]"r"(buffer), [c]"I"((PREF_OFFSET) + ((ITR) + 1)*64));\ - __asm__("PRFM PLDL1KEEP, [%x[v],%[c]]"::[v]"r"(buffer), [c]"I"((PREF_OFFSET) + ((ITR) + 2)*64));\ - __asm__("PRFM PLDL1KEEP, [%x[v],%[c]]"::[v]"r"(buffer), [c]"I"((PREF_OFFSET) + ((ITR) + 3)*64)); +#define PREF4X64L1(buffer, PREF_OFFSET, ITR) \ + __asm__("PRFM PLDL1KEEP, [%x[v],%[c]]" ::[v] "r"(buffer), \ + [c] "I"((PREF_OFFSET) + ((ITR) + 0) * 64)); \ + __asm__("PRFM PLDL1KEEP, [%x[v],%[c]]" ::[v] "r"(buffer), \ + [c] "I"((PREF_OFFSET) + ((ITR) + 1) * 64)); \ + __asm__("PRFM PLDL1KEEP, [%x[v],%[c]]" ::[v] "r"(buffer), \ + [c] "I"((PREF_OFFSET) + ((ITR) + 2) * 64)); \ + __asm__("PRFM PLDL1KEEP, [%x[v],%[c]]" ::[v] "r"(buffer), \ + [c] "I"((PREF_OFFSET) + ((ITR) + 3) * 64)); -#define PREF1KL1(buffer,PREF_OFFSET) \ - PREF4X64L1(buffer,(PREF_OFFSET), 0) \ - PREF4X64L1(buffer,(PREF_OFFSET), 4) \ - PREF4X64L1(buffer,(PREF_OFFSET), 8) \ - PREF4X64L1(buffer,(PREF_OFFSET), 12) +#define PREF1KL1(buffer, PREF_OFFSET) \ + PREF4X64L1(buffer, (PREF_OFFSET), 0) \ + PREF4X64L1(buffer, (PREF_OFFSET), 4) \ + PREF4X64L1(buffer, (PREF_OFFSET), 8) \ + PREF4X64L1(buffer, (PREF_OFFSET), 12) extern uint32_t crc32c_arm64(uint32_t crc, unsigned char const *data, unsigned len); extern uint32_t crc32c_runtime_check(void); diff --git a/util/dynamic_bloom.cc b/util/dynamic_bloom.cc index 0ad06942e..26ff1c3aa 100644 --- a/util/dynamic_bloom.cc +++ b/util/dynamic_bloom.cc @@ -42,7 +42,7 @@ DynamicBloom::DynamicBloom(Allocator* allocator, uint32_t total_bits, uint32_t block_bits = block_bytes * 8; uint32_t blocks = (total_bits + block_bits - 1) / block_bits; uint32_t sz = blocks * block_bytes; - kLen = sz / /*bytes/u64*/8; + kLen = sz / /*bytes/u64*/ 8; assert(kLen > 0); #ifndef NDEBUG for (uint32_t i = 0; i < kNumDoubleProbes; ++i) { diff --git a/util/dynamic_bloom_test.cc b/util/dynamic_bloom_test.cc index 4799b35a6..4feaa1f64 100644 --- a/util/dynamic_bloom_test.cc +++ b/util/dynamic_bloom_test.cc @@ -134,41 +134,41 @@ TEST_F(DynamicBloomTest, VaryingLengths) { // NB: FP rate impact of 32-bit hash is noticeable starting around 10M keys. // But that effect is hidden if using sequential keys (unique hashes). for (bool nonseq : {false, true}) { - const uint32_t max_num = FLAGS_enable_perf ? 40000000 : 400000; - for (uint32_t num = 1; num <= max_num; num = NextNum(num)) { - uint32_t bloom_bits = 0; - Arena arena; - bloom_bits = num * FLAGS_bits_per_key; - DynamicBloom bloom(&arena, bloom_bits, num_probes); - for (uint64_t i = 0; i < num; i++) { - bloom.Add(km.Key(i, nonseq)); - ASSERT_TRUE(bloom.MayContain(km.Key(i, nonseq))); - } - - // All added keys must match - for (uint64_t i = 0; i < num; i++) { - ASSERT_TRUE(bloom.MayContain(km.Key(i, nonseq))); - } - - // Check false positive rate - int result = 0; - for (uint64_t i = 0; i < 30000; i++) { - if (bloom.MayContain(km.Key(i + 1000000000, nonseq))) { - result++; + const uint32_t max_num = FLAGS_enable_perf ? 40000000 : 400000; + for (uint32_t num = 1; num <= max_num; num = NextNum(num)) { + uint32_t bloom_bits = 0; + Arena arena; + bloom_bits = num * FLAGS_bits_per_key; + DynamicBloom bloom(&arena, bloom_bits, num_probes); + for (uint64_t i = 0; i < num; i++) { + bloom.Add(km.Key(i, nonseq)); + ASSERT_TRUE(bloom.MayContain(km.Key(i, nonseq))); } + + // All added keys must match + for (uint64_t i = 0; i < num; i++) { + ASSERT_TRUE(bloom.MayContain(km.Key(i, nonseq))); + } + + // Check false positive rate + int result = 0; + for (uint64_t i = 0; i < 30000; i++) { + if (bloom.MayContain(km.Key(i + 1000000000, nonseq))) { + result++; + } + } + double rate = result / 30000.0; + + fprintf(stderr, + "False positives (%s keys): " + "%5.2f%% @ num = %6u, bloom_bits = %6u\n", + nonseq ? "nonseq" : "seq", rate * 100.0, num, bloom_bits); + + if (rate > 0.0125) + mediocre_filters++; // Allowed, but not too often + else + good_filters++; } - double rate = result / 30000.0; - - fprintf(stderr, - "False positives (%s keys): " - "%5.2f%% @ num = %6u, bloom_bits = %6u\n", - nonseq ? "nonseq" : "seq", rate * 100.0, num, bloom_bits); - - if (rate > 0.0125) - mediocre_filters++; // Allowed, but not too often - else - good_filters++; - } } fprintf(stderr, "Filters: %d good, %d mediocre\n", good_filters, @@ -263,8 +263,7 @@ TEST_F(DynamicBloomTest, concurrent_with_perf) { StopWatchNano timer(Env::Default()); timer.Start(); for (uint64_t i = 1 + t; i <= num_keys; i += num_threads) { - bool f = - std_bloom.MayContain(km.Seq(i)); + bool f = std_bloom.MayContain(km.Seq(i)); ASSERT_TRUE(f); } elapsed += timer.ElapsedNanos(); @@ -289,8 +288,7 @@ TEST_F(DynamicBloomTest, concurrent_with_perf) { timer.Start(); for (uint64_t i = num_keys + 1 + t; i <= 2 * num_keys; i += num_threads) { - bool f = - std_bloom.MayContain(km.Seq(i)); + bool f = std_bloom.MayContain(km.Seq(i)); if (f) { ++false_positives; } diff --git a/util/mutexlock.h b/util/mutexlock.h index 90e6c8b99..7516683a7 100644 --- a/util/mutexlock.h +++ b/util/mutexlock.h @@ -32,8 +32,8 @@ class MutexLock { this->mu_->Lock(); } // No copying allowed - MutexLock(const MutexLock&) = delete; - void operator=(const MutexLock&) = delete; + MutexLock(const MutexLock &) = delete; + void operator=(const MutexLock &) = delete; ~MutexLock() { this->mu_->Unlock(); } @@ -52,8 +52,8 @@ class ReadLock { this->mu_->ReadLock(); } // No copying allowed - ReadLock(const ReadLock&) = delete; - void operator=(const ReadLock&) = delete; + ReadLock(const ReadLock &) = delete; + void operator=(const ReadLock &) = delete; ~ReadLock() { this->mu_->ReadUnlock(); } @@ -88,8 +88,8 @@ class WriteLock { this->mu_->WriteLock(); } // No copying allowed - WriteLock(const WriteLock&) = delete; - void operator=(const WriteLock&) = delete; + WriteLock(const WriteLock &) = delete; + void operator=(const WriteLock &) = delete; ~WriteLock() { this->mu_->WriteUnlock(); } diff --git a/utilities/transactions/write_unprepared_txn_db.cc b/utilities/transactions/write_unprepared_txn_db.cc index b883f4496..9d3417f9c 100644 --- a/utilities/transactions/write_unprepared_txn_db.cc +++ b/utilities/transactions/write_unprepared_txn_db.cc @@ -5,8 +5,8 @@ #ifndef ROCKSDB_LITE -#include "db/arena_wrapped_db_iter.h" #include "utilities/transactions/write_unprepared_txn_db.h" +#include "db/arena_wrapped_db_iter.h" #include "rocksdb/utilities/transaction_db.h" #include "util/cast_util.h"