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/compaction/compaction_iterator.h

@@ -59,9 +59,9 @@ class CompactionIterator {
     const Compaction* compaction_;
   };
 
-  CompactionIterator(InternalIterator* input, const Comparator* cmp,
-                     MergeHelper* merge_helper, SequenceNumber last_sequence,
-                     std::vector<SequenceNumber>* snapshots,
+  CompactionIterator(
+      InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
+      SequenceNumber last_sequence, std::vector<SequenceNumber>* snapshots,
       SequenceNumber earliest_write_conflict_snapshot,
       const SnapshotChecker* snapshot_checker, Env* env,
       bool report_detailed_time, bool expect_valid_internal_key,
@@ -73,9 +73,9 @@ class CompactionIterator {
       const std::atomic<bool>* 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<SequenceNumber>* snapshots,
+  CompactionIterator(
+      InternalIterator* input, const Comparator* cmp, MergeHelper* merge_helper,
+      SequenceNumber last_sequence, std::vector<SequenceNumber>* snapshots,
       SequenceNumber earliest_write_conflict_snapshot,
       const SnapshotChecker* snapshot_checker, Env* env,
       bool report_detailed_time, bool expect_valid_internal_key,

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<void *>(
-        const_cast<std::atomic<bool> *>(manual_compaction_paused_)));
+  TEST_SYNC_POINT_CALLBACK(
+      "CompactionJob::Run():PausingManualCompaction:1",
+      reinterpret_cast<void*>(
+          const_cast<std::atomic<bool>*>(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<void *>(
-          const_cast<std::atomic<bool> *>(manual_compaction_paused_)));
+    TEST_SYNC_POINT_CALLBACK(
+        "CompactionJob::Run():PausingManualCompaction:2",
+        reinterpret_cast<void*>(
+            const_cast<std::atomic<bool>*>(manual_compaction_paused_)));
     c_iter->Next();
     if (c_iter->status().IsManualCompactionPaused()) {
       break;

db/compaction/compaction_job.h

@@ -62,19 +62,21 @@ class VersionSet;
 // if needed.
 class CompactionJob {
  public:
-  CompactionJob(
-      int job_id, Compaction* compaction, const ImmutableDBOptions& db_options,
+  CompactionJob(int job_id, Compaction* compaction,
+                const ImmutableDBOptions& db_options,
                 const EnvOptions env_options, VersionSet* versions,
                 const std::atomic<bool>* shutting_down,
-      const SequenceNumber preserve_deletes_seqnum, LogBuffer* log_buffer,
-      Directory* db_directory, Directory* output_directory, Statistics* stats,
+                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<SequenceNumber> existing_snapshots,
                 SequenceNumber earliest_write_conflict_snapshot,
                 const SnapshotChecker* snapshot_checker,
                 std::shared_ptr<Cache> table_cache, EventLogger* event_logger,
                 bool paranoid_file_checks, bool measure_io_stats,
-      const std::string& dbname, CompactionJobStats* compaction_job_stats,
+                const std::string& dbname,
+                CompactionJobStats* compaction_job_stats,
                 Env::Priority thread_pri,
                 const std::atomic<bool>* manual_compaction_paused = nullptr);
 

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);

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"

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();

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);
       }
     }

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<String>(Arrays.asList(value.split(",")));
       }

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 <jni.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <jni.h>
 
 #include "include/org_rocksdb_SstFileReaderIterator.h"
-#include "rocksjni/portal.h"
 #include "rocksdb/iterator.h"
+#include "rocksjni/portal.h"
 
 /*
  * Class:     org_rocksdb_SstFileReaderIterator
@@ -65,7 +65,8 @@ 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<rocksdb::Iterator*>(handle)->Next();
 }
@@ -75,7 +76,8 @@ 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<rocksdb::Iterator*>(handle)->Prev();
 }
@@ -86,16 +88,16 @@ 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) {
+  if (target == nullptr) {
     // exception thrown: OutOfMemoryError
     return;
   }
 
-    rocksdb::Slice target_slice(
-            reinterpret_cast<char*>(target), jtarget_len);
+  rocksdb::Slice target_slice(reinterpret_cast<char*>(target), jtarget_len);
 
   auto* it = reinterpret_cast<rocksdb::Iterator*>(handle);
   it->Seek(target_slice);
@@ -108,18 +110,18 @@ 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) {
+  if (target == nullptr) {
     // exception thrown: OutOfMemoryError
     return;
   }
 
-    rocksdb::Slice target_slice(
-            reinterpret_cast<char*>(target), jtarget_len);
+  rocksdb::Slice target_slice(reinterpret_cast<char*>(target), jtarget_len);
 
   auto* it = reinterpret_cast<rocksdb::Iterator*>(handle);
   it->SeekForPrev(target_slice);
@@ -132,7 +134,8 @@ 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<rocksdb::Iterator*>(handle);
   rocksdb::Status s = it->status();
@@ -149,17 +152,19 @@ 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<rocksdb::Iterator*>(handle);
   rocksdb::Slice key_slice = it->key();
 
   jbyteArray jkey = env->NewByteArray(static_cast<jsize>(key_slice.size()));
-    if(jkey == nullptr) {
+  if (jkey == nullptr) {
     // exception thrown: OutOfMemoryError
     return nullptr;
   }
-    env->SetByteArrayRegion(jkey, 0, static_cast<jsize>(key_slice.size()),
+  env->SetByteArrayRegion(
+      jkey, 0, static_cast<jsize>(key_slice.size()),
       const_cast<jbyte*>(reinterpret_cast<const jbyte*>(key_slice.data())));
   return jkey;
 }

java/rocksjni/sst_file_readerjni.cc

@@ -53,17 +53,17 @@ 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<rocksdb::SstFileReader*>(jhandle);
-    auto* read_options =
-        reinterpret_cast<rocksdb::ReadOptions*>(jread_options_handle);
+  auto *sst_file_reader = reinterpret_cast<rocksdb::SstFileReader *>(jhandle);
+  auto *read_options =
+      reinterpret_cast<rocksdb::ReadOptions *>(jread_options_handle);
   return reinterpret_cast<jlong>(sst_file_reader->NewIterator(*read_options));
 }
 
@@ -86,7 +86,7 @@ void Java_org_rocksdb_SstFileReader_disposeInternal(JNIEnv * /*env*/,
 void Java_org_rocksdb_SstFileReader_verifyChecksum(JNIEnv *env,
                                                    jobject /*jobj*/,
                                                    jlong jhandle) {
-  auto* sst_file_reader = reinterpret_cast<rocksdb::SstFileReader*>(jhandle);
+  auto *sst_file_reader = reinterpret_cast<rocksdb::SstFileReader *>(jhandle);
   auto s = sst_file_reader->VerifyChecksum();
   if (!s.ok()) {
     rocksdb::RocksDBExceptionJni::ThrowNew(env, s);
@@ -101,10 +101,10 @@ void Java_org_rocksdb_SstFileReader_verifyChecksum(JNIEnv *env,
 jobject Java_org_rocksdb_SstFileReader_getTableProperties(JNIEnv *env,
                                                           jobject /*jobj*/,
                                                           jlong jhandle) {
-  auto* sst_file_reader = reinterpret_cast<rocksdb::SstFileReader*>(jhandle);
-  std::shared_ptr<const rocksdb::TableProperties> tp = sst_file_reader->GetTableProperties();
-  jobject jtable_properties = rocksdb::TablePropertiesJni::fromCppTableProperties(
-      env, *(tp.get()));
+  auto *sst_file_reader = reinterpret_cast<rocksdb::SstFileReader *>(jhandle);
+  std::shared_ptr<const rocksdb::TableProperties> tp =
+      sst_file_reader->GetTableProperties();
+  jobject jtable_properties =
+      rocksdb::TablePropertiesJni::fromCppTableProperties(env, *(tp.get()));
   return jtable_properties;
 }
-

java/src/main/java/org/rocksdb/SstFileReader.java

@@ -31,9 +31,8 @@ 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);
   }
 
@@ -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;

java/src/main/java/org/rocksdb/SstFileReaderIterator.java

@@ -33,7 +33,7 @@ public class SstFileReaderIterator extends AbstractRocksIterator<SstFileReader>
    * @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<SstFileReader>
    * @return value for the current entry.
    */
   public byte[] value() {
-    assert(isOwningHandle());
+    assert (isOwningHandle());
     return value0(nativeHandle_);
   }
 

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<KeyValueWithOp> keyValues) throws IOException, RocksDBException {
+  private File newSstFile(final List<KeyValueWithOp> 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<KeyValueWithOp> 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());
     }
   }
-
 }

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<TableFactory>)},
-      {offset_of(&ColumnFamilyOptions::cf_paths),
-       sizeof(std::vector<DbPath>)},
+      {offset_of(&ColumnFamilyOptions::cf_paths), sizeof(std::vector<DbPath>)},
       {offset_of(&ColumnFamilyOptions::compaction_thread_limiter),
        sizeof(std::shared_ptr<ConcurrentTaskLimiter>)},
   };

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<uint64_t>(hist_naccess_per_key.Average());
-        uint64_t stdev_accesses = static_cast<uint64_t>(hist_naccess_per_key.StandardDeviation());
+        uint64_t avg_accesses =
+            static_cast<uint64_t>(hist_naccess_per_key.Average());
+        uint64_t stdev_accesses =
+            static_cast<uint64_t>(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);

tools/db_stress.cc

@@ -353,7 +353,8 @@ 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 "
+DEFINE_bool(partition_filters, false,
+            "use partitioned filters "
             "for block-based table");
 
 DEFINE_int32(

tools/sst_dump_tool.cc

@@ -405,7 +405,8 @@ Status SstFileDumper::ReadTableProperties(
 namespace {
 
 void print_help() {
-  fprintf(stderr,
+  fprintf(
+      stderr,
       R"(sst_dump --file=<data_dir_OR_sst_file> [--command=check|scan|raw|recompress]
     --file=<data_dir_OR_sst_file>
       Path to SST file or directory containing SST files

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 <bool ExtraRotates>
 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,

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();
 

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 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 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)
 
 extern uint32_t crc32c_arm64(uint32_t crc, unsigned char const *data, unsigned len);
 extern uint32_t crc32c_runtime_check(void);

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) {

util/dynamic_bloom_test.cc

@@ -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;
         }

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(); }
 

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"